RTEMS 4.11
Annotated Report
Thu Dec 20 17:12:54 2012

4000b480 <IMFS_chown>:                                                
int IMFS_chown(                                                       
  const rtems_filesystem_location_info_t *loc,                        
  uid_t owner,                                                        
  gid_t group                                                         
)                                                                     
{                                                                     
4000b480:	9d e3 bf 98 	save  %sp, -104, %sp                           
  /*                                                                  
   *  Verify I am the owner of the node or the super user.            
   */                                                                 
                                                                      
#if defined(RTEMS_POSIX_API)                                          
  st_uid = geteuid();                                                 
4000b484:	40 00 02 6e 	call  4000be3c <geteuid>                       
4000b488:	fa 06 20 08 	ld  [ %i0 + 8 ], %i5                           
                                                                      
  if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )               
4000b48c:	c2 17 60 3c 	lduh  [ %i5 + 0x3c ], %g1                      
4000b490:	91 2a 20 10 	sll  %o0, 0x10, %o0                            
4000b494:	91 32 20 10 	srl  %o0, 0x10, %o0                            
4000b498:	80 a0 40 08 	cmp  %g1, %o0                                  
4000b49c:	02 80 00 04 	be  4000b4ac <IMFS_chown+0x2c>                 
4000b4a0:	80 a2 20 00 	cmp  %o0, 0                                    
4000b4a4:	12 80 00 0b 	bne  4000b4d0 <IMFS_chown+0x50>                <== ALWAYS TAKEN
4000b4a8:	01 00 00 00 	nop                                            
    rtems_set_errno_and_return_minus_one( EPERM );                    
#endif                                                                
                                                                      
  jnode->st_uid = owner;                                              
4000b4ac:	f2 37 60 3c 	sth  %i1, [ %i5 + 0x3c ]                       
  jnode->st_gid = group;                                              
4000b4b0:	f4 37 60 3e 	sth  %i2, [ %i5 + 0x3e ]                       
                                                                      
  IMFS_update_ctime( jnode );                                         
4000b4b4:	90 07 bf f8 	add  %fp, -8, %o0                              
4000b4b8:	7f ff df 06 	call  400030d0 <gettimeofday>                  
4000b4bc:	92 10 20 00 	clr  %o1                                       
4000b4c0:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
4000b4c4:	c2 27 60 48 	st  %g1, [ %i5 + 0x48 ]                        
                                                                      
  return 0;                                                           
}                                                                     
4000b4c8:	81 c7 e0 08 	ret                                            
4000b4cc:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      
#if defined(RTEMS_POSIX_API)                                          
  st_uid = geteuid();                                                 
                                                                      
  if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )               
    rtems_set_errno_and_return_minus_one( EPERM );                    
4000b4d0:	40 00 10 9c 	call  4000f740 <__errno>                       
4000b4d4:	b0 10 3f ff 	mov  -1, %i0                                   
4000b4d8:	82 10 20 01 	mov  1, %g1                                    
4000b4dc:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4000b4e0:	81 c7 e0 08 	ret                                            
4000b4e4:	81 e8 00 00 	restore                                        
                                                                      

400051f0 <IMFS_dump_directory>: */ static void IMFS_dump_directory( IMFS_jnode_t *the_directory, int level ) {
400051f0:	9d e3 bf a0 	save  %sp, -96, %sp                            
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return _Chain_Head( the_chain )->next;                              
400051f4:	f4 06 20 50 	ld  [ %i0 + 0x50 ], %i2                        
400051f8:	39 10 00 97 	sethi  %hi(0x40025c00), %i4                    
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(                             
  const Chain_Control *the_chain,                                     
  const Chain_Node    *the_node                                       
)                                                                     
{                                                                     
  return (the_node == _Chain_Immutable_tail( the_chain ));            
400051fc:	b0 06 20 54 	add  %i0, 0x54, %i0                            
  IMFS_assert( level >= 0 );                                          
  IMFS_assert( IMFS_is_directory( the_directory ) );                  
                                                                      
  the_chain = &the_directory->info.directory.Entries;                 
                                                                      
  for ( the_node = rtems_chain_first( the_chain );                    
40005200:	80 a6 80 18 	cmp  %i2, %i0                                  
40005204:	02 80 00 30 	be  400052c4 <IMFS_dump_directory+0xd4>        
40005208:	b8 17 20 b8 	or  %i4, 0xb8, %i4                             
4000520c:	37 10 00 8f 	sethi  %hi(0x40023c00), %i3                    
    case IMFS_FIFO:                                                   
      fprintf(stdout, " FIFO not printed\n" );                        
      return;                                                         
                                                                      
    default:                                                          
      fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );     
40005210:	29 10 00 8f 	sethi  %hi(0x40023c00), %l4                    
      return;                                                         
  }                                                                   
  puts("");                                                           
40005214:	21 10 00 8f 	sethi  %hi(0x40023c00), %l0                    
    case IMFS_SYM_LINK:                                               
      fprintf(stdout, " links not printed\n" );                       
      return;                                                         
                                                                      
    case IMFS_FIFO:                                                   
      fprintf(stdout, " FIFO not printed\n" );                        
40005218:	27 10 00 8f 	sethi  %hi(0x40023c00), %l3                    
    case IMFS_HARD_LINK:                                              
      fprintf(stdout, " links not printed\n" );                       
      return;                                                         
                                                                      
    case IMFS_SYM_LINK:                                               
      fprintf(stdout, " links not printed\n" );                       
4000521c:	25 10 00 8f 	sethi  %hi(0x40023c00), %l2                    
        the_node = the_node->next ) {                                 
                                                                      
    the_jnode = (IMFS_jnode_t *) the_node;                            
                                                                      
    for ( i=0 ; i<=level ; i++ )                                      
      fprintf(stdout, "...." );                                       
40005220:	b6 16 e1 e0 	or  %i3, 0x1e0, %i3                            
    case IMFS_FIFO:                                                   
      fprintf(stdout, " FIFO not printed\n" );                        
      return;                                                         
                                                                      
    default:                                                          
      fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );     
40005224:	a8 15 22 50 	or  %l4, 0x250, %l4                            
      return;                                                         
  }                                                                   
  puts("");                                                           
40005228:	a0 14 20 d0 	or  %l0, 0xd0, %l0                             
    case IMFS_SYM_LINK:                                               
      fprintf(stdout, " links not printed\n" );                       
      return;                                                         
                                                                      
    case IMFS_FIFO:                                                   
      fprintf(stdout, " FIFO not printed\n" );                        
4000522c:	a6 14 e2 38 	or  %l3, 0x238, %l3                            
    case IMFS_HARD_LINK:                                              
      fprintf(stdout, " links not printed\n" );                       
      return;                                                         
                                                                      
    case IMFS_SYM_LINK:                                               
      fprintf(stdout, " links not printed\n" );                       
40005230:	a4 14 a2 20 	or  %l2, 0x220, %l2                            
                                                                      
    for ( i=0 ; i<=level ; i++ )                                      
      fprintf(stdout, "...." );                                       
    IMFS_print_jnode( the_jnode );                                    
    if ( IMFS_is_directory( the_jnode ) )                             
      IMFS_dump_directory( the_jnode, level + 1 );                    
40005234:	a2 06 60 01 	add  %i1, 1, %l1                               
        !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++ )                                      
40005238:	80 a6 60 00 	cmp  %i1, 0                                    
4000523c:	06 80 00 0c 	bl  4000526c <IMFS_dump_directory+0x7c>        <== NEVER TAKEN
40005240:	ba 10 20 00 	clr  %i5                                       
      fprintf(stdout, "...." );                                       
40005244:	c2 07 00 00 	ld  [ %i4 ], %g1                               
40005248:	90 10 00 1b 	mov  %i3, %o0                                  
4000524c:	d6 00 60 08 	ld  [ %g1 + 8 ], %o3                           
40005250:	92 10 20 01 	mov  1, %o1                                    
40005254:	40 00 3e 0c 	call  40014a84 <fwrite>                        
40005258:	94 10 20 04 	mov  4, %o2                                    
        !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++ )                                      
4000525c:	ba 07 60 01 	inc  %i5                                       
40005260:	80 a6 40 1d 	cmp  %i1, %i5                                  
40005264:	36 bf ff f9 	bge,a   40005248 <IMFS_dump_directory+0x58>    
40005268:	c2 07 00 00 	ld  [ %i4 ], %g1                               
  IMFS_jnode_t *the_jnode                                             
)                                                                     
{                                                                     
  IMFS_assert( the_jnode );                                           
                                                                      
  fprintf(stdout, "%s", the_jnode->name );                            
4000526c:	c2 07 00 00 	ld  [ %i4 ], %g1                               
40005270:	90 06 a0 0c 	add  %i2, 0xc, %o0                             
40005274:	40 00 3a e6 	call  40013e0c <fputs>                         
40005278:	d2 00 60 08 	ld  [ %g1 + 8 ], %o1                           
  rtems_chain_extract_unprotected( &node->Node );                     
}                                                                     
                                                                      
static inline IMFS_jnode_types_t IMFS_type( const IMFS_jnode_t *node )
{                                                                     
  return node->control->imfs_type;                                    
4000527c:	c2 06 a0 4c 	ld  [ %i2 + 0x4c ], %g1                        
40005280:	d4 00 40 00 	ld  [ %g1 ], %o2                               
  switch( IMFS_type( the_jnode ) ) {                                  
40005284:	80 a2 a0 06 	cmp  %o2, 6                                    
40005288:	28 80 00 11 	bleu,a   400052cc <IMFS_dump_directory+0xdc>   <== ALWAYS TAKEN
4000528c:	95 2a a0 02 	sll  %o2, 2, %o2                               
    case IMFS_FIFO:                                                   
      fprintf(stdout, " FIFO not printed\n" );                        
      return;                                                         
                                                                      
    default:                                                          
      fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );     
40005290:	c2 07 00 00 	ld  [ %i4 ], %g1                               <== NOT EXECUTED
40005294:	92 10 00 14 	mov  %l4, %o1                                  <== NOT EXECUTED
40005298:	40 00 3a 8d 	call  40013ccc <fprintf>                       <== NOT EXECUTED
4000529c:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           <== NOT EXECUTED
}                                                                     
                                                                      
static inline bool IMFS_is_directory( const IMFS_jnode_t *node )      
{                                                                     
  return node->control->imfs_type == IMFS_DIRECTORY;                  
400052a0:	c2 06 a0 4c 	ld  [ %i2 + 0x4c ], %g1                        <== NOT EXECUTED
    the_jnode = (IMFS_jnode_t *) the_node;                            
                                                                      
    for ( i=0 ; i<=level ; i++ )                                      
      fprintf(stdout, "...." );                                       
    IMFS_print_jnode( the_jnode );                                    
    if ( IMFS_is_directory( the_jnode ) )                             
400052a4:	c2 00 40 00 	ld  [ %g1 ], %g1                               
400052a8:	80 a0 60 00 	cmp  %g1, 0                                    
400052ac:	22 80 00 19 	be,a   40005310 <IMFS_dump_directory+0x120>    
400052b0:	90 10 00 1a 	mov  %i2, %o0                                  
                                                                      
  the_chain = &the_directory->info.directory.Entries;                 
                                                                      
  for ( the_node = rtems_chain_first( the_chain );                    
        !rtems_chain_is_tail( the_chain, the_node );                  
        the_node = the_node->next ) {                                 
400052b4:	f4 06 80 00 	ld  [ %i2 ], %i2                               
  IMFS_assert( level >= 0 );                                          
  IMFS_assert( IMFS_is_directory( the_directory ) );                  
                                                                      
  the_chain = &the_directory->info.directory.Entries;                 
                                                                      
  for ( the_node = rtems_chain_first( the_chain );                    
400052b8:	80 a6 80 18 	cmp  %i2, %i0                                  
400052bc:	12 bf ff e0 	bne  4000523c <IMFS_dump_directory+0x4c>       
400052c0:	80 a6 60 00 	cmp  %i1, 0                                    
400052c4:	81 c7 e0 08 	ret                                            
400052c8:	81 e8 00 00 	restore                                        
)                                                                     
{                                                                     
  IMFS_assert( the_jnode );                                           
                                                                      
  fprintf(stdout, "%s", the_jnode->name );                            
  switch( IMFS_type( the_jnode ) ) {                                  
400052cc:	03 10 00 14 	sethi  %hi(0x40005000), %g1                    
400052d0:	82 10 61 d4 	or  %g1, 0x1d4, %g1	! 400051d4 <bsp_interrupt_handler_default+0x18>
400052d4:	c2 00 40 0a 	ld  [ %g1 + %o2 ], %g1                         
400052d8:	81 c0 40 00 	jmp  %g1                                       
400052dc:	01 00 00 00 	nop                                            
    case IMFS_HARD_LINK:                                              
      fprintf(stdout, " links not printed\n" );                       
      return;                                                         
                                                                      
    case IMFS_SYM_LINK:                                               
      fprintf(stdout, " links not printed\n" );                       
400052e0:	c2 07 00 00 	ld  [ %i4 ], %g1                               
400052e4:	90 10 00 12 	mov  %l2, %o0                                  
400052e8:	d6 00 60 08 	ld  [ %g1 + 8 ], %o3                           
400052ec:	92 10 20 01 	mov  1, %o1                                    
400052f0:	40 00 3d e5 	call  40014a84 <fwrite>                        
400052f4:	94 10 20 13 	mov  0x13, %o2                                 
400052f8:	c2 06 a0 4c 	ld  [ %i2 + 0x4c ], %g1                        
    the_jnode = (IMFS_jnode_t *) the_node;                            
                                                                      
    for ( i=0 ; i<=level ; i++ )                                      
      fprintf(stdout, "...." );                                       
    IMFS_print_jnode( the_jnode );                                    
    if ( IMFS_is_directory( the_jnode ) )                             
400052fc:	c2 00 40 00 	ld  [ %g1 ], %g1                               
40005300:	80 a0 60 00 	cmp  %g1, 0                                    
40005304:	32 bf ff ed 	bne,a   400052b8 <IMFS_dump_directory+0xc8>    <== ALWAYS TAKEN
40005308:	f4 06 80 00 	ld  [ %i2 ], %i2                               
      IMFS_dump_directory( the_jnode, level + 1 );                    
4000530c:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
40005310:	7f ff ff b8 	call  400051f0 <IMFS_dump_directory>           
40005314:	92 10 00 11 	mov  %l1, %o1                                  
                                                                      
  the_chain = &the_directory->info.directory.Entries;                 
                                                                      
  for ( the_node = rtems_chain_first( the_chain );                    
        !rtems_chain_is_tail( the_chain, the_node );                  
        the_node = the_node->next ) {                                 
40005318:	10 bf ff e8 	b  400052b8 <IMFS_dump_directory+0xc8>         
4000531c:	f4 06 80 00 	ld  [ %i2 ], %i2                               
      fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",           
        the_jnode->info.device.major, the_jnode->info.device.minor ); 
      break;                                                          
                                                                      
    case IMFS_LINEAR_FILE:                                            
      fprintf(stdout, " (file %" PRId32 " %p)",                       
40005320:	c2 07 00 00 	ld  [ %i4 ], %g1                               
40005324:	d4 06 a0 54 	ld  [ %i2 + 0x54 ], %o2                        
40005328:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           
4000532c:	d6 06 a0 58 	ld  [ %i2 + 0x58 ], %o3                        
40005330:	13 10 00 8f 	sethi  %hi(0x40023c00), %o1                    
40005334:	40 00 3a 66 	call  40013ccc <fprintf>                       
40005338:	92 12 62 00 	or  %o1, 0x200, %o1	! 40023e00 <__FUNCTION__.6193+0x278>
                                                                      
    default:                                                          
      fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );     
      return;                                                         
  }                                                                   
  puts("");                                                           
4000533c:	40 00 41 d3 	call  40015a88 <puts>                          
40005340:	90 10 00 10 	mov  %l0, %o0                                  
40005344:	10 bf ff d8 	b  400052a4 <IMFS_dump_directory+0xb4>         
40005348:	c2 06 a0 4c 	ld  [ %i2 + 0x4c ], %g1                        
    case IMFS_DIRECTORY:                                              
      fprintf(stdout, "/" );                                          
      break;                                                          
                                                                      
    case IMFS_DEVICE:                                                 
      fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",           
4000534c:	c2 07 00 00 	ld  [ %i4 ], %g1                               
40005350:	d4 06 a0 50 	ld  [ %i2 + 0x50 ], %o2                        
40005354:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           
40005358:	d6 06 a0 54 	ld  [ %i2 + 0x54 ], %o3                        
4000535c:	13 10 00 8f 	sethi  %hi(0x40023c00), %o1                    
40005360:	40 00 3a 5b 	call  40013ccc <fprintf>                       
40005364:	92 12 61 e8 	or  %o1, 0x1e8, %o1	! 40023de8 <__FUNCTION__.6193+0x260>
40005368:	30 bf ff f5 	b,a   4000533c <IMFS_dump_directory+0x14c>     
  IMFS_assert( the_jnode );                                           
                                                                      
  fprintf(stdout, "%s", the_jnode->name );                            
  switch( IMFS_type( the_jnode ) ) {                                  
    case IMFS_DIRECTORY:                                              
      fprintf(stdout, "/" );                                          
4000536c:	c2 07 00 00 	ld  [ %i4 ], %g1                               
40005370:	90 10 20 2f 	mov  0x2f, %o0                                 
40005374:	40 00 3a 72 	call  40013d3c <fputc>                         
40005378:	d2 00 60 08 	ld  [ %g1 + 8 ], %o1                           
4000537c:	30 bf ff f0 	b,a   4000533c <IMFS_dump_directory+0x14c>     
    case IMFS_SYM_LINK:                                               
      fprintf(stdout, " links not printed\n" );                       
      return;                                                         
                                                                      
    case IMFS_FIFO:                                                   
      fprintf(stdout, " FIFO not printed\n" );                        
40005380:	c2 07 00 00 	ld  [ %i4 ], %g1                               
40005384:	90 10 00 13 	mov  %l3, %o0                                  
40005388:	d6 00 60 08 	ld  [ %g1 + 8 ], %o3                           
4000538c:	92 10 20 01 	mov  1, %o1                                    
40005390:	40 00 3d bd 	call  40014a84 <fwrite>                        
40005394:	94 10 20 12 	mov  0x12, %o2                                 
40005398:	10 bf ff c3 	b  400052a4 <IMFS_dump_directory+0xb4>         
4000539c:	c2 06 a0 4c 	ld  [ %i2 + 0x4c ], %g1                        
        the_jnode->info.file.indirect,                                
        the_jnode->info.file.doubly_indirect,                         
        the_jnode->info.file.triply_indirect                          
      );                                                              
#else                                                                 
      fprintf(stdout, " (file %" PRId32 ")",                          
400053a0:	c2 07 00 00 	ld  [ %i4 ], %g1                               
400053a4:	d4 06 a0 54 	ld  [ %i2 + 0x54 ], %o2                        
400053a8:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           
400053ac:	13 10 00 8f 	sethi  %hi(0x40023c00), %o1                    
400053b0:	40 00 3a 47 	call  40013ccc <fprintf>                       
400053b4:	92 12 62 10 	or  %o1, 0x210, %o1	! 40023e10 <__FUNCTION__.6193+0x288>
400053b8:	30 bf ff e1 	b,a   4000533c <IMFS_dump_directory+0x14c>     
                                                                      

4000b62c <IMFS_eval_token>: rtems_filesystem_eval_path_context_t *ctx, void *arg, const char *token, size_t tokenlen ) {
4000b62c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_filesystem_eval_path_generic_status status =                  
    RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;                          
  rtems_filesystem_location_info_t *currentloc =                      
    rtems_filesystem_eval_path_get_currentloc( ctx );                 
  IMFS_jnode_t *dir = currentloc->node_access;                        
4000b630:	f8 06 20 20 	ld  [ %i0 + 0x20 ], %i4                        
  bool access_ok = rtems_filesystem_eval_path_check_access(           
4000b634:	90 10 00 18 	mov  %i0, %o0                                  
4000b638:	d4 07 20 30 	ld  [ %i4 + 0x30 ], %o2                        
4000b63c:	d6 17 20 3c 	lduh  [ %i4 + 0x3c ], %o3                      
4000b640:	d8 17 20 3e 	lduh  [ %i4 + 0x3e ], %o4                      
4000b644:	40 00 03 24 	call  4000c2d4 <rtems_filesystem_eval_path_check_access>
4000b648:	92 10 20 01 	mov  1, %o1                                    
    dir->st_mode,                                                     
    dir->st_uid,                                                      
    dir->st_gid                                                       
  );                                                                  
                                                                      
  if ( access_ok ) {                                                  
4000b64c:	80 8a 20 ff 	btst  0xff, %o0                                
4000b650:	12 80 00 04 	bne  4000b660 <IMFS_eval_token+0x34>           
4000b654:	80 a6 e0 01 	cmp  %i3, 1                                    
                                                                      
      if ( type == IMFS_HARD_LINK && (follow_hard_link || !terminal)) {
        entry = entry->info.hard_link.link_node;                      
      }                                                               
                                                                      
      if ( type == IMFS_SYM_LINK && (follow_sym_link || !terminal)) { 
4000b658:	81 c7 e0 08 	ret                                            
4000b65c:	91 e8 20 01 	restore  %g0, 1, %o0                           
static inline bool rtems_filesystem_is_current_directory(             
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  return tokenlen == 1 && token [0] == '.';                           
4000b660:	02 80 00 58 	be  4000b7c0 <IMFS_eval_token+0x194>           
4000b664:	80 a6 e0 02 	cmp  %i3, 2                                    
static inline bool rtems_filesystem_is_parent_directory(              
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  return tokenlen == 2 && token [0] == '.' && token [1] == '.';       
4000b668:	22 80 00 37 	be,a   4000b744 <IMFS_eval_token+0x118>        
4000b66c:	c2 4e 80 00 	ldsb  [ %i2 ], %g1                             
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return _Chain_Head( the_chain )->next;                              
4000b670:	fa 07 20 50 	ld  [ %i4 + 0x50 ], %i5                        
    if ( rtems_filesystem_is_parent_directory( token, tokenlen ) ) {  
      return dir->Parent;                                             
    } else {                                                          
      rtems_chain_control *entries = &dir->info.directory.Entries;    
      rtems_chain_node *current = rtems_chain_first( entries );       
      rtems_chain_node *tail = rtems_chain_tail( entries );           
4000b674:	b2 07 20 54 	add  %i4, 0x54, %i1                            
                                                                      
      while ( current != tail ) {                                     
4000b678:	80 a7 40 19 	cmp  %i5, %i1                                  
4000b67c:	02 80 00 30 	be  4000b73c <IMFS_eval_token+0x110>           
4000b680:	90 07 60 0c 	add  %i5, 0xc, %o0                             
        IMFS_jnode_t *entry = (IMFS_jnode_t *) current;               
        bool match = strncmp( entry->name, token, tokenlen ) == 0     
4000b684:	92 10 00 1a 	mov  %i2, %o1                                  
4000b688:	40 00 15 c5 	call  40010d9c <strncmp>                       
4000b68c:	94 10 00 1b 	mov  %i3, %o2                                  
          && entry->name [tokenlen] == '\0';                          
4000b690:	80 a2 20 00 	cmp  %o0, 0                                    
4000b694:	12 80 00 26 	bne  4000b72c <IMFS_eval_token+0x100>          
4000b698:	82 07 40 1b 	add  %i5, %i3, %g1                             
4000b69c:	c2 48 60 0c 	ldsb  [ %g1 + 0xc ], %g1                       
4000b6a0:	80 a0 60 00 	cmp  %g1, 0                                    
4000b6a4:	32 80 00 23 	bne,a   4000b730 <IMFS_eval_token+0x104>       
4000b6a8:	fa 07 40 00 	ld  [ %i5 ], %i5                               
  rtems_chain_extract_unprotected( &node->Node );                     
}                                                                     
                                                                      
static inline IMFS_jnode_types_t IMFS_type( const IMFS_jnode_t *node )
{                                                                     
  return node->control->imfs_type;                                    
4000b6ac:	c2 07 60 4c 	ld  [ %i5 + 0x4c ], %g1                        
                                                                      
  if ( access_ok ) {                                                  
    IMFS_jnode_t *entry = IMFS_search_in_directory( dir, token, tokenlen );
                                                                      
    if ( entry != NULL ) {                                            
      bool terminal = !rtems_filesystem_eval_path_has_path( ctx );    
4000b6b0:	c4 06 20 04 	ld  [ %i0 + 4 ], %g2                           
4000b6b4:	c2 00 40 00 	ld  [ %g1 ], %g1                               
4000b6b8:	80 a0 00 02 	cmp  %g0, %g2                                  
                                                                      
static inline void rtems_filesystem_eval_path_clear_token(            
  rtems_filesystem_eval_path_context_t *ctx                           
)                                                                     
{                                                                     
  ctx->tokenlen = 0;                                                  
4000b6bc:	c0 26 20 0c 	clr  [ %i0 + 0xc ]                             
4000b6c0:	84 60 3f ff 	subx  %g0, -1, %g2                             
                                                                      
static inline int rtems_filesystem_eval_path_get_flags(               
  const rtems_filesystem_eval_path_context_t *ctx                     
)                                                                     
{                                                                     
  return ctx->flags;                                                  
4000b6c4:	c8 06 20 10 	ld  [ %i0 + 0x10 ], %g4                        
      bool follow_sym_link = (eval_flags & RTEMS_FS_FOLLOW_SYM_LINK) != 0;
      IMFS_jnode_types_t type = IMFS_type( entry );                   
                                                                      
      rtems_filesystem_eval_path_clear_token( ctx );                  
                                                                      
      if ( type == IMFS_HARD_LINK && (follow_hard_link || !terminal)) {
4000b6c8:	80 a0 60 02 	cmp  %g1, 2                                    
4000b6cc:	02 80 00 43 	be  4000b7d8 <IMFS_eval_token+0x1ac>           
4000b6d0:	86 10 00 02 	mov  %g2, %g3                                  
        entry = entry->info.hard_link.link_node;                      
      }                                                               
                                                                      
      if ( type == IMFS_SYM_LINK && (follow_sym_link || !terminal)) { 
4000b6d4:	80 a0 60 03 	cmp  %g1, 3                                    
4000b6d8:	02 80 00 28 	be  4000b778 <IMFS_eval_token+0x14c>           
4000b6dc:	80 a0 60 00 	cmp  %g1, 0                                    
  IMFS_jnode_types_t type                                             
)                                                                     
{                                                                     
  rtems_filesystem_global_location_t **fs_root_ptr = NULL;            
                                                                      
  if ( type == IMFS_DIRECTORY ) {                                     
4000b6e0:	32 80 00 2c 	bne,a   4000b790 <IMFS_eval_token+0x164>       
4000b6e4:	c4 17 20 34 	lduh  [ %i4 + 0x34 ], %g2                      
    if ( node->info.directory.mt_fs != NULL ) {                       
4000b6e8:	f6 07 60 5c 	ld  [ %i5 + 0x5c ], %i3                        
4000b6ec:	80 a6 e0 00 	cmp  %i3, 0                                    
4000b6f0:	02 80 00 27 	be  4000b78c <IMFS_eval_token+0x160>           
4000b6f4:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
          if ( !terminal ) {                                          
            status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;     
          }                                                           
        } else {                                                      
          access_ok = rtems_filesystem_eval_path_check_access(        
4000b6f8:	d4 07 60 30 	ld  [ %i5 + 0x30 ], %o2                        
4000b6fc:	d6 17 60 3c 	lduh  [ %i5 + 0x3c ], %o3                      
4000b700:	d8 17 60 3e 	lduh  [ %i5 + 0x3e ], %o4                      
4000b704:	40 00 02 f4 	call  4000c2d4 <rtems_filesystem_eval_path_check_access>
4000b708:	92 10 20 01 	mov  1, %o1                                    
            RTEMS_FS_PERMS_EXEC,                                      
            entry->st_mode,                                           
            entry->st_uid,                                            
            entry->st_gid                                             
          );                                                          
          if ( access_ok ) {                                          
4000b70c:	80 8a 20 ff 	btst  0xff, %o0                                
4000b710:	02 bf ff d2 	be  4000b658 <IMFS_eval_token+0x2c>            <== NEVER TAKEN
4000b714:	90 10 00 18 	mov  %i0, %o0                                  
            rtems_filesystem_eval_path_restart( ctx, fs_root_ptr );   
4000b718:	92 06 e0 24 	add  %i3, 0x24, %o1                            
4000b71c:	7f ff e3 2b 	call  400043c8 <rtems_filesystem_eval_path_restart>
4000b720:	b0 10 20 01 	mov  1, %i0                                    
4000b724:	81 c7 e0 08 	ret                                            
4000b728:	81 e8 00 00 	restore                                        
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(                         
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  return the_node->next;                                              
4000b72c:	fa 07 40 00 	ld  [ %i5 ], %i5                               
    } else {                                                          
      rtems_chain_control *entries = &dir->info.directory.Entries;    
      rtems_chain_node *current = rtems_chain_first( entries );       
      rtems_chain_node *tail = rtems_chain_tail( entries );           
                                                                      
      while ( current != tail ) {                                     
4000b730:	80 a6 40 1d 	cmp  %i1, %i5                                  
4000b734:	12 bf ff d4 	bne  4000b684 <IMFS_eval_token+0x58>           
4000b738:	90 07 60 0c 	add  %i5, 0xc, %o0                             
            rtems_filesystem_eval_path_restart( ctx, fs_root_ptr );   
          }                                                           
        }                                                             
      }                                                               
    } else {                                                          
      status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;           
4000b73c:	81 c7 e0 08 	ret                                            
4000b740:	91 e8 20 02 	restore  %g0, 2, %o0                           
static inline bool rtems_filesystem_is_parent_directory(              
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  return tokenlen == 2 && token [0] == '.' && token [1] == '.';       
4000b744:	80 a0 60 2e 	cmp  %g1, 0x2e                                 
4000b748:	32 bf ff cb 	bne,a   4000b674 <IMFS_eval_token+0x48>        
4000b74c:	fa 07 20 50 	ld  [ %i4 + 0x50 ], %i5                        
4000b750:	c2 4e a0 01 	ldsb  [ %i2 + 1 ], %g1                         
4000b754:	80 a0 60 2e 	cmp  %g1, 0x2e                                 
4000b758:	32 bf ff c7 	bne,a   4000b674 <IMFS_eval_token+0x48>        <== NEVER TAKEN
4000b75c:	fa 07 20 50 	ld  [ %i4 + 0x50 ], %i5                        <== NOT EXECUTED
{                                                                     
  if ( rtems_filesystem_is_current_directory( token, tokenlen ) ) {   
    return dir;                                                       
  } else {                                                            
    if ( rtems_filesystem_is_parent_directory( token, tokenlen ) ) {  
      return dir->Parent;                                             
4000b760:	fa 07 20 08 	ld  [ %i4 + 8 ], %i5                           
  );                                                                  
                                                                      
  if ( access_ok ) {                                                  
    IMFS_jnode_t *entry = IMFS_search_in_directory( dir, token, tokenlen );
                                                                      
    if ( entry != NULL ) {                                            
4000b764:	80 a7 60 00 	cmp  %i5, 0                                    
4000b768:	02 bf ff f5 	be  4000b73c <IMFS_eval_token+0x110>           
4000b76c:	01 00 00 00 	nop                                            
4000b770:	10 bf ff d0 	b  4000b6b0 <IMFS_eval_token+0x84>             
4000b774:	c2 07 60 4c 	ld  [ %i5 + 0x4c ], %g1                        
                                                                      
      if ( type == IMFS_HARD_LINK && (follow_hard_link || !terminal)) {
        entry = entry->info.hard_link.link_node;                      
      }                                                               
                                                                      
      if ( type == IMFS_SYM_LINK && (follow_sym_link || !terminal)) { 
4000b778:	80 a0 a0 00 	cmp  %g2, 0                                    
4000b77c:	02 80 00 20 	be  4000b7fc <IMFS_eval_token+0x1d0>           
4000b780:	80 89 20 10 	btst  0x10, %g4                                
4000b784:	32 80 00 1f 	bne,a   4000b800 <IMFS_eval_token+0x1d4>       
4000b788:	fa 07 60 50 	ld  [ %i5 + 0x50 ], %i5                        
      } else {                                                        
        rtems_filesystem_global_location_t **fs_root_ptr =            
          IMFS_is_mount_point( entry, type );                         
                                                                      
        if ( fs_root_ptr == NULL ) {                                  
          --dir->reference_count;                                     
4000b78c:	c4 17 20 34 	lduh  [ %i4 + 0x34 ], %g2                      
                                                                      
static inline void IMFS_Set_handlers( rtems_filesystem_location_info_t *loc )
{                                                                     
  IMFS_jnode_t *node = (IMFS_jnode_t *) loc->node_access;             
                                                                      
  loc->handlers = node->control->handlers;                            
4000b790:	c2 07 60 4c 	ld  [ %i5 + 0x4c ], %g1                        
4000b794:	84 00 bf ff 	add  %g2, -1, %g2                              
4000b798:	c4 37 20 34 	sth  %g2, [ %i4 + 0x34 ]                       
          ++entry->reference_count;                                   
4000b79c:	c4 17 60 34 	lduh  [ %i5 + 0x34 ], %g2                      
4000b7a0:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
4000b7a4:	84 00 a0 01 	inc  %g2                                       
4000b7a8:	c4 37 60 34 	sth  %g2, [ %i5 + 0x34 ]                       
          currentloc->node_access = entry;                            
4000b7ac:	fa 26 20 20 	st  %i5, [ %i0 + 0x20 ]                        
4000b7b0:	c2 26 20 28 	st  %g1, [ %i0 + 0x28 ]                        
  void *arg,                                                          
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  rtems_filesystem_eval_path_generic_status status =                  
4000b7b4:	b0 08 e0 ff 	and  %g3, 0xff, %i0                            
      status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;           
    }                                                                 
  }                                                                   
                                                                      
  return status;                                                      
}                                                                     
4000b7b8:	81 c7 e0 08 	ret                                            
4000b7bc:	81 e8 00 00 	restore                                        
static inline bool rtems_filesystem_is_current_directory(             
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  return tokenlen == 1 && token [0] == '.';                           
4000b7c0:	c2 4e 80 00 	ldsb  [ %i2 ], %g1                             
4000b7c4:	80 a0 60 2e 	cmp  %g1, 0x2e                                 
4000b7c8:	32 bf ff ab 	bne,a   4000b674 <IMFS_eval_token+0x48>        
4000b7cc:	fa 07 20 50 	ld  [ %i4 + 0x50 ], %i5                        
4000b7d0:	10 bf ff b7 	b  4000b6ac <IMFS_eval_token+0x80>             
4000b7d4:	ba 10 00 1c 	mov  %i4, %i5                                  
      bool follow_sym_link = (eval_flags & RTEMS_FS_FOLLOW_SYM_LINK) != 0;
      IMFS_jnode_types_t type = IMFS_type( entry );                   
                                                                      
      rtems_filesystem_eval_path_clear_token( ctx );                  
                                                                      
      if ( type == IMFS_HARD_LINK && (follow_hard_link || !terminal)) {
4000b7d8:	80 a0 a0 00 	cmp  %g2, 0                                    
4000b7dc:	12 80 00 04 	bne  4000b7ec <IMFS_eval_token+0x1c0>          
4000b7e0:	80 89 20 08 	btst  8, %g4                                   
        entry = entry->info.hard_link.link_node;                      
4000b7e4:	10 bf ff ea 	b  4000b78c <IMFS_eval_token+0x160>            
4000b7e8:	fa 07 60 50 	ld  [ %i5 + 0x50 ], %i5                        
      bool follow_sym_link = (eval_flags & RTEMS_FS_FOLLOW_SYM_LINK) != 0;
      IMFS_jnode_types_t type = IMFS_type( entry );                   
                                                                      
      rtems_filesystem_eval_path_clear_token( ctx );                  
                                                                      
      if ( type == IMFS_HARD_LINK && (follow_hard_link || !terminal)) {
4000b7ec:	22 bf ff e9 	be,a   4000b790 <IMFS_eval_token+0x164>        
4000b7f0:	c4 17 20 34 	lduh  [ %i4 + 0x34 ], %g2                      
4000b7f4:	10 bf ff e6 	b  4000b78c <IMFS_eval_token+0x160>            
4000b7f8:	fa 07 60 50 	ld  [ %i5 + 0x50 ], %i5                        
        entry = entry->info.hard_link.link_node;                      
      }                                                               
                                                                      
      if ( type == IMFS_SYM_LINK && (follow_sym_link || !terminal)) { 
        const char *target = entry->info.sym_link.name;               
4000b7fc:	fa 07 60 50 	ld  [ %i5 + 0x50 ], %i5                        
                                                                      
        rtems_filesystem_eval_path_recursive( ctx, target, strlen( target ) );
4000b800:	40 00 15 35 	call  40010cd4 <strlen>                        
4000b804:	90 10 00 1d 	mov  %i5, %o0                                  
4000b808:	92 10 00 1d 	mov  %i5, %o1                                  
4000b80c:	94 10 00 08 	mov  %o0, %o2                                  
4000b810:	7f ff e3 07 	call  4000442c <rtems_filesystem_eval_path_recursive>
4000b814:	90 10 00 18 	mov  %i0, %o0                                  
4000b818:	30 bf ff 90 	b,a   4000b658 <IMFS_eval_token+0x2c>          
                                                                      

4000b834 <IMFS_fchmod>: int IMFS_fchmod( const rtems_filesystem_location_info_t *loc, mode_t mode ) {
4000b834:	9d e3 bf 98 	save  %sp, -104, %sp                           
                                                                      
  /*                                                                  
   *  Verify I am the owner of the node or the super user.            
   */                                                                 
#if defined(RTEMS_POSIX_API)                                          
  st_uid = geteuid();                                                 
4000b838:	40 00 01 81 	call  4000be3c <geteuid>                       
4000b83c:	fa 06 20 08 	ld  [ %i0 + 8 ], %i5                           
                                                                      
  if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )               
4000b840:	c2 17 60 3c 	lduh  [ %i5 + 0x3c ], %g1                      
4000b844:	91 2a 20 10 	sll  %o0, 0x10, %o0                            
4000b848:	91 32 20 10 	srl  %o0, 0x10, %o0                            
4000b84c:	80 a0 40 08 	cmp  %g1, %o0                                  
4000b850:	02 80 00 04 	be  4000b860 <IMFS_fchmod+0x2c>                
4000b854:	80 a2 20 00 	cmp  %o0, 0                                    
4000b858:	12 80 00 0e 	bne  4000b890 <IMFS_fchmod+0x5c>               <== ALWAYS TAKEN
4000b85c:	01 00 00 00 	nop                                            
                                                                      
  /*                                                                  
   * Change only the RWX permissions on the jnode to mode.            
   */                                                                 
                                                                      
  jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
4000b860:	c2 07 60 30 	ld  [ %i5 + 0x30 ], %g1                        
  jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
                                                                      
  IMFS_update_ctime( jnode );                                         
4000b864:	90 07 bf f8 	add  %fp, -8, %o0                              
                                                                      
  /*                                                                  
   * Change only the RWX permissions on the jnode to mode.            
   */                                                                 
                                                                      
  jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
4000b868:	82 08 70 00 	and  %g1, -4096, %g1                           
  jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
                                                                      
  IMFS_update_ctime( jnode );                                         
4000b86c:	92 10 20 00 	clr  %o1                                       
  /*                                                                  
   * Change only the RWX permissions on the jnode to mode.            
   */                                                                 
                                                                      
  jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
  jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
4000b870:	b2 0e 6f ff 	and  %i1, 0xfff, %i1                           
4000b874:	b2 16 40 01 	or  %i1, %g1, %i1                              
                                                                      
  IMFS_update_ctime( jnode );                                         
4000b878:	7f ff de 16 	call  400030d0 <gettimeofday>                  
4000b87c:	f2 27 60 30 	st  %i1, [ %i5 + 0x30 ]                        
4000b880:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
4000b884:	c2 27 60 48 	st  %g1, [ %i5 + 0x48 ]                        
                                                                      
  return 0;                                                           
}                                                                     
4000b888:	81 c7 e0 08 	ret                                            
4000b88c:	91 e8 20 00 	restore  %g0, 0, %o0                           
   */                                                                 
#if defined(RTEMS_POSIX_API)                                          
  st_uid = geteuid();                                                 
                                                                      
  if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )               
    rtems_set_errno_and_return_minus_one( EPERM );                    
4000b890:	40 00 0f ac 	call  4000f740 <__errno>                       
4000b894:	b0 10 3f ff 	mov  -1, %i0                                   
4000b898:	82 10 20 01 	mov  1, %g1                                    
4000b89c:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4000b8a0:	81 c7 e0 08 	ret                                            
4000b8a4:	81 e8 00 00 	restore                                        
                                                                      

4000327c <IMFS_fifo_write>: static ssize_t IMFS_fifo_write( rtems_libio_t *iop, const void *buffer, size_t count ) {
4000327c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  IMFS_jnode_t *jnode = iop->pathinfo.node_access;                    
40003280:	fa 06 20 1c 	ld  [ %i0 + 0x1c ], %i5                        
                                                                      
  int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);        
40003284:	96 10 00 18 	mov  %i0, %o3                                  
40003288:	d0 07 60 50 	ld  [ %i5 + 0x50 ], %o0                        
4000328c:	92 10 00 19 	mov  %i1, %o1                                  
40003290:	40 00 2b b6 	call  4000e168 <pipe_write>                    
40003294:	94 10 00 1a 	mov  %i2, %o2                                  
  if (err > 0) {                                                      
40003298:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4000329c:	04 80 00 09 	ble  400032c0 <IMFS_fifo_write+0x44>           
400032a0:	90 07 bf f8 	add  %fp, -8, %o0                              
    IMFS_mtime_ctime_update(jnode);                                   
400032a4:	40 00 03 c5 	call  400041b8 <gettimeofday>                  
400032a8:	92 10 20 00 	clr  %o1                                       
400032ac:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
400032b0:	c2 27 60 44 	st  %g1, [ %i5 + 0x44 ]                        
400032b4:	c2 27 60 48 	st  %g1, [ %i5 + 0x48 ]                        
400032b8:	81 c7 e0 08 	ret                                            
400032bc:	81 e8 00 00 	restore                                        
  }                                                                   
                                                                      
  IMFS_FIFO_RETURN(err);                                              
400032c0:	80 a6 20 00 	cmp  %i0, 0                                    
400032c4:	12 80 00 04 	bne  400032d4 <IMFS_fifo_write+0x58>           <== ALWAYS TAKEN
400032c8:	01 00 00 00 	nop                                            
}                                                                     
400032cc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400032d0:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);        
  if (err > 0) {                                                      
    IMFS_mtime_ctime_update(jnode);                                   
  }                                                                   
                                                                      
  IMFS_FIFO_RETURN(err);                                              
400032d4:	40 00 38 81 	call  400114d8 <__errno>                       
400032d8:	01 00 00 00 	nop                                            
400032dc:	82 20 00 18 	neg  %i0, %g1                                  
400032e0:	c2 22 00 00 	st  %g1, [ %o0 ]                               
}                                                                     
400032e4:	81 c7 e0 08 	ret                                            
400032e8:	91 e8 3f ff 	restore  %g0, -1, %o0                          
                                                                      

4000b8a8 <IMFS_fsunmount>: ((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next)) void IMFS_fsunmount( rtems_filesystem_mount_table_entry_t *temp_mt_entry ) {
4000b8a8:	9d e3 bf 88 	save  %sp, -120, %sp                           
   /*                                                                 
    * Traverse tree that starts at the mt_fs_root and deallocate memory
    * associated memory space                                         
    */                                                                
                                                                      
   loc = temp_mt_entry->mt_fs_root->location;                         
4000b8ac:	c4 06 20 24 	ld  [ %i0 + 0x24 ], %g2                        
4000b8b0:	c6 00 a0 08 	ld  [ %g2 + 8 ], %g3                           
4000b8b4:	f2 00 80 00 	ld  [ %g2 ], %i1                               
4000b8b8:	f4 00 a0 04 	ld  [ %g2 + 4 ], %i2                           
4000b8bc:	f6 00 a0 0c 	ld  [ %g2 + 0xc ], %i3                         
4000b8c0:	f8 00 a0 10 	ld  [ %g2 + 0x10 ], %i4                        
4000b8c4:	c8 00 a0 14 	ld  [ %g2 + 0x14 ], %g4                        
4000b8c8:	c2 00 e0 4c 	ld  [ %g3 + 0x4c ], %g1                        
4000b8cc:	f2 27 bf e8 	st  %i1, [ %fp + -24 ]                         
4000b8d0:	f4 27 bf ec 	st  %i2, [ %fp + -20 ]                         
4000b8d4:	c6 27 bf f0 	st  %g3, [ %fp + -16 ]                         
4000b8d8:	f6 27 bf f4 	st  %i3, [ %fp + -12 ]                         
4000b8dc:	f8 27 bf f8 	st  %i4, [ %fp + -8 ]                          
4000b8e0:	c8 27 bf fc 	st  %g4, [ %fp + -4 ]                          
                                                                      
   /*                                                                 
    *  Set this to null to indicate that it is being unmounted.       
    */                                                                
                                                                      
   temp_mt_entry->mt_fs_root->location.node_access = NULL;            
4000b8e4:	c0 20 a0 08 	clr  [ %g2 + 8 ]                               
4000b8e8:	c4 00 40 00 	ld  [ %g1 ], %g2                               
    * Traverse tree that starts at the mt_fs_root and deallocate memory
    * associated memory space                                         
    */                                                                
                                                                      
   loc = temp_mt_entry->mt_fs_root->location;                         
   jnode = (IMFS_jnode_t *)loc.node_access;                           
4000b8ec:	ba 10 00 03 	mov  %g3, %i5                                  
4000b8f0:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
    */                                                                
                                                                      
   temp_mt_entry->mt_fs_root->location.node_access = NULL;            
                                                                      
   do {                                                               
     next = jnode->Parent;                                            
4000b8f4:	f8 07 60 08 	ld  [ %i5 + 8 ], %i4                           
     loc.node_access = (void *)jnode;                                 
4000b8f8:	fa 27 bf f0 	st  %i5, [ %fp + -16 ]                         
     IMFS_Set_handlers( &loc );                                       
                                                                      
     if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
4000b8fc:	80 a0 a0 00 	cmp  %g2, 0                                    
4000b900:	12 80 00 13 	bne  4000b94c <IMFS_fsunmount+0xa4>            <== NEVER TAKEN
4000b904:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]                          
4000b908:	c2 07 60 50 	ld  [ %i5 + 0x50 ], %g1                        
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
4000b90c:	84 07 60 54 	add  %i5, 0x54, %g2                            
4000b910:	80 a0 40 02 	cmp  %g1, %g2                                  
4000b914:	02 80 00 0f 	be  4000b950 <IMFS_fsunmount+0xa8>             
4000b918:	90 10 20 00 	clr  %o0                                       
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(        
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_head( the_chain )->next;                    
4000b91c:	ba 10 00 01 	mov  %g1, %i5                                  
       if ( IMFS_is_directory( jnode ) ) {                            
         if ( jnode_has_children( jnode ) )                           
           jnode = jnode_get_first_child( jnode );                    
       }                                                              
     }                                                                
   } while (jnode != NULL);                                           
4000b920:	80 a7 60 00 	cmp  %i5, 0                                    
4000b924:	02 80 00 21 	be  4000b9a8 <IMFS_fsunmount+0x100>            <== NEVER TAKEN
4000b928:	01 00 00 00 	nop                                            
4000b92c:	c2 07 60 4c 	ld  [ %i5 + 0x4c ], %g1                        
    */                                                                
                                                                      
   temp_mt_entry->mt_fs_root->location.node_access = NULL;            
                                                                      
   do {                                                               
     next = jnode->Parent;                                            
4000b930:	f8 07 60 08 	ld  [ %i5 + 8 ], %i4                           
4000b934:	c4 00 40 00 	ld  [ %g1 ], %g2                               
4000b938:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
     loc.node_access = (void *)jnode;                                 
4000b93c:	fa 27 bf f0 	st  %i5, [ %fp + -16 ]                         
     IMFS_Set_handlers( &loc );                                       
                                                                      
     if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
4000b940:	80 a0 a0 00 	cmp  %g2, 0                                    
4000b944:	02 bf ff f1 	be  4000b908 <IMFS_fsunmount+0x60>             
4000b948:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]                          
        result = IMFS_rmnod( NULL, &loc );                            
4000b94c:	90 10 20 00 	clr  %o0                                       
4000b950:	7f ff dc 53 	call  40002a9c <IMFS_rmnod>                    
4000b954:	92 07 bf e8 	add  %fp, -24, %o1                             
        if ( result != 0 )                                            
4000b958:	80 a2 20 00 	cmp  %o0, 0                                    
4000b95c:	12 80 00 15 	bne  4000b9b0 <IMFS_fsunmount+0x108>           <== NEVER TAKEN
4000b960:	11 37 ab 6f 	sethi  %hi(0xdeadbc00), %o0                    
	  rtems_fatal_error_occurred( 0xdeadbeef );                          
        IMFS_node_destroy( jnode );                                   
4000b964:	7f ff db 6c 	call  40002714 <IMFS_node_destroy>             
4000b968:	90 10 00 1d 	mov  %i5, %o0                                  
        jnode = next;                                                 
     }                                                                
     if ( jnode != NULL ) {                                           
4000b96c:	80 a7 20 00 	cmp  %i4, 0                                    
4000b970:	02 80 00 0e 	be  4000b9a8 <IMFS_fsunmount+0x100>            
4000b974:	01 00 00 00 	nop                                            
4000b978:	c2 07 20 4c 	ld  [ %i4 + 0x4c ], %g1                        
4000b97c:	c4 00 40 00 	ld  [ %g1 ], %g2                               
       if ( IMFS_is_directory( jnode ) ) {                            
4000b980:	80 a0 a0 00 	cmp  %g2, 0                                    
4000b984:	12 bf ff db 	bne  4000b8f0 <IMFS_fsunmount+0x48>            <== NEVER TAKEN
4000b988:	ba 10 00 1c 	mov  %i4, %i5                                  
4000b98c:	fa 07 20 50 	ld  [ %i4 + 0x50 ], %i5                        
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
4000b990:	86 07 20 54 	add  %i4, 0x54, %g3                            
         if ( jnode_has_children( jnode ) )                           
4000b994:	80 a7 40 03 	cmp  %i5, %g3                                  
4000b998:	12 bf ff e3 	bne  4000b924 <IMFS_fsunmount+0x7c>            
4000b99c:	80 a7 60 00 	cmp  %i5, 0                                    
4000b9a0:	10 bf ff d4 	b  4000b8f0 <IMFS_fsunmount+0x48>              
4000b9a4:	ba 10 00 1c 	mov  %i4, %i5                                  
4000b9a8:	81 c7 e0 08 	ret                                            
4000b9ac:	81 e8 00 00 	restore                                        
     IMFS_Set_handlers( &loc );                                       
                                                                      
     if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
        result = IMFS_rmnod( NULL, &loc );                            
        if ( result != 0 )                                            
	  rtems_fatal_error_occurred( 0xdeadbeef );                          
4000b9b0:	7f ff f0 5c 	call  40007b20 <rtems_fatal_error_occurred>    <== NOT EXECUTED
4000b9b4:	90 12 22 ef 	or  %o0, 0x2ef, %o0                            <== NOT EXECUTED
                                                                      

40002600 <IMFS_initialize_support>: int IMFS_initialize_support( rtems_filesystem_mount_table_entry_t *mt_entry, const rtems_filesystem_operations_table *op_table, const IMFS_node_control *const node_controls [IMFS_TYPE_COUNT] ) {
40002600:	9d e3 bf a0 	save  %sp, -96, %sp                            
  static int imfs_instance;                                           
                                                                      
  int rv = 0;                                                         
  IMFS_fs_info_t *fs_info = calloc( 1, sizeof( *fs_info ) );          
40002604:	90 10 20 01 	mov  1, %o0                                    
40002608:	40 00 01 d9 	call  40002d6c <calloc>                        
4000260c:	92 10 20 24 	mov  0x24, %o1                                 
                                                                      
  if ( fs_info != NULL ) {                                            
40002610:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40002614:	02 80 00 34 	be  400026e4 <IMFS_initialize_support+0xe4>    
40002618:	03 10 00 7a 	sethi  %hi(0x4001e800), %g1                    
    IMFS_jnode_t *root_node;                                          
                                                                      
    fs_info->instance = imfs_instance++;                              
4000261c:	c4 00 62 a4 	ld  [ %g1 + 0x2a4 ], %g2	! 4001eaa4 <imfs_instance.6621>
    memcpy(                                                           
40002620:	92 10 00 1a 	mov  %i2, %o1                                  
  IMFS_fs_info_t *fs_info = calloc( 1, sizeof( *fs_info ) );          
                                                                      
  if ( fs_info != NULL ) {                                            
    IMFS_jnode_t *root_node;                                          
                                                                      
    fs_info->instance = imfs_instance++;                              
40002624:	86 00 a0 01 	add  %g2, 1, %g3                               
    memcpy(                                                           
40002628:	94 10 20 1c 	mov  0x1c, %o2                                 
  IMFS_fs_info_t *fs_info = calloc( 1, sizeof( *fs_info ) );          
                                                                      
  if ( fs_info != NULL ) {                                            
    IMFS_jnode_t *root_node;                                          
                                                                      
    fs_info->instance = imfs_instance++;                              
4000262c:	c4 27 40 00 	st  %g2, [ %i5 ]                               
40002630:	c6 20 62 a4 	st  %g3, [ %g1 + 0x2a4 ]                       
    memcpy(                                                           
40002634:	40 00 36 94 	call  40010084 <memcpy>                        
40002638:	90 07 60 08 	add  %i5, 8, %o0                               
      fs_info->node_controls,                                         
      node_controls,                                                  
      sizeof( fs_info->node_controls )                                
    );                                                                
                                                                      
    root_node = IMFS_allocate_node(                                   
4000263c:	d2 07 60 08 	ld  [ %i5 + 8 ], %o1                           
40002640:	90 10 00 1d 	mov  %i5, %o0                                  
40002644:	96 10 20 00 	clr  %o3                                       
40002648:	15 10 00 71 	sethi  %hi(0x4001c400), %o2                    
4000264c:	9a 10 20 00 	clr  %o5                                       
40002650:	94 12 a3 f0 	or  %o2, 0x3f0, %o2                            
40002654:	19 00 00 10 	sethi  %hi(0x4000), %o4                        
40002658:	40 00 23 a4 	call  4000b4e8 <IMFS_allocate_node>            
4000265c:	98 13 21 ed 	or  %o4, 0x1ed, %o4	! 41ed <PROM_START+0x41ed> 
      "",                                                             
      0,                                                              
      (S_IFDIR | 0755),                                               
      NULL                                                            
    );                                                                
    if ( root_node != NULL ) {                                        
40002660:	80 a2 20 00 	cmp  %o0, 0                                    
40002664:	02 80 00 20 	be  400026e4 <IMFS_initialize_support+0xe4>    <== NEVER TAKEN
40002668:	09 10 00 74 	sethi  %hi(0x4001d000), %g4                    
                                                                      
static inline void IMFS_Set_handlers( rtems_filesystem_location_info_t *loc )
{                                                                     
  IMFS_jnode_t *node = (IMFS_jnode_t *) loc->node_access;             
                                                                      
  loc->handlers = node->control->handlers;                            
4000266c:	c4 02 20 4c 	ld  [ %o0 + 0x4c ], %g2                        
      mt_entry->fs_info = fs_info;                                    
      mt_entry->ops = op_table;                                       
      mt_entry->pathconf_limits_and_options = &IMFS_LIMITS_AND_OPTIONS;
      mt_entry->mt_fs_root->location.node_access = root_node;         
40002670:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
40002674:	c6 00 a0 04 	ld  [ %g2 + 4 ], %g3                           
      0,                                                              
      (S_IFDIR | 0755),                                               
      NULL                                                            
    );                                                                
    if ( root_node != NULL ) {                                        
      mt_entry->fs_info = fs_info;                                    
40002678:	fa 26 20 08 	st  %i5, [ %i0 + 8 ]                           
      mt_entry->ops = op_table;                                       
4000267c:	f2 26 20 0c 	st  %i1, [ %i0 + 0xc ]                         
    errno = ENOMEM;                                                   
    rv = -1;                                                          
  }                                                                   
                                                                      
  if ( rv == 0 ) {                                                    
    IMFS_determine_bytes_per_block(                                   
40002680:	05 10 00 78 	sethi  %hi(0x4001e000), %g2                    
      NULL                                                            
    );                                                                
    if ( root_node != NULL ) {                                        
      mt_entry->fs_info = fs_info;                                    
      mt_entry->ops = op_table;                                       
      mt_entry->pathconf_limits_and_options = &IMFS_LIMITS_AND_OPTIONS;
40002684:	88 11 21 bc 	or  %g4, 0x1bc, %g4                            
    errno = ENOMEM;                                                   
    rv = -1;                                                          
  }                                                                   
                                                                      
  if ( rv == 0 ) {                                                    
    IMFS_determine_bytes_per_block(                                   
40002688:	c4 00 a3 a0 	ld  [ %g2 + 0x3a0 ], %g2                       
      NULL                                                            
    );                                                                
    if ( root_node != NULL ) {                                        
      mt_entry->fs_info = fs_info;                                    
      mt_entry->ops = op_table;                                       
      mt_entry->pathconf_limits_and_options = &IMFS_LIMITS_AND_OPTIONS;
4000268c:	c8 26 20 2c 	st  %g4, [ %i0 + 0x2c ]                        
      mt_entry->mt_fs_root->location.node_access = root_node;         
40002690:	d0 20 60 08 	st  %o0, [ %g1 + 8 ]                           
                                                                      
  /*                                                                  
   * check, whether requested bytes per block is valid                
   */                                                                 
  for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
    if (bit_mask == requested_bytes_per_block) {                      
40002694:	80 a0 a0 10 	cmp  %g2, 0x10                                 
40002698:	02 80 00 0f 	be  400026d4 <IMFS_initialize_support+0xd4>    
4000269c:	c6 20 60 10 	st  %g3, [ %g1 + 0x10 ]                        
      is_valid = true;                                                
      break;                                                          
    }                                                                 
    if(bit_mask > requested_bytes_per_block)                          
400026a0:	80 a0 a0 0f 	cmp  %g2, 0xf                                  
400026a4:	04 80 00 0b 	ble  400026d0 <IMFS_initialize_support+0xd0>   
400026a8:	82 10 20 20 	mov  0x20, %g1                                 
400026ac:	86 10 20 05 	mov  5, %g3                                    
                                                                      
  /*                                                                  
   * check, whether requested bytes per block is valid                
   */                                                                 
  for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
    if (bit_mask == requested_bytes_per_block) {                      
400026b0:	80 a0 80 01 	cmp  %g2, %g1                                  
400026b4:	22 80 00 09 	be,a   400026d8 <IMFS_initialize_support+0xd8> 
400026b8:	03 10 00 7a 	sethi  %hi(0x4001e800), %g1                    
      is_valid = true;                                                
      break;                                                          
    }                                                                 
    if(bit_mask > requested_bytes_per_block)                          
400026bc:	26 80 00 06 	bl,a   400026d4 <IMFS_initialize_support+0xd4> <== NEVER TAKEN
400026c0:	84 10 20 80 	mov  0x80, %g2                                 <== NOT EXECUTED
  int bit_mask;                                                       
                                                                      
  /*                                                                  
   * check, whether requested bytes per block is valid                
   */                                                                 
  for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
400026c4:	86 80 ff ff 	addcc  %g3, -1, %g3                            
400026c8:	12 bf ff fa 	bne  400026b0 <IMFS_initialize_support+0xb0>   <== ALWAYS TAKEN
400026cc:	83 28 60 01 	sll  %g1, 1, %g1                               
    if(bit_mask > requested_bytes_per_block)                          
      break;                                                          
  }                                                                   
  *dest_bytes_per_block = ((is_valid)                                 
			   ? requested_bytes_per_block                                     
			   : default_bytes_per_block);                                     
400026d0:	84 10 20 80 	mov  0x80, %g2                                 
      break;                                                          
    }                                                                 
    if(bit_mask > requested_bytes_per_block)                          
      break;                                                          
  }                                                                   
  *dest_bytes_per_block = ((is_valid)                                 
400026d4:	03 10 00 7a 	sethi  %hi(0x4001e800), %g1                    
400026d8:	c4 20 62 a0 	st  %g2, [ %g1 + 0x2a0 ]	! 4001eaa0 <imfs_memfile_bytes_per_block>
  const IMFS_node_control *const node_controls [IMFS_TYPE_COUNT]      
)                                                                     
{                                                                     
  static int imfs_instance;                                           
                                                                      
  int rv = 0;                                                         
400026dc:	81 c7 e0 08 	ret                                            
400026e0:	91 e8 20 00 	restore  %g0, 0, %o0                           
    } else {                                                          
      errno = ENOMEM;                                                 
      rv = -1;                                                        
    }                                                                 
  } else {                                                            
    errno = ENOMEM;                                                   
400026e4:	40 00 34 17 	call  4000f740 <__errno>                       
400026e8:	b0 10 3f ff 	mov  -1, %i0                                   
400026ec:	82 10 20 0c 	mov  0xc, %g1                                  
400026f0:	c2 22 00 00 	st  %g1, [ %o0 ]                               
      IMFS_MEMFILE_DEFAULT_BYTES_PER_BLOCK                            
    );                                                                
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
400026f4:	81 c7 e0 08 	ret                                            
400026f8:	81 e8 00 00 	restore                                        
                                                                      

400042fc <IMFS_make_generic_node>: const char *path, mode_t mode, const IMFS_node_control *node_control, void *context ) {
400042fc:	9d e3 bf 48 	save  %sp, -184, %sp                           
  int rv = 0;                                                         
                                                                      
  mode &= ~rtems_filesystem_umask;                                    
40004300:	03 10 00 6b 	sethi  %hi(0x4001ac00), %g1                    
40004304:	c2 00 62 08 	ld  [ %g1 + 0x208 ], %g1	! 4001ae08 <rtems_current_user_env>
                                                                      
  switch (mode & S_IFMT) {                                            
40004308:	05 00 00 08 	sethi  %hi(0x2000), %g2                        
  void *context                                                       
)                                                                     
{                                                                     
  int rv = 0;                                                         
                                                                      
  mode &= ~rtems_filesystem_umask;                                    
4000430c:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
40004310:	b2 2e 40 01 	andn  %i1, %g1, %i1                            
                                                                      
  switch (mode & S_IFMT) {                                            
40004314:	03 00 00 3c 	sethi  %hi(0xf000), %g1                        
40004318:	82 0e 40 01 	and  %i1, %g1, %g1                             
4000431c:	80 a0 40 02 	cmp  %g1, %g2                                  
40004320:	22 80 00 0c 	be,a   40004350 <IMFS_make_generic_node+0x54>  
40004324:	c2 06 80 00 	ld  [ %i2 ], %g1                               
40004328:	08 80 00 1d 	bleu  4000439c <IMFS_make_generic_node+0xa0>   <== NEVER TAKEN
4000432c:	05 00 00 04 	sethi  %hi(0x1000), %g2                        
40004330:	05 00 00 18 	sethi  %hi(0x6000), %g2                        
40004334:	80 a0 40 02 	cmp  %g1, %g2                                  
40004338:	02 80 00 05 	be  4000434c <IMFS_make_generic_node+0x50>     
4000433c:	05 00 00 20 	sethi  %hi(0x8000), %g2                        
40004340:	80 a0 40 02 	cmp  %g1, %g2                                  
40004344:	12 80 00 19 	bne  400043a8 <IMFS_make_generic_node+0xac>    <== ALWAYS TAKEN
40004348:	01 00 00 00 	nop                                            
      rv = -1;                                                        
      break;                                                          
  }                                                                   
                                                                      
  if ( rv == 0 ) {                                                    
    if ( node_control->imfs_type == IMFS_GENERIC ) {                  
4000434c:	c2 06 80 00 	ld  [ %i2 ], %g1                               
40004350:	80 a0 60 07 	cmp  %g1, 7                                    
40004354:	12 80 00 15 	bne  400043a8 <IMFS_make_generic_node+0xac>    
40004358:	92 10 00 18 	mov  %i0, %o1                                  
      rtems_filesystem_eval_path_context_t ctx;                       
      int eval_flags = RTEMS_FS_FOLLOW_LINK                           
        | RTEMS_FS_MAKE                                               
        | RTEMS_FS_EXCLUSIVE;                                         
      const rtems_filesystem_location_info_t *currentloc =            
4000435c:	94 10 20 78 	mov  0x78, %o2                                 
40004360:	40 00 07 ac 	call  40006210 <rtems_filesystem_eval_path_start>
40004364:	90 07 bf c8 	add  %fp, -56, %o0                             
        rtems_filesystem_eval_path_start( &ctx, path, eval_flags );   
                                                                      
      if ( IMFS_is_imfs_instance( currentloc ) ) {                    
40004368:	7f ff ff d2 	call  400042b0 <IMFS_is_imfs_instance>         
4000436c:	ba 10 00 08 	mov  %o0, %i5                                  
40004370:	80 8a 20 ff 	btst  0xff, %o0                                
40004374:	12 80 00 13 	bne  400043c0 <IMFS_make_generic_node+0xc4>    
40004378:	d4 1f bf d0 	ldd  [ %fp + -48 ], %o2                        
          IMFS_update_mtime( parent );                                
        } else {                                                      
          rv = -1;                                                    
        }                                                             
      } else {                                                        
        rtems_filesystem_eval_path_error( &ctx, ENOTSUP );            
4000437c:	90 07 bf c8 	add  %fp, -56, %o0                             
40004380:	92 10 20 86 	mov  0x86, %o1                                 
40004384:	40 00 06 e7 	call  40005f20 <rtems_filesystem_eval_path_error>
40004388:	b0 10 3f ff 	mov  -1, %i0                                   
        rv = -1;                                                      
      }                                                               
                                                                      
      rtems_filesystem_eval_path_cleanup( &ctx );                     
4000438c:	40 00 07 e1 	call  40006310 <rtems_filesystem_eval_path_cleanup>
40004390:	90 07 bf c8 	add  %fp, -56, %o0                             
40004394:	81 c7 e0 08 	ret                                            
40004398:	81 e8 00 00 	restore                                        
{                                                                     
  int rv = 0;                                                         
                                                                      
  mode &= ~rtems_filesystem_umask;                                    
                                                                      
  switch (mode & S_IFMT) {                                            
4000439c:	80 a0 40 02 	cmp  %g1, %g2                                  <== NOT EXECUTED
400043a0:	22 bf ff ec 	be,a   40004350 <IMFS_make_generic_node+0x54>  <== NOT EXECUTED
400043a4:	c2 06 80 00 	ld  [ %i2 ], %g1                               <== NOT EXECUTED
        rv = -1;                                                      
      }                                                               
                                                                      
      rtems_filesystem_eval_path_cleanup( &ctx );                     
    } else {                                                          
      errno = EINVAL;                                                 
400043a8:	40 00 40 36 	call  40014480 <__errno>                       
400043ac:	b0 10 3f ff 	mov  -1, %i0                                   
400043b0:	82 10 20 16 	mov  0x16, %g1                                 
400043b4:	c2 22 00 00 	st  %g1, [ %o0 ]                               
400043b8:	81 c7 e0 08 	ret                                            
400043bc:	81 e8 00 00 	restore                                        
                                                                      
      if ( IMFS_is_imfs_instance( currentloc ) ) {                    
        IMFS_types_union info;                                        
        IMFS_jnode_t *new_node;                                       
                                                                      
        info.generic.context = context;                               
400043c0:	f6 27 bf b0 	st  %i3, [ %fp + -80 ]                         
        new_node = IMFS_create_node_with_control(                     
400043c4:	90 10 00 1d 	mov  %i5, %o0                                  
400043c8:	92 10 00 1a 	mov  %i2, %o1                                  
400043cc:	98 10 00 19 	mov  %i1, %o4                                  
400043d0:	9a 07 bf b0 	add  %fp, -80, %o5                             
400043d4:	40 00 2f 26 	call  4001006c <IMFS_create_node_with_control> 
400043d8:	b0 10 3f ff 	mov  -1, %i0                                   
          rtems_filesystem_eval_path_get_tokenlen( &ctx ),            
          mode,                                                       
          &info                                                       
        );                                                            
                                                                      
        if ( new_node != NULL ) {                                     
400043dc:	80 a2 20 00 	cmp  %o0, 0                                    
400043e0:	02 bf ff eb 	be  4000438c <IMFS_make_generic_node+0x90>     
400043e4:	92 10 20 00 	clr  %o1                                       
          IMFS_jnode_t *parent = currentloc->node_access;             
400043e8:	fa 07 60 08 	ld  [ %i5 + 8 ], %i5                           
                                                                      
          IMFS_update_ctime( parent );                                
400043ec:	40 00 02 0f 	call  40004c28 <gettimeofday>                  
400043f0:	90 07 bf a8 	add  %fp, -88, %o0                             
400043f4:	c2 07 bf a8 	ld  [ %fp + -88 ], %g1                         
          IMFS_update_mtime( parent );                                
400043f8:	90 07 bf a8 	add  %fp, -88, %o0                             
        );                                                            
                                                                      
        if ( new_node != NULL ) {                                     
          IMFS_jnode_t *parent = currentloc->node_access;             
                                                                      
          IMFS_update_ctime( parent );                                
400043fc:	c2 27 60 48 	st  %g1, [ %i5 + 0x48 ]                        
          IMFS_update_mtime( parent );                                
40004400:	40 00 02 0a 	call  40004c28 <gettimeofday>                  
40004404:	92 10 20 00 	clr  %o1                                       
40004408:	c2 07 bf a8 	ld  [ %fp + -88 ], %g1                         
4000440c:	b0 10 20 00 	clr  %i0                                       
40004410:	c2 27 60 44 	st  %g1, [ %i5 + 0x44 ]                        
      } else {                                                        
        rtems_filesystem_eval_path_error( &ctx, ENOTSUP );            
        rv = -1;                                                      
      }                                                               
                                                                      
      rtems_filesystem_eval_path_cleanup( &ctx );                     
40004414:	40 00 07 bf 	call  40006310 <rtems_filesystem_eval_path_cleanup>
40004418:	90 07 bf c8 	add  %fp, -56, %o0                             
4000441c:	81 c7 e0 08 	ret                                            
40004420:	81 e8 00 00 	restore                                        
                                                                      

4000e110 <IMFS_memfile_addblock>: */ MEMFILE_STATIC int IMFS_memfile_addblock( IMFS_jnode_t *the_jnode, unsigned int block ) {
4000e110:	9d e3 bf a0 	save  %sp, -96, %sp                            
  IMFS_assert( IMFS_type( the_jnode ) == IMFS_MEMORY_FILE );          
                                                                      
  /*                                                                  
   * Obtain the pointer for the specified block number                
   */                                                                 
  block_entry_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 1 );
4000e114:	94 10 20 01 	mov  1, %o2                                    
4000e118:	90 10 00 18 	mov  %i0, %o0                                  
4000e11c:	7f ff fe c9 	call  4000dc40 <IMFS_memfile_get_block_pointer>
4000e120:	92 10 00 19 	mov  %i1, %o1                                  
  if ( *block_entry_ptr )                                             
4000e124:	c2 02 00 00 	ld  [ %o0 ], %g1                               
  IMFS_assert( IMFS_type( the_jnode ) == IMFS_MEMORY_FILE );          
                                                                      
  /*                                                                  
   * Obtain the pointer for the specified block number                
   */                                                                 
  block_entry_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 1 );
4000e128:	ba 10 00 08 	mov  %o0, %i5                                  
  if ( *block_entry_ptr )                                             
4000e12c:	80 a0 60 00 	cmp  %g1, 0                                    
4000e130:	12 80 00 08 	bne  4000e150 <IMFS_memfile_addblock+0x40>     
4000e134:	b0 10 20 00 	clr  %i0                                       
    return 0;                                                         
                                                                      
  /*                                                                  
   *  There is no memory for this block number so allocate it.        
   */                                                                 
  memory = memfile_alloc_block();                                     
4000e138:	7f ff fe b5 	call  4000dc0c <memfile_alloc_block>           
4000e13c:	01 00 00 00 	nop                                            
  if ( !memory )                                                      
4000e140:	80 a2 20 00 	cmp  %o0, 0                                    
4000e144:	02 80 00 05 	be  4000e158 <IMFS_memfile_addblock+0x48>      <== NEVER TAKEN
4000e148:	01 00 00 00 	nop                                            
    return 1;                                                         
                                                                      
  *block_entry_ptr = memory;                                          
4000e14c:	d0 27 40 00 	st  %o0, [ %i5 ]                               
  return 0;                                                           
4000e150:	81 c7 e0 08 	ret                                            
4000e154:	81 e8 00 00 	restore                                        
}                                                                     
4000e158:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000e15c:	91 e8 20 01 	restore  %g0, 1, %o0                           <== NOT EXECUTED
                                                                      

4000e384 <IMFS_memfile_extend>: MEMFILE_STATIC int IMFS_memfile_extend( IMFS_jnode_t *the_jnode, bool zero_fill, off_t new_length ) {
4000e384:	9d e3 bf 98 	save  %sp, -104, %sp                           
    IMFS_assert( IMFS_type( the_jnode ) == IMFS_MEMORY_FILE );        
                                                                      
  /*                                                                  
   *  Verify new file size is supported                               
   */                                                                 
  if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )                      
4000e388:	25 10 00 7a 	sethi  %hi(0x4001e800), %l2                    
4000e38c:	fa 04 a2 a0 	ld  [ %l2 + 0x2a0 ], %i5	! 4001eaa0 <imfs_memfile_bytes_per_block>
4000e390:	b9 37 60 02 	srl  %i5, 2, %i4                               
4000e394:	92 10 00 1c 	mov  %i4, %o1                                  
4000e398:	40 00 28 fd 	call  4001878c <.umul>                         
4000e39c:	90 07 20 01 	add  %i4, 1, %o0                               
4000e3a0:	92 10 00 1c 	mov  %i4, %o1                                  
4000e3a4:	40 00 28 fa 	call  4001878c <.umul>                         
4000e3a8:	90 02 20 01 	inc  %o0                                       
4000e3ac:	92 10 00 1d 	mov  %i5, %o1                                  
4000e3b0:	40 00 28 f7 	call  4001878c <.umul>                         
4000e3b4:	90 02 3f ff 	add  %o0, -1, %o0                              
4000e3b8:	82 10 20 00 	clr  %g1                                       
4000e3bc:	80 a0 40 1a 	cmp  %g1, %i2                                  
4000e3c0:	04 80 00 58 	ble  4000e520 <IMFS_memfile_extend+0x19c>      <== ALWAYS TAKEN
4000e3c4:	b8 10 00 18 	mov  %i0, %i4                                  
    rtems_set_errno_and_return_minus_one( EFBIG );                    
                                                                      
  /*                                                                  
   *  Verify new file size is actually larger than current size       
   */                                                                 
  if ( new_length <= the_jnode->info.file.size )                      
4000e3c8:	e2 07 20 50 	ld  [ %i4 + 0x50 ], %l1                        <== NOT EXECUTED
4000e3cc:	80 a6 80 11 	cmp  %i2, %l1                                  
4000e3d0:	04 80 00 3f 	ble  4000e4cc <IMFS_memfile_extend+0x148>      <== ALWAYS TAKEN
4000e3d4:	e0 07 20 54 	ld  [ %i4 + 0x54 ], %l0                        
    return 0;                                                         
                                                                      
  /*                                                                  
   *  Calculate the number of range of blocks to allocate             
   */                                                                 
  new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;             
4000e3d8:	a7 3f 60 1f 	sra  %i5, 0x1f, %l3                            <== NOT EXECUTED
4000e3dc:	96 10 00 1d 	mov  %i5, %o3                                  
4000e3e0:	94 10 00 13 	mov  %l3, %o2                                  
4000e3e4:	90 10 00 1a 	mov  %i2, %o0                                  
4000e3e8:	40 00 2a 7b 	call  40018dd4 <__divdi3>                      
4000e3ec:	92 10 00 1b 	mov  %i3, %o1                                  
  old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
4000e3f0:	96 10 00 1d 	mov  %i5, %o3                                  
    return 0;                                                         
                                                                      
  /*                                                                  
   *  Calculate the number of range of blocks to allocate             
   */                                                                 
  new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;             
4000e3f4:	b0 10 00 09 	mov  %o1, %i0                                  
  old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
4000e3f8:	90 10 00 11 	mov  %l1, %o0                                  
4000e3fc:	92 10 00 10 	mov  %l0, %o1                                  
4000e400:	40 00 2a 75 	call  40018dd4 <__divdi3>                      
4000e404:	94 10 00 13 	mov  %l3, %o2                                  
4000e408:	a2 10 00 09 	mov  %o1, %l1                                  
  offset = the_jnode->info.file.size - old_blocks * IMFS_MEMFILE_BYTES_PER_BLOCK;
4000e40c:	90 10 00 09 	mov  %o1, %o0                                  
4000e410:	40 00 28 df 	call  4001878c <.umul>                         
4000e414:	92 10 00 1d 	mov  %i5, %o1                                  
                                                                      
  /*                                                                  
   *  Now allocate each of those blocks.                              
   */                                                                 
  for ( block=old_blocks ; block<=new_blocks ; block++ ) {            
4000e418:	ba 10 00 11 	mov  %l1, %i5                                  
4000e41c:	80 a6 00 11 	cmp  %i0, %l1                                  
4000e420:	1a 80 00 07 	bcc  4000e43c <IMFS_memfile_extend+0xb8>       <== ALWAYS TAKEN
4000e424:	a0 24 00 08 	sub  %l0, %o0, %l0                             
  /*                                                                  
   *  Set the new length of the file.                                 
   */                                                                 
  the_jnode->info.file.size = new_length;                             
                                                                      
  IMFS_update_ctime(the_jnode);                                       
4000e428:	10 80 00 1d 	b  4000e49c <IMFS_memfile_extend+0x118>        <== NOT EXECUTED
4000e42c:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
  offset = the_jnode->info.file.size - old_blocks * IMFS_MEMFILE_BYTES_PER_BLOCK;
                                                                      
  /*                                                                  
   *  Now allocate each of those blocks.                              
   */                                                                 
  for ( block=old_blocks ; block<=new_blocks ; block++ ) {            
4000e430:	80 a6 00 1d 	cmp  %i0, %i5                                  
4000e434:	0a 80 00 1a 	bcs  4000e49c <IMFS_memfile_extend+0x118>      
4000e438:	92 10 20 00 	clr  %o1                                       
    if ( !IMFS_memfile_addblock( the_jnode, block ) ) {               
4000e43c:	92 10 00 1d 	mov  %i5, %o1                                  
4000e440:	7f ff ff 34 	call  4000e110 <IMFS_memfile_addblock>         
4000e444:	90 10 00 1c 	mov  %i4, %o0                                  
4000e448:	80 a2 20 00 	cmp  %o0, 0                                    
4000e44c:	12 80 00 26 	bne  4000e4e4 <IMFS_memfile_extend+0x160>      <== NEVER TAKEN
4000e450:	80 a6 60 00 	cmp  %i1, 0                                    
       if ( zero_fill ) {                                             
4000e454:	22 bf ff f7 	be,a   4000e430 <IMFS_memfile_extend+0xac>     
4000e458:	ba 07 60 01 	inc  %i5                                       
          size_t count = IMFS_MEMFILE_BYTES_PER_BLOCK - offset;       
          block_p *block_ptr =                                        
4000e45c:	92 10 00 1d 	mov  %i5, %o1                                  
   *  Now allocate each of those blocks.                              
   */                                                                 
  for ( block=old_blocks ; block<=new_blocks ; block++ ) {            
    if ( !IMFS_memfile_addblock( the_jnode, block ) ) {               
       if ( zero_fill ) {                                             
          size_t count = IMFS_MEMFILE_BYTES_PER_BLOCK - offset;       
4000e460:	e6 04 a2 a0 	ld  [ %l2 + 0x2a0 ], %l3                       
          block_p *block_ptr =                                        
4000e464:	94 10 20 00 	clr  %o2                                       
4000e468:	7f ff fd f6 	call  4000dc40 <IMFS_memfile_get_block_pointer>
4000e46c:	90 10 00 1c 	mov  %i4, %o0                                  
            IMFS_memfile_get_block_pointer( the_jnode, block, 0 );    
                                                                      
          memset( &(*block_ptr) [offset], 0, count);                  
4000e470:	d0 02 00 00 	ld  [ %o0 ], %o0                               
   *  Now allocate each of those blocks.                              
   */                                                                 
  for ( block=old_blocks ; block<=new_blocks ; block++ ) {            
    if ( !IMFS_memfile_addblock( the_jnode, block ) ) {               
       if ( zero_fill ) {                                             
          size_t count = IMFS_MEMFILE_BYTES_PER_BLOCK - offset;       
4000e474:	a6 24 c0 10 	sub  %l3, %l0, %l3                             
          block_p *block_ptr =                                        
            IMFS_memfile_get_block_pointer( the_jnode, block, 0 );    
                                                                      
          memset( &(*block_ptr) [offset], 0, count);                  
4000e478:	90 02 00 10 	add  %o0, %l0, %o0                             
4000e47c:	92 10 20 00 	clr  %o1                                       
4000e480:	40 00 07 3e 	call  40010178 <memset>                        
4000e484:	94 10 00 13 	mov  %l3, %o2                                  
  offset = the_jnode->info.file.size - old_blocks * IMFS_MEMFILE_BYTES_PER_BLOCK;
                                                                      
  /*                                                                  
   *  Now allocate each of those blocks.                              
   */                                                                 
  for ( block=old_blocks ; block<=new_blocks ; block++ ) {            
4000e488:	ba 07 60 01 	inc  %i5                                       
4000e48c:	80 a6 00 1d 	cmp  %i0, %i5                                  
4000e490:	1a bf ff eb 	bcc  4000e43c <IMFS_memfile_extend+0xb8>       
4000e494:	a0 10 20 00 	clr  %l0                                       
  /*                                                                  
   *  Set the new length of the file.                                 
   */                                                                 
  the_jnode->info.file.size = new_length;                             
                                                                      
  IMFS_update_ctime(the_jnode);                                       
4000e498:	92 10 20 00 	clr  %o1                                       
  }                                                                   
                                                                      
  /*                                                                  
   *  Set the new length of the file.                                 
   */                                                                 
  the_jnode->info.file.size = new_length;                             
4000e49c:	f4 3f 20 50 	std  %i2, [ %i4 + 0x50 ]                       
                                                                      
  IMFS_update_ctime(the_jnode);                                       
4000e4a0:	7f ff d3 0c 	call  400030d0 <gettimeofday>                  
4000e4a4:	90 07 bf f8 	add  %fp, -8, %o0                              
4000e4a8:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
  IMFS_update_mtime(the_jnode);                                       
4000e4ac:	90 07 bf f8 	add  %fp, -8, %o0                              
  /*                                                                  
   *  Set the new length of the file.                                 
   */                                                                 
  the_jnode->info.file.size = new_length;                             
                                                                      
  IMFS_update_ctime(the_jnode);                                       
4000e4b0:	c2 27 20 48 	st  %g1, [ %i4 + 0x48 ]                        
  IMFS_update_mtime(the_jnode);                                       
4000e4b4:	7f ff d3 07 	call  400030d0 <gettimeofday>                  
4000e4b8:	92 10 20 00 	clr  %o1                                       
4000e4bc:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
4000e4c0:	c2 27 20 44 	st  %g1, [ %i4 + 0x44 ]                        
  return 0;                                                           
4000e4c4:	81 c7 e0 08 	ret                                            
4000e4c8:	91 e8 20 00 	restore  %g0, 0, %o0                           
    rtems_set_errno_and_return_minus_one( EFBIG );                    
                                                                      
  /*                                                                  
   *  Verify new file size is actually larger than current size       
   */                                                                 
  if ( new_length <= the_jnode->info.file.size )                      
4000e4cc:	12 80 00 04 	bne  4000e4dc <IMFS_memfile_extend+0x158>      <== NEVER TAKEN
4000e4d0:	80 a6 c0 10 	cmp  %i3, %l0                                  
4000e4d4:	18 bf ff c2 	bgu  4000e3dc <IMFS_memfile_extend+0x58>       <== ALWAYS TAKEN
4000e4d8:	a7 3f 60 1f 	sra  %i5, 0x1f, %l3                            
  the_jnode->info.file.size = new_length;                             
                                                                      
  IMFS_update_ctime(the_jnode);                                       
  IMFS_update_mtime(the_jnode);                                       
  return 0;                                                           
}                                                                     
4000e4dc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000e4e0:	91 e8 20 00 	restore  %g0, 0, %o0                           <== NOT EXECUTED
                                                                      
          memset( &(*block_ptr) [offset], 0, count);                  
          offset = 0;                                                 
       }                                                              
    } else {                                                          
       for ( ; block>=old_blocks ; block-- ) {                        
4000e4e4:	80 a7 40 11 	cmp  %i5, %l1                                  <== NOT EXECUTED
4000e4e8:	0a 80 00 08 	bcs  4000e508 <IMFS_memfile_extend+0x184>      <== NOT EXECUTED
4000e4ec:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
         IMFS_memfile_remove_block( the_jnode, block );               
4000e4f0:	7f ff ff 99 	call  4000e354 <IMFS_memfile_remove_block>     <== NOT EXECUTED
4000e4f4:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
                                                                      
          memset( &(*block_ptr) [offset], 0, count);                  
          offset = 0;                                                 
       }                                                              
    } else {                                                          
       for ( ; block>=old_blocks ; block-- ) {                        
4000e4f8:	ba 07 7f ff 	add  %i5, -1, %i5                              <== NOT EXECUTED
4000e4fc:	80 a4 40 1d 	cmp  %l1, %i5                                  <== NOT EXECUTED
4000e500:	08 bf ff fc 	bleu  4000e4f0 <IMFS_memfile_extend+0x16c>     <== NOT EXECUTED
4000e504:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
         IMFS_memfile_remove_block( the_jnode, block );               
       }                                                              
       rtems_set_errno_and_return_minus_one( ENOSPC );                
4000e508:	40 00 04 8e 	call  4000f740 <__errno>                       <== NOT EXECUTED
4000e50c:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4000e510:	82 10 20 1c 	mov  0x1c, %g1                                 <== NOT EXECUTED
4000e514:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4000e518:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000e51c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    IMFS_assert( IMFS_type( the_jnode ) == IMFS_MEMORY_FILE );        
                                                                      
  /*                                                                  
   *  Verify new file size is supported                               
   */                                                                 
  if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )                      
4000e520:	12 80 00 04 	bne  4000e530 <IMFS_memfile_extend+0x1ac>      <== NEVER TAKEN
4000e524:	80 a2 00 1b 	cmp  %o0, %i3                                  
4000e528:	38 bf ff a9 	bgu,a   4000e3cc <IMFS_memfile_extend+0x48>    
4000e52c:	e2 07 20 50 	ld  [ %i4 + 0x50 ], %l1                        
    rtems_set_errno_and_return_minus_one( EFBIG );                    
4000e530:	40 00 04 84 	call  4000f740 <__errno>                       
4000e534:	b0 10 3f ff 	mov  -1, %i0                                   
4000e538:	82 10 20 1b 	mov  0x1b, %g1                                 
4000e53c:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4000e540:	81 c7 e0 08 	ret                                            
4000e544:	81 e8 00 00 	restore                                        
                                                                      

4000dc40 <IMFS_memfile_get_block_pointer>: #endif IMFS_jnode_t *the_jnode, unsigned int block, int malloc_it ) {
4000dc40:	9d e3 bf a0 	save  %sp, -96, %sp                            
  my_block = block;                                                   
                                                                      
  /*                                                                  
   *  Is the block number in the simple indirect portion?             
   */                                                                 
  if ( my_block <= LAST_INDIRECT ) {                                  
4000dc44:	03 10 00 7a 	sethi  %hi(0x4001e800), %g1                    
4000dc48:	fa 00 62 a0 	ld  [ %g1 + 0x2a0 ], %i5	! 4001eaa0 <imfs_memfile_bytes_per_block>
4000dc4c:	bb 37 60 02 	srl  %i5, 2, %i5                               
4000dc50:	82 07 7f ff 	add  %i5, -1, %g1                              
4000dc54:	80 a6 40 01 	cmp  %i1, %g1                                  
4000dc58:	38 80 00 0b 	bgu,a   4000dc84 <IMFS_memfile_get_block_pointer+0x44>
4000dc5c:	90 07 60 01 	add  %i5, 1, %o0                               
    p = info->indirect;                                               
                                                                      
    if ( malloc_it ) {                                                
4000dc60:	80 a6 a0 00 	cmp  %i2, 0                                    
4000dc64:	12 80 00 4e 	bne  4000dd9c <IMFS_memfile_get_block_pointer+0x15c>
4000dc68:	d0 06 20 58 	ld  [ %i0 + 0x58 ], %o0                        
        info->indirect = p;                                           
      }                                                               
      return &info->indirect[ my_block ];                             
    }                                                                 
                                                                      
    if ( !p )                                                         
4000dc6c:	80 a2 20 00 	cmp  %o0, 0                                    
4000dc70:	02 80 00 6d 	be  4000de24 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000dc74:	01 00 00 00 	nop                                            
      return 0;                                                       
                                                                      
    return &info->indirect[ my_block ];                               
4000dc78:	b3 2e 60 02 	sll  %i1, 2, %i1                               
4000dc7c:	81 c7 e0 08 	ret                                            
4000dc80:	91 ea 00 19 	restore  %o0, %i1, %o0                         
                                                                      
  /*                                                                  
   *  Is the block number in the doubly indirect portion?             
   */                                                                 
                                                                      
  if ( my_block <= LAST_DOUBLY_INDIRECT ) {                           
4000dc84:	40 00 2a c2 	call  4001878c <.umul>                         
4000dc88:	92 10 00 1d 	mov  %i5, %o1                                  
4000dc8c:	82 02 3f ff 	add  %o0, -1, %g1                              
4000dc90:	80 a6 40 01 	cmp  %i1, %g1                                  
4000dc94:	08 80 00 2b 	bleu  4000dd40 <IMFS_memfile_get_block_pointer+0x100>
4000dc98:	b8 10 00 08 	mov  %o0, %i4                                  
  }                                                                   
                                                                      
  /*                                                                  
   *  Is the block number in the triply indirect portion?             
   */                                                                 
  if ( my_block <= LAST_TRIPLY_INDIRECT ) {                           
4000dc9c:	90 02 20 01 	inc  %o0                                       
4000dca0:	40 00 2a bb 	call  4001878c <.umul>                         
4000dca4:	92 10 00 1d 	mov  %i5, %o1                                  
4000dca8:	90 02 3f ff 	add  %o0, -1, %o0                              
4000dcac:	80 a6 40 08 	cmp  %i1, %o0                                  
4000dcb0:	18 80 00 5d 	bgu  4000de24 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000dcb4:	b2 26 40 1c 	sub  %i1, %i4, %i1                             
    my_block -= FIRST_TRIPLY_INDIRECT;                                
                                                                      
    singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;                     
4000dcb8:	92 10 00 1d 	mov  %i5, %o1                                  
4000dcbc:	40 00 2b 9a 	call  40018b24 <.urem>                         
4000dcc0:	90 10 00 19 	mov  %i1, %o0                                  
    doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;                     
4000dcc4:	92 10 00 1d 	mov  %i5, %o1                                  
   *  Is the block number in the triply indirect portion?             
   */                                                                 
  if ( my_block <= LAST_TRIPLY_INDIRECT ) {                           
    my_block -= FIRST_TRIPLY_INDIRECT;                                
                                                                      
    singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;                     
4000dcc8:	a0 10 00 08 	mov  %o0, %l0                                  
    doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;                     
4000dccc:	40 00 2a ea 	call  40018874 <.udiv>                         
4000dcd0:	90 10 00 19 	mov  %i1, %o0                                  
    triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;                       
4000dcd4:	92 10 00 1d 	mov  %i5, %o1                                  
4000dcd8:	40 00 2a e7 	call  40018874 <.udiv>                         
4000dcdc:	b8 10 00 08 	mov  %o0, %i4                                  
    doubly %= IMFS_MEMFILE_BLOCK_SLOTS;                               
4000dce0:	92 10 00 1d 	mov  %i5, %o1                                  
  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;                       
4000dce4:	b6 10 00 08 	mov  %o0, %i3                                  
    doubly %= IMFS_MEMFILE_BLOCK_SLOTS;                               
4000dce8:	40 00 2b 8f 	call  40018b24 <.urem>                         
4000dcec:	90 10 00 1c 	mov  %i4, %o0                                  
                                                                      
    p = info->triply_indirect;                                        
                                                                      
    if ( malloc_it ) {                                                
4000dcf0:	80 a6 a0 00 	cmp  %i2, 0                                    
    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;                               
4000dcf4:	ba 10 00 08 	mov  %o0, %i5                                  
                                                                      
    p = info->triply_indirect;                                        
                                                                      
    if ( malloc_it ) {                                                
4000dcf8:	02 80 00 3d 	be  4000ddec <IMFS_memfile_get_block_pointer+0x1ac>
4000dcfc:	d0 06 20 60 	ld  [ %i0 + 0x60 ], %o0                        
      if ( !p ) {                                                     
4000dd00:	80 a2 20 00 	cmp  %o0, 0                                    
4000dd04:	02 80 00 66 	be  4000de9c <IMFS_memfile_get_block_pointer+0x25c>
4000dd08:	01 00 00 00 	nop                                            
        if ( !p )                                                     
           return 0;                                                  
        info->triply_indirect = p;                                    
      }                                                               
                                                                      
      p1 = (block_p *) p[ triply ];                                   
4000dd0c:	b7 2e e0 02 	sll  %i3, 2, %i3                               
4000dd10:	c4 02 00 1b 	ld  [ %o0 + %i3 ], %g2                         
      if ( !p1 ) {                                                    
4000dd14:	80 a0 a0 00 	cmp  %g2, 0                                    
4000dd18:	02 80 00 5a 	be  4000de80 <IMFS_memfile_get_block_pointer+0x240>
4000dd1c:	b6 02 00 1b 	add  %o0, %i3, %i3                             
        if ( !p1 )                                                    
           return 0;                                                  
        p[ triply ] = (block_p) p1;                                   
      }                                                               
                                                                      
      p2 = (block_p *)p1[ doubly ];                                   
4000dd20:	bb 2f 60 02 	sll  %i5, 2, %i5                               
4000dd24:	d0 00 80 1d 	ld  [ %g2 + %i5 ], %o0                         
      if ( !p2 ) {                                                    
4000dd28:	80 a2 20 00 	cmp  %o0, 0                                    
4000dd2c:	02 80 00 47 	be  4000de48 <IMFS_memfile_get_block_pointer+0x208>
4000dd30:	ba 00 80 1d 	add  %g2, %i5, %i5                             
        p2 = memfile_alloc_block();                                   
        if ( !p2 )                                                    
           return 0;                                                  
        p1[ doubly ] = (block_p) p2;                                  
      }                                                               
      return (block_p *)&p2[ singly ];                                
4000dd34:	b1 2c 20 02 	sll  %l0, 2, %i0                               
4000dd38:	81 c7 e0 08 	ret                                            
4000dd3c:	91 ea 00 18 	restore  %o0, %i0, %o0                         
  /*                                                                  
   *  Is the block number in the doubly indirect portion?             
   */                                                                 
                                                                      
  if ( my_block <= LAST_DOUBLY_INDIRECT ) {                           
    my_block -= FIRST_DOUBLY_INDIRECT;                                
4000dd40:	b2 26 40 1d 	sub  %i1, %i5, %i1                             
                                                                      
    singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;                     
4000dd44:	92 10 00 1d 	mov  %i5, %o1                                  
4000dd48:	40 00 2b 77 	call  40018b24 <.urem>                         
4000dd4c:	90 10 00 19 	mov  %i1, %o0                                  
    doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;                     
4000dd50:	92 10 00 1d 	mov  %i5, %o1                                  
   */                                                                 
                                                                      
  if ( my_block <= LAST_DOUBLY_INDIRECT ) {                           
    my_block -= FIRST_DOUBLY_INDIRECT;                                
                                                                      
    singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;                     
4000dd54:	b8 10 00 08 	mov  %o0, %i4                                  
    doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;                     
4000dd58:	40 00 2a c7 	call  40018874 <.udiv>                         
4000dd5c:	90 10 00 19 	mov  %i1, %o0                                  
                                                                      
    p = info->doubly_indirect;                                        
4000dd60:	c2 06 20 5c 	ld  [ %i0 + 0x5c ], %g1                        
    if ( malloc_it ) {                                                
4000dd64:	80 a6 a0 00 	cmp  %i2, 0                                    
4000dd68:	02 80 00 17 	be  4000ddc4 <IMFS_memfile_get_block_pointer+0x184>
4000dd6c:	ba 10 00 08 	mov  %o0, %i5                                  
                                                                      
      if ( !p ) {                                                     
4000dd70:	80 a0 60 00 	cmp  %g1, 0                                    
4000dd74:	02 80 00 3c 	be  4000de64 <IMFS_memfile_get_block_pointer+0x224>
4000dd78:	01 00 00 00 	nop                                            
        if ( !p )                                                     
           return 0;                                                  
        info->doubly_indirect = p;                                    
      }                                                               
                                                                      
      p1 = (block_p *)p[ doubly ];                                    
4000dd7c:	bb 2f 60 02 	sll  %i5, 2, %i5                               
4000dd80:	d0 00 40 1d 	ld  [ %g1 + %i5 ], %o0                         
      if ( !p1 ) {                                                    
4000dd84:	80 a2 20 00 	cmp  %o0, 0                                    
4000dd88:	02 80 00 29 	be  4000de2c <IMFS_memfile_get_block_pointer+0x1ec>
4000dd8c:	ba 00 40 1d 	add  %g1, %i5, %i5                             
        if ( !p1 )                                                    
           return 0;                                                  
        p[ doubly ] = (block_p) p1;                                   
      }                                                               
                                                                      
      return (block_p *)&p1[ singly ];                                
4000dd90:	b1 2f 20 02 	sll  %i4, 2, %i0                               
4000dd94:	81 c7 e0 08 	ret                                            
4000dd98:	91 ea 00 18 	restore  %o0, %i0, %o0                         
  if ( my_block <= LAST_INDIRECT ) {                                  
    p = info->indirect;                                               
                                                                      
    if ( malloc_it ) {                                                
                                                                      
      if ( !p ) {                                                     
4000dd9c:	80 a2 20 00 	cmp  %o0, 0                                    
4000dda0:	32 bf ff b7 	bne,a   4000dc7c <IMFS_memfile_get_block_pointer+0x3c>
4000dda4:	b3 2e 60 02 	sll  %i1, 2, %i1                               
        p = memfile_alloc_block();                                    
4000dda8:	7f ff ff 99 	call  4000dc0c <memfile_alloc_block>           
4000ddac:	01 00 00 00 	nop                                            
        if ( !p )                                                     
4000ddb0:	80 a2 20 00 	cmp  %o0, 0                                    
4000ddb4:	02 80 00 1c 	be  4000de24 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000ddb8:	01 00 00 00 	nop                                            
           return 0;                                                  
        info->indirect = p;                                           
4000ddbc:	10 bf ff af 	b  4000dc78 <IMFS_memfile_get_block_pointer+0x38>
4000ddc0:	d0 26 20 58 	st  %o0, [ %i0 + 0x58 ]                        
      }                                                               
                                                                      
      return (block_p *)&p1[ singly ];                                
    }                                                                 
                                                                      
    if ( !p )                                                         
4000ddc4:	80 a0 60 00 	cmp  %g1, 0                                    
4000ddc8:	02 80 00 17 	be  4000de24 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000ddcc:	bb 2a 20 02 	sll  %o0, 2, %i5                               
      return 0;                                                       
                                                                      
    p = (block_p *)p[ doubly ];                                       
4000ddd0:	c2 00 40 1d 	ld  [ %g1 + %i5 ], %g1                         
    if ( !p )                                                         
4000ddd4:	80 a0 60 00 	cmp  %g1, 0                                    
4000ddd8:	02 80 00 13 	be  4000de24 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000dddc:	01 00 00 00 	nop                                            
      return 0;                                                       
                                                                      
    return (block_p *)&p[ singly ];                                   
4000dde0:	b1 2f 20 02 	sll  %i4, 2, %i0                               
4000dde4:	81 c7 e0 08 	ret                                            
4000dde8:	91 e8 40 18 	restore  %g1, %i0, %o0                         
        p1[ doubly ] = (block_p) p2;                                  
      }                                                               
      return (block_p *)&p2[ singly ];                                
    }                                                                 
                                                                      
    if ( !p )                                                         
4000ddec:	80 a2 20 00 	cmp  %o0, 0                                    
4000ddf0:	02 80 00 0d 	be  4000de24 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000ddf4:	b7 2e e0 02 	sll  %i3, 2, %i3                               
      return 0;                                                       
                                                                      
    p1 = (block_p *) p[ triply ];                                     
4000ddf8:	c2 02 00 1b 	ld  [ %o0 + %i3 ], %g1                         
    if ( !p1 )                                                        
4000ddfc:	80 a0 60 00 	cmp  %g1, 0                                    
4000de00:	02 80 00 09 	be  4000de24 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000de04:	bb 2f 60 02 	sll  %i5, 2, %i5                               
      return 0;                                                       
                                                                      
    p2 = (block_p *)p1[ doubly ];                                     
4000de08:	c2 00 40 1d 	ld  [ %g1 + %i5 ], %g1                         
    if ( !p2 )                                                        
4000de0c:	80 a0 60 00 	cmp  %g1, 0                                    
4000de10:	02 80 00 05 	be  4000de24 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000de14:	01 00 00 00 	nop                                            
      return 0;                                                       
                                                                      
    return (block_p *)&p2[ singly ];                                  
4000de18:	b1 2c 20 02 	sll  %l0, 2, %i0                               
                                                                      
  /*                                                                  
   *  This means the requested block number is out of range.          
   */                                                                 
  return 0;                                                           
}                                                                     
4000de1c:	81 c7 e0 08 	ret                                            
4000de20:	91 e8 40 18 	restore  %g1, %i0, %o0                         
    if ( malloc_it ) {                                                
                                                                      
      if ( !p ) {                                                     
        p = memfile_alloc_block();                                    
        if ( !p )                                                     
           return 0;                                                  
4000de24:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000de28:	91 e8 20 00 	restore  %g0, 0, %o0                           <== NOT EXECUTED
        info->doubly_indirect = p;                                    
      }                                                               
                                                                      
      p1 = (block_p *)p[ doubly ];                                    
      if ( !p1 ) {                                                    
        p1 = memfile_alloc_block();                                   
4000de2c:	7f ff ff 78 	call  4000dc0c <memfile_alloc_block>           
4000de30:	01 00 00 00 	nop                                            
        if ( !p1 )                                                    
4000de34:	80 a2 20 00 	cmp  %o0, 0                                    
4000de38:	02 bf ff fb 	be  4000de24 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000de3c:	01 00 00 00 	nop                                            
           return 0;                                                  
        p[ doubly ] = (block_p) p1;                                   
4000de40:	10 bf ff d4 	b  4000dd90 <IMFS_memfile_get_block_pointer+0x150>
4000de44:	d0 27 40 00 	st  %o0, [ %i5 ]                               
        p[ triply ] = (block_p) p1;                                   
      }                                                               
                                                                      
      p2 = (block_p *)p1[ doubly ];                                   
      if ( !p2 ) {                                                    
        p2 = memfile_alloc_block();                                   
4000de48:	7f ff ff 71 	call  4000dc0c <memfile_alloc_block>           
4000de4c:	01 00 00 00 	nop                                            
        if ( !p2 )                                                    
4000de50:	80 a2 20 00 	cmp  %o0, 0                                    
4000de54:	02 bf ff f4 	be  4000de24 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000de58:	01 00 00 00 	nop                                            
           return 0;                                                  
        p1[ doubly ] = (block_p) p2;                                  
4000de5c:	10 bf ff b6 	b  4000dd34 <IMFS_memfile_get_block_pointer+0xf4>
4000de60:	d0 27 40 00 	st  %o0, [ %i5 ]                               
                                                                      
    p = info->doubly_indirect;                                        
    if ( malloc_it ) {                                                
                                                                      
      if ( !p ) {                                                     
        p = memfile_alloc_block();                                    
4000de64:	7f ff ff 6a 	call  4000dc0c <memfile_alloc_block>           
4000de68:	01 00 00 00 	nop                                            
        if ( !p )                                                     
4000de6c:	82 92 20 00 	orcc  %o0, 0, %g1                              
4000de70:	02 bf ff ed 	be  4000de24 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000de74:	01 00 00 00 	nop                                            
           return 0;                                                  
        info->doubly_indirect = p;                                    
4000de78:	10 bf ff c1 	b  4000dd7c <IMFS_memfile_get_block_pointer+0x13c>
4000de7c:	c2 26 20 5c 	st  %g1, [ %i0 + 0x5c ]                        
        info->triply_indirect = p;                                    
      }                                                               
                                                                      
      p1 = (block_p *) p[ triply ];                                   
      if ( !p1 ) {                                                    
        p1 = memfile_alloc_block();                                   
4000de80:	7f ff ff 63 	call  4000dc0c <memfile_alloc_block>           
4000de84:	01 00 00 00 	nop                                            
        if ( !p1 )                                                    
4000de88:	84 92 20 00 	orcc  %o0, 0, %g2                              
4000de8c:	02 bf ff e6 	be  4000de24 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000de90:	01 00 00 00 	nop                                            
           return 0;                                                  
        p[ triply ] = (block_p) p1;                                   
4000de94:	10 bf ff a3 	b  4000dd20 <IMFS_memfile_get_block_pointer+0xe0>
4000de98:	c4 26 c0 00 	st  %g2, [ %i3 ]                               
                                                                      
    p = info->triply_indirect;                                        
                                                                      
    if ( malloc_it ) {                                                
      if ( !p ) {                                                     
        p = memfile_alloc_block();                                    
4000de9c:	7f ff ff 5c 	call  4000dc0c <memfile_alloc_block>           
4000dea0:	01 00 00 00 	nop                                            
        if ( !p )                                                     
4000dea4:	80 a2 20 00 	cmp  %o0, 0                                    
4000dea8:	02 bf ff df 	be  4000de24 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000deac:	01 00 00 00 	nop                                            
           return 0;                                                  
        info->triply_indirect = p;                                    
4000deb0:	10 bf ff 97 	b  4000dd0c <IMFS_memfile_get_block_pointer+0xcc>
4000deb4:	d0 26 20 60 	st  %o0, [ %i0 + 0x60 ]                        
                                                                      

4000deb8 <IMFS_memfile_read>: IMFS_jnode_t *the_jnode, off_t start, unsigned char *destination, unsigned int length ) {
4000deb8:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_chain_extract_unprotected( &node->Node );                     
}                                                                     
                                                                      
static inline IMFS_jnode_types_t IMFS_type( const IMFS_jnode_t *node )
{                                                                     
  return node->control->imfs_type;                                    
4000debc:	c2 06 20 4c 	ld  [ %i0 + 0x4c ], %g1                        
4000dec0:	a4 10 00 18 	mov  %i0, %l2                                  
   *  Linear files (as created from a tar file are easier to handle   
   *  than block files).                                              
   */                                                                 
  my_length = length;                                                 
                                                                      
  if ( IMFS_type( the_jnode ) == IMFS_LINEAR_FILE ) {                 
4000dec4:	c2 00 40 00 	ld  [ %g1 ], %g1                               
   IMFS_jnode_t    *the_jnode,                                        
   off_t            start,                                            
   unsigned char   *destination,                                      
   unsigned int     length                                            
)                                                                     
{                                                                     
4000dec8:	a0 10 00 19 	mov  %i1, %l0                                  
4000decc:	a2 10 00 1a 	mov  %i2, %l1                                  
   *  Linear files (as created from a tar file are easier to handle   
   *  than block files).                                              
   */                                                                 
  my_length = length;                                                 
                                                                      
  if ( IMFS_type( the_jnode ) == IMFS_LINEAR_FILE ) {                 
4000ded0:	80 a0 60 05 	cmp  %g1, 5                                    
4000ded4:	02 80 00 68 	be  4000e074 <IMFS_memfile_read+0x1bc>         
4000ded8:	a6 10 00 1b 	mov  %i3, %l3                                  
  /*                                                                  
   *  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 )                        
4000dedc:	c4 06 20 50 	ld  [ %i0 + 0x50 ], %g2                        
4000dee0:	86 10 20 00 	clr  %g3                                       
                                                                      
  /*                                                                  
   *  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;                                         
4000dee4:	82 10 00 1a 	mov  %i2, %g1                                  
  if ( last_byte > the_jnode->info.file.size )                        
4000dee8:	c8 06 20 54 	ld  [ %i0 + 0x54 ], %g4                        
4000deec:	80 a0 c0 02 	cmp  %g3, %g2                                  
4000def0:	04 80 00 42 	ble  4000dff8 <IMFS_memfile_read+0x140>        <== ALWAYS TAKEN
4000def4:	ba 07 00 1a 	add  %i4, %i2, %i5                             
    my_length = the_jnode->info.file.size - start;                    
4000def8:	b8 21 00 01 	sub  %g4, %g1, %i4                             <== NOT EXECUTED
   */                                                                 
                                                                      
  /*                                                                  
   *  Phase 1: possibly the last part of one block                    
   */                                                                 
  start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;                
4000defc:	33 10 00 7a 	sethi  %hi(0x4001e800), %i1                    <== NOT EXECUTED
4000df00:	fa 06 62 a0 	ld  [ %i1 + 0x2a0 ], %i5	! 4001eaa0 <imfs_memfile_bytes_per_block>
4000df04:	90 10 00 10 	mov  %l0, %o0                                  
4000df08:	b7 3f 60 1f 	sra  %i5, 0x1f, %i3                            
4000df0c:	96 10 00 1d 	mov  %i5, %o3                                  
4000df10:	94 10 00 1b 	mov  %i3, %o2                                  
4000df14:	40 00 2c 9b 	call  40019180 <__moddi3>                      
4000df18:	92 10 00 11 	mov  %l1, %o1                                  
  block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;                       
4000df1c:	90 10 00 10 	mov  %l0, %o0                                  
   */                                                                 
                                                                      
  /*                                                                  
   *  Phase 1: possibly the last part of one block                    
   */                                                                 
  start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;                
4000df20:	a8 10 00 09 	mov  %o1, %l4                                  
  block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;                       
4000df24:	94 10 00 1b 	mov  %i3, %o2                                  
4000df28:	92 10 00 11 	mov  %l1, %o1                                  
4000df2c:	40 00 2b aa 	call  40018dd4 <__divdi3>                      
4000df30:	96 10 00 1d 	mov  %i5, %o3                                  
  if ( start_offset )  {                                              
4000df34:	80 a5 20 00 	cmp  %l4, 0                                    
4000df38:	02 80 00 37 	be  4000e014 <IMFS_memfile_read+0x15c>         
4000df3c:	b4 10 00 09 	mov  %o1, %i2                                  
    to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;            
4000df40:	ba 27 40 14 	sub  %i5, %l4, %i5                             
4000df44:	80 a7 00 1d 	cmp  %i4, %i5                                  
4000df48:	18 80 00 59 	bgu  4000e0ac <IMFS_memfile_read+0x1f4>        
4000df4c:	a0 10 00 1c 	mov  %i4, %l0                                  
    if ( to_copy > my_length )                                        
      to_copy = my_length;                                            
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4000df50:	90 10 00 12 	mov  %l2, %o0                                  
4000df54:	92 10 00 1a 	mov  %i2, %o1                                  
4000df58:	94 10 20 00 	clr  %o2                                       
4000df5c:	7f ff ff 39 	call  4000dc40 <IMFS_memfile_get_block_pointer>
4000df60:	b0 10 20 00 	clr  %i0                                       
    if ( !block_ptr )                                                 
4000df64:	80 a2 20 00 	cmp  %o0, 0                                    
4000df68:	02 80 00 22 	be  4000dff0 <IMFS_memfile_read+0x138>         <== NEVER TAKEN
4000df6c:	94 10 00 10 	mov  %l0, %o2                                  
      return copied;                                                  
    memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );           
4000df70:	d2 02 00 00 	ld  [ %o0 ], %o1                               
4000df74:	90 10 00 13 	mov  %l3, %o0                                  
4000df78:	40 00 08 43 	call  40010084 <memcpy>                        
4000df7c:	92 02 40 14 	add  %o1, %l4, %o1                             
4000df80:	fa 06 62 a0 	ld  [ %i1 + 0x2a0 ], %i5                       
    dest += to_copy;                                                  
4000df84:	b6 04 c0 10 	add  %l3, %l0, %i3                             
    block++;                                                          
4000df88:	b4 06 a0 01 	inc  %i2                                       
    my_length -= to_copy;                                             
4000df8c:	b8 27 00 10 	sub  %i4, %l0, %i4                             
    copied += to_copy;                                                
4000df90:	b0 10 00 10 	mov  %l0, %i0                                  
                                                                      
  /*                                                                  
   *  Phase 2: all of zero of more blocks                             
   */                                                                 
  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;                             
  while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {               
4000df94:	80 a7 00 1d 	cmp  %i4, %i5                                  
4000df98:	1a 80 00 0e 	bcc  4000dfd0 <IMFS_memfile_read+0x118>        
4000df9c:	94 10 20 00 	clr  %o2                                       
  /*                                                                  
   *  Phase 3: possibly the first part of one block                   
   */                                                                 
  IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );            
                                                                      
  if ( my_length ) {                                                  
4000dfa0:	10 80 00 21 	b  4000e024 <IMFS_memfile_read+0x16c>          
4000dfa4:	80 a7 20 00 	cmp  %i4, 0                                    
  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;                             
  while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {               
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
    if ( !block_ptr )                                                 
      return copied;                                                  
    memcpy( dest, &(*block_ptr)[ 0 ], to_copy );                      
4000dfa8:	d2 00 40 00 	ld  [ %g1 ], %o1                               
4000dfac:	40 00 08 36 	call  40010084 <memcpy>                        
4000dfb0:	b8 27 00 1d 	sub  %i4, %i5, %i4                             
                                                                      
  /*                                                                  
   *  Phase 2: all of zero of more blocks                             
   */                                                                 
  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;                             
  while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {               
4000dfb4:	c2 06 62 a0 	ld  [ %i1 + 0x2a0 ], %g1                       
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
    if ( !block_ptr )                                                 
      return copied;                                                  
    memcpy( dest, &(*block_ptr)[ 0 ], to_copy );                      
    dest += to_copy;                                                  
4000dfb8:	b6 06 c0 1d 	add  %i3, %i5, %i3                             
    block++;                                                          
4000dfbc:	b4 06 a0 01 	inc  %i2                                       
                                                                      
  /*                                                                  
   *  Phase 2: all of zero of more blocks                             
   */                                                                 
  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;                             
  while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {               
4000dfc0:	80 a0 40 1c 	cmp  %g1, %i4                                  
4000dfc4:	18 80 00 17 	bgu  4000e020 <IMFS_memfile_read+0x168>        
4000dfc8:	b0 06 00 1d 	add  %i0, %i5, %i0                             
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4000dfcc:	94 10 20 00 	clr  %o2                                       
4000dfd0:	92 10 00 1a 	mov  %i2, %o1                                  
4000dfd4:	7f ff ff 1b 	call  4000dc40 <IMFS_memfile_get_block_pointer>
4000dfd8:	90 10 00 12 	mov  %l2, %o0                                  
    if ( !block_ptr )                                                 
      return copied;                                                  
    memcpy( dest, &(*block_ptr)[ 0 ], to_copy );                      
4000dfdc:	94 10 00 1d 	mov  %i5, %o2                                  
  /*                                                                  
   *  Phase 2: all of zero of more blocks                             
   */                                                                 
  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;                             
  while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {               
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4000dfe0:	82 10 00 08 	mov  %o0, %g1                                  
    if ( !block_ptr )                                                 
4000dfe4:	80 a0 60 00 	cmp  %g1, 0                                    
4000dfe8:	12 bf ff f0 	bne  4000dfa8 <IMFS_memfile_read+0xf0>         <== ALWAYS TAKEN
4000dfec:	90 10 00 1b 	mov  %i3, %o0                                  
  }                                                                   
                                                                      
  IMFS_update_atime( the_jnode );                                     
                                                                      
  return copied;                                                      
}                                                                     
4000dff0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000dff4:	81 e8 00 00 	restore                                        <== 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 )                        
4000dff8:	12 bf ff c2 	bne  4000df00 <IMFS_memfile_read+0x48>         <== NEVER TAKEN
4000dffc:	33 10 00 7a 	sethi  %hi(0x4001e800), %i1                    
4000e000:	80 a7 40 04 	cmp  %i5, %g4                                  
4000e004:	08 bf ff c0 	bleu  4000df04 <IMFS_memfile_read+0x4c>        
4000e008:	fa 06 62 a0 	ld  [ %i1 + 0x2a0 ], %i5                       
    my_length = the_jnode->info.file.size - start;                    
4000e00c:	10 bf ff bd 	b  4000df00 <IMFS_memfile_read+0x48>           
4000e010:	b8 21 00 01 	sub  %g4, %g1, %i4                             
  unsigned int         last_byte;                                     
  unsigned int         copied;                                        
  unsigned int         start_offset;                                  
  unsigned char       *dest;                                          
                                                                      
  dest = destination;                                                 
4000e014:	b6 10 00 13 	mov  %l3, %i3                                  
   */                                                                 
  last_byte = start + length;                                         
  if ( last_byte > the_jnode->info.file.size )                        
    my_length = the_jnode->info.file.size - start;                    
                                                                      
  copied = 0;                                                         
4000e018:	10 bf ff df 	b  4000df94 <IMFS_memfile_read+0xdc>           
4000e01c:	b0 10 20 00 	clr  %i0                                       
  /*                                                                  
   *  Phase 3: possibly the first part of one block                   
   */                                                                 
  IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );            
                                                                      
  if ( my_length ) {                                                  
4000e020:	80 a7 20 00 	cmp  %i4, 0                                    
4000e024:	02 80 00 0e 	be  4000e05c <IMFS_memfile_read+0x1a4>         
4000e028:	90 07 bf f8 	add  %fp, -8, %o0                              
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4000e02c:	90 10 00 12 	mov  %l2, %o0                                  
4000e030:	92 10 00 1a 	mov  %i2, %o1                                  
4000e034:	7f ff ff 03 	call  4000dc40 <IMFS_memfile_get_block_pointer>
4000e038:	94 10 20 00 	clr  %o2                                       
    if ( !block_ptr )                                                 
4000e03c:	80 a2 20 00 	cmp  %o0, 0                                    
4000e040:	02 bf ff ec 	be  4000dff0 <IMFS_memfile_read+0x138>         <== NEVER TAKEN
4000e044:	94 10 00 1c 	mov  %i4, %o2                                  
      return copied;                                                  
    memcpy( dest, &(*block_ptr)[ 0 ], my_length );                    
4000e048:	d2 02 00 00 	ld  [ %o0 ], %o1                               
4000e04c:	90 10 00 1b 	mov  %i3, %o0                                  
4000e050:	40 00 08 0d 	call  40010084 <memcpy>                        
4000e054:	b0 06 00 1c 	add  %i0, %i4, %i0                             
    copied += my_length;                                              
  }                                                                   
                                                                      
  IMFS_update_atime( the_jnode );                                     
4000e058:	90 07 bf f8 	add  %fp, -8, %o0                              
4000e05c:	7f ff d4 1d 	call  400030d0 <gettimeofday>                  
4000e060:	92 10 20 00 	clr  %o1                                       
4000e064:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
4000e068:	c2 24 a0 40 	st  %g1, [ %l2 + 0x40 ]                        
                                                                      
  return copied;                                                      
}                                                                     
4000e06c:	81 c7 e0 08 	ret                                            
4000e070:	81 e8 00 00 	restore                                        
  if ( IMFS_type( the_jnode ) == IMFS_LINEAR_FILE ) {                 
    unsigned char  *file_ptr;                                         
                                                                      
    file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;    
                                                                      
    if (my_length > (the_jnode->info.linearfile.size - start))        
4000e074:	f4 1e 20 50 	ldd  [ %i0 + 0x50 ], %i2                       
4000e078:	82 10 20 00 	clr  %g1                                       
4000e07c:	86 a6 c0 11 	subcc  %i3, %l1, %g3                           
4000e080:	84 66 80 19 	subx  %i2, %i1, %g2                            
4000e084:	80 a0 40 02 	cmp  %g1, %g2                                  
4000e088:	04 80 00 0b 	ble  4000e0b4 <IMFS_memfile_read+0x1fc>        <== ALWAYS TAKEN
4000e08c:	d2 06 20 58 	ld  [ %i0 + 0x58 ], %o1                        
      my_length = the_jnode->info.linearfile.size - start;            
4000e090:	b0 26 c0 11 	sub  %i3, %l1, %i0                             <== NOT EXECUTED
                                                                      
    memcpy(dest, &file_ptr[start], my_length);                        
4000e094:	92 02 40 11 	add  %o1, %l1, %o1                             
4000e098:	94 10 00 18 	mov  %i0, %o2                                  
                                                                      
  if ( my_length ) {                                                  
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
    if ( !block_ptr )                                                 
      return copied;                                                  
    memcpy( dest, &(*block_ptr)[ 0 ], my_length );                    
4000e09c:	40 00 07 fa 	call  40010084 <memcpy>                        
4000e0a0:	90 10 00 13 	mov  %l3, %o0                                  
    copied += my_length;                                              
  }                                                                   
                                                                      
  IMFS_update_atime( the_jnode );                                     
4000e0a4:	10 bf ff ee 	b  4000e05c <IMFS_memfile_read+0x1a4>          
4000e0a8:	90 07 bf f8 	add  %fp, -8, %o0                              
4000e0ac:	10 bf ff a9 	b  4000df50 <IMFS_memfile_read+0x98>           
4000e0b0:	a0 10 00 1d 	mov  %i5, %l0                                  
  if ( IMFS_type( the_jnode ) == IMFS_LINEAR_FILE ) {                 
    unsigned char  *file_ptr;                                         
                                                                      
    file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;    
                                                                      
    if (my_length > (the_jnode->info.linearfile.size - start))        
4000e0b4:	12 80 00 04 	bne  4000e0c4 <IMFS_memfile_read+0x20c>        <== NEVER TAKEN
4000e0b8:	80 a7 00 03 	cmp  %i4, %g3                                  
4000e0bc:	38 bf ff f6 	bgu,a   4000e094 <IMFS_memfile_read+0x1dc>     <== ALWAYS TAKEN
4000e0c0:	b0 26 c0 11 	sub  %i3, %l1, %i0                             
                                                                      
  /*                                                                  
   *  Linear files (as created from a tar file are easier to handle   
   *  than block files).                                              
   */                                                                 
  my_length = length;                                                 
4000e0c4:	10 bf ff f4 	b  4000e094 <IMFS_memfile_read+0x1dc>          <== NOT EXECUTED
4000e0c8:	b0 10 00 1c 	mov  %i4, %i0                                  <== NOT EXECUTED
                                                                      

4000e1dc <IMFS_memfile_remove>: * is better to stick to simple, easy to understand algorithms. */ IMFS_jnode_t *IMFS_memfile_remove( IMFS_jnode_t *the_jnode ) {
4000e1dc:	9d e3 bf a0 	save  %sp, -96, %sp                            
                                                                      
  /*                                                                  
   *  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;                                 
4000e1e0:	39 10 00 7a 	sethi  %hi(0x4001e800), %i4                    
   *    + doubly indirect                                             
   *    + triply indirect                                             
   */                                                                 
  info = &the_jnode->info.file;                                       
                                                                      
  if ( info->indirect ) {                                             
4000e1e4:	c2 06 20 58 	ld  [ %i0 + 0x58 ], %g1                        
                                                                      
  /*                                                                  
   *  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;                                 
4000e1e8:	f4 07 22 a0 	ld  [ %i4 + 0x2a0 ], %i2                       
   *    + doubly indirect                                             
   *    + triply indirect                                             
   */                                                                 
  info = &the_jnode->info.file;                                       
                                                                      
  if ( info->indirect ) {                                             
4000e1ec:	80 a0 60 00 	cmp  %g1, 0                                    
4000e1f0:	02 80 00 05 	be  4000e204 <IMFS_memfile_remove+0x28>        
4000e1f4:	b5 36 a0 02 	srl  %i2, 2, %i2                               
    memfile_free_blocks_in_table( &info->indirect, to_free );         
4000e1f8:	90 06 20 58 	add  %i0, 0x58, %o0                            
4000e1fc:	7f ff ff e2 	call  4000e184 <memfile_free_blocks_in_table>  
4000e200:	92 10 00 1a 	mov  %i2, %o1                                  
  }                                                                   
                                                                      
  if ( info->doubly_indirect ) {                                      
4000e204:	c2 06 20 5c 	ld  [ %i0 + 0x5c ], %g1                        
4000e208:	80 a0 60 00 	cmp  %g1, 0                                    
4000e20c:	02 80 00 1b 	be  4000e278 <IMFS_memfile_remove+0x9c>        
4000e210:	c4 07 22 a0 	ld  [ %i4 + 0x2a0 ], %g2                       
    for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {                  
4000e214:	85 30 a0 02 	srl  %g2, 2, %g2                               
4000e218:	80 a0 a0 00 	cmp  %g2, 0                                    
4000e21c:	02 80 00 14 	be  4000e26c <IMFS_memfile_remove+0x90>        <== NEVER TAKEN
4000e220:	90 10 20 00 	clr  %o0                                       
4000e224:	37 10 00 7a 	sethi  %hi(0x4001e800), %i3                    
4000e228:	ba 10 20 00 	clr  %i5                                       
4000e22c:	10 80 00 03 	b  4000e238 <IMFS_memfile_remove+0x5c>         
4000e230:	b6 16 e2 a0 	or  %i3, 0x2a0, %i3                            
4000e234:	c2 06 20 5c 	ld  [ %i0 + 0x5c ], %g1                        
      if ( info->doubly_indirect[i] ) {                               
4000e238:	91 2a 20 02 	sll  %o0, 2, %o0                               
4000e23c:	c4 00 40 08 	ld  [ %g1 + %o0 ], %g2                         
4000e240:	80 a0 a0 00 	cmp  %g2, 0                                    
4000e244:	02 80 00 04 	be  4000e254 <IMFS_memfile_remove+0x78>        <== NEVER TAKEN
4000e248:	90 00 40 08 	add  %g1, %o0, %o0                             
        memfile_free_blocks_in_table(                                 
4000e24c:	7f ff ff ce 	call  4000e184 <memfile_free_blocks_in_table>  
4000e250:	92 10 00 1a 	mov  %i2, %o1                                  
  if ( info->indirect ) {                                             
    memfile_free_blocks_in_table( &info->indirect, to_free );         
  }                                                                   
                                                                      
  if ( info->doubly_indirect ) {                                      
    for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {                  
4000e254:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
4000e258:	ba 07 60 01 	inc  %i5                                       
4000e25c:	83 30 60 02 	srl  %g1, 2, %g1                               
4000e260:	80 a7 40 01 	cmp  %i5, %g1                                  
4000e264:	0a bf ff f4 	bcs  4000e234 <IMFS_memfile_remove+0x58>       
4000e268:	90 10 00 1d 	mov  %i5, %o0                                  
      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 );  
4000e26c:	90 06 20 5c 	add  %i0, 0x5c, %o0                            
4000e270:	7f ff ff c5 	call  4000e184 <memfile_free_blocks_in_table>  
4000e274:	92 10 00 1a 	mov  %i2, %o1                                  
                                                                      
  }                                                                   
                                                                      
  if ( info->triply_indirect ) {                                      
4000e278:	d0 06 20 60 	ld  [ %i0 + 0x60 ], %o0                        
4000e27c:	80 a2 20 00 	cmp  %o0, 0                                    
4000e280:	02 80 00 33 	be  4000e34c <IMFS_memfile_remove+0x170>       
4000e284:	c4 07 22 a0 	ld  [ %i4 + 0x2a0 ], %g2                       
    for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {                  
4000e288:	85 30 a0 02 	srl  %g2, 2, %g2                               
4000e28c:	80 a0 a0 00 	cmp  %g2, 0                                    
4000e290:	22 80 00 2d 	be,a   4000e344 <IMFS_memfile_remove+0x168>    <== NEVER TAKEN
4000e294:	90 06 20 60 	add  %i0, 0x60, %o0                            <== NOT EXECUTED
      p = (block_p *) info->triply_indirect[i];                       
4000e298:	f8 02 00 00 	ld  [ %o0 ], %i4                               
      if ( !p )  /* ensure we have a valid pointer */                 
4000e29c:	80 a7 20 00 	cmp  %i4, 0                                    
4000e2a0:	22 80 00 29 	be,a   4000e344 <IMFS_memfile_remove+0x168>    <== NEVER TAKEN
4000e2a4:	90 06 20 60 	add  %i0, 0x60, %o0                            <== NOT EXECUTED
4000e2a8:	37 10 00 7a 	sethi  %hi(0x4001e800), %i3                    
                                                                      
  }                                                                   
                                                                      
  if ( info->triply_indirect ) {                                      
    for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {                  
      p = (block_p *) info->triply_indirect[i];                       
4000e2ac:	a0 10 20 00 	clr  %l0                                       
      if ( !p )  /* ensure we have a valid pointer */                 
4000e2b0:	b2 10 20 00 	clr  %i1                                       
4000e2b4:	b6 16 e2 a0 	or  %i3, 0x2a0, %i3                            
         break;                                                       
      for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {                
4000e2b8:	80 a0 a0 00 	cmp  %g2, 0                                    
4000e2bc:	22 80 00 13 	be,a   4000e308 <IMFS_memfile_remove+0x12c>    <== NEVER TAKEN
4000e2c0:	90 02 00 10 	add  %o0, %l0, %o0                             <== NOT EXECUTED
4000e2c4:	90 10 20 00 	clr  %o0                                       
4000e2c8:	ba 10 20 00 	clr  %i5                                       
        if ( p[j] ) {                                                 
4000e2cc:	91 2a 20 02 	sll  %o0, 2, %o0                               
4000e2d0:	c2 07 00 08 	ld  [ %i4 + %o0 ], %g1                         
4000e2d4:	80 a0 60 00 	cmp  %g1, 0                                    
4000e2d8:	02 80 00 04 	be  4000e2e8 <IMFS_memfile_remove+0x10c>       <== NEVER TAKEN
4000e2dc:	90 07 00 08 	add  %i4, %o0, %o0                             
          memfile_free_blocks_in_table( (block_p **)&p[j], to_free);  
4000e2e0:	7f ff ff a9 	call  4000e184 <memfile_free_blocks_in_table>  
4000e2e4:	92 10 00 1a 	mov  %i2, %o1                                  
  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++ ) {                
4000e2e8:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
4000e2ec:	ba 07 60 01 	inc  %i5                                       
4000e2f0:	83 30 60 02 	srl  %g1, 2, %g1                               
4000e2f4:	80 a7 40 01 	cmp  %i5, %g1                                  
4000e2f8:	0a bf ff f5 	bcs  4000e2cc <IMFS_memfile_remove+0xf0>       
4000e2fc:	90 10 00 1d 	mov  %i5, %o0                                  
4000e300:	d0 06 20 60 	ld  [ %i0 + 0x60 ], %o0                        
        if ( p[j] ) {                                                 
          memfile_free_blocks_in_table( (block_p **)&p[j], to_free);  
        }                                                             
      }                                                               
      memfile_free_blocks_in_table(                                   
4000e304:	90 02 00 10 	add  %o0, %l0, %o0                             
4000e308:	7f ff ff 9f 	call  4000e184 <memfile_free_blocks_in_table>  
4000e30c:	92 10 00 1a 	mov  %i2, %o1                                  
    memfile_free_blocks_in_table( &info->doubly_indirect, to_free );  
                                                                      
  }                                                                   
                                                                      
  if ( info->triply_indirect ) {                                      
    for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {                  
4000e310:	c4 06 c0 00 	ld  [ %i3 ], %g2                               
4000e314:	b2 06 60 01 	inc  %i1                                       
4000e318:	85 30 a0 02 	srl  %g2, 2, %g2                               
4000e31c:	80 a6 40 02 	cmp  %i1, %g2                                  
4000e320:	1a 80 00 09 	bcc  4000e344 <IMFS_memfile_remove+0x168>      
4000e324:	90 06 20 60 	add  %i0, 0x60, %o0                            
      p = (block_p *) info->triply_indirect[i];                       
4000e328:	d0 06 20 60 	ld  [ %i0 + 0x60 ], %o0                        
 *         a significant difference in the performance of this routine.
 *                                                                    
 *         Regardless until the IMFS implementation is proven, it     
 *         is better to stick to simple, easy to understand algorithms.
 */                                                                   
IMFS_jnode_t *IMFS_memfile_remove(                                    
4000e32c:	a1 2e 60 02 	sll  %i1, 2, %l0                               
                                                                      
  }                                                                   
                                                                      
  if ( info->triply_indirect ) {                                      
    for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {                  
      p = (block_p *) info->triply_indirect[i];                       
4000e330:	f8 02 00 10 	ld  [ %o0 + %l0 ], %i4                         
      if ( !p )  /* ensure we have a valid pointer */                 
4000e334:	80 a7 20 00 	cmp  %i4, 0                                    
4000e338:	12 bf ff e1 	bne  4000e2bc <IMFS_memfile_remove+0xe0>       <== ALWAYS TAKEN
4000e33c:	80 a0 a0 00 	cmp  %g2, 0                                    
        }                                                             
      }                                                               
      memfile_free_blocks_in_table(                                   
        (block_p **)&info->triply_indirect[i], to_free );             
    }                                                                 
    memfile_free_blocks_in_table(                                     
4000e340:	90 06 20 60 	add  %i0, 0x60, %o0                            <== NOT EXECUTED
4000e344:	7f ff ff 90 	call  4000e184 <memfile_free_blocks_in_table>  
4000e348:	92 10 00 1a 	mov  %i2, %o1                                  
        (block_p **)&info->triply_indirect, to_free );                
  }                                                                   
                                                                      
  return the_jnode;                                                   
}                                                                     
4000e34c:	81 c7 e0 08 	ret                                            
4000e350:	81 e8 00 00 	restore                                        
                                                                      

4000e354 <IMFS_memfile_remove_block>: */ MEMFILE_STATIC int IMFS_memfile_remove_block( IMFS_jnode_t *the_jnode, unsigned int block ) {
4000e354:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
  block_p *block_ptr;                                                 
  block_p  ptr;                                                       
                                                                      
  block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );  
4000e358:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
4000e35c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4000e360:	7f ff fe 38 	call  4000dc40 <IMFS_memfile_get_block_pointer><== NOT EXECUTED
4000e364:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
4000e368:	82 10 00 08 	mov  %o0, %g1                                  <== NOT EXECUTED
  IMFS_assert( block_ptr );                                           
                                                                      
  ptr = *block_ptr;                                                   
4000e36c:	d0 02 00 00 	ld  [ %o0 ], %o0                               <== NOT EXECUTED
  *block_ptr = 0;                                                     
  memfile_free_block( ptr );                                          
                                                                      
  return 1;                                                           
}                                                                     
4000e370:	b0 10 20 01 	mov  1, %i0                                    <== NOT EXECUTED
  block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );  
  IMFS_assert( block_ptr );                                           
                                                                      
  ptr = *block_ptr;                                                   
  *block_ptr = 0;                                                     
  memfile_free_block( ptr );                                          
4000e374:	7f ff ff 7b 	call  4000e160 <memfile_free_block>            <== NOT EXECUTED
4000e378:	c0 20 40 00 	clr  [ %g1 ]                                   <== NOT EXECUTED
                                                                      
  return 1;                                                           
}                                                                     
4000e37c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000e380:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4000e548 <IMFS_memfile_write>: IMFS_jnode_t *the_jnode, off_t start, const unsigned char *source, unsigned int length ) {
4000e548:	9d e3 bf 98 	save  %sp, -104, %sp                           
   *  If the last byte we are supposed to write is past the end of this
   *  in memory file, then extend the length.                         
   */                                                                 
                                                                      
  last_byte = start + my_length;                                      
  if ( last_byte > the_jnode->info.file.size ) {                      
4000e54c:	c2 06 20 50 	ld  [ %i0 + 0x50 ], %g1                        
4000e550:	84 10 20 00 	clr  %g2                                       
  /*                                                                  
   *  If the last byte we are supposed to write is past the end of this
   *  in memory file, then extend the length.                         
   */                                                                 
                                                                      
  last_byte = start + my_length;                                      
4000e554:	96 07 00 1a 	add  %i4, %i2, %o3                             
  if ( last_byte > the_jnode->info.file.size ) {                      
4000e558:	80 a0 80 01 	cmp  %g2, %g1                                  
4000e55c:	14 80 00 5e 	bg  4000e6d4 <IMFS_memfile_write+0x18c>        <== NEVER TAKEN
4000e560:	c6 06 20 54 	ld  [ %i0 + 0x54 ], %g3                        
4000e564:	80 a0 80 01 	cmp  %g2, %g1                                  
4000e568:	02 80 00 59 	be  4000e6cc <IMFS_memfile_write+0x184>        <== ALWAYS TAKEN
4000e56c:	80 a2 c0 03 	cmp  %o3, %g3                                  
   */                                                                 
                                                                      
  /*                                                                  
   *  Phase 1: possibly the last part of one block                    
   */                                                                 
  start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;                
4000e570:	21 10 00 7a 	sethi  %hi(0x4001e800), %l0                    <== NOT EXECUTED
4000e574:	fa 04 22 a0 	ld  [ %l0 + 0x2a0 ], %i5	! 4001eaa0 <imfs_memfile_bytes_per_block>
4000e578:	90 10 00 19 	mov  %i1, %o0                                  
4000e57c:	a3 3f 60 1f 	sra  %i5, 0x1f, %l1                            
4000e580:	92 10 00 1a 	mov  %i2, %o1                                  
4000e584:	94 10 00 11 	mov  %l1, %o2                                  
4000e588:	40 00 2a fe 	call  40019180 <__moddi3>                      
4000e58c:	96 10 00 1d 	mov  %i5, %o3                                  
  block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;                       
4000e590:	90 10 00 19 	mov  %i1, %o0                                  
   */                                                                 
                                                                      
  /*                                                                  
   *  Phase 1: possibly the last part of one block                    
   */                                                                 
  start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;                
4000e594:	a4 10 00 09 	mov  %o1, %l2                                  
  block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;                       
4000e598:	94 10 00 11 	mov  %l1, %o2                                  
4000e59c:	92 10 00 1a 	mov  %i2, %o1                                  
4000e5a0:	40 00 2a 0d 	call  40018dd4 <__divdi3>                      
4000e5a4:	96 10 00 1d 	mov  %i5, %o3                                  
    status = IMFS_memfile_extend( the_jnode, zero_fill, last_byte );  
    if ( status )                                                     
      return status;                                                  
  }                                                                   
                                                                      
  copied = 0;                                                         
4000e5a8:	b2 10 20 00 	clr  %i1                                       
  /*                                                                  
   *  Phase 1: possibly the last part of one block                    
   */                                                                 
  start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;                
  block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;                       
  if ( start_offset )  {                                              
4000e5ac:	80 a4 a0 00 	cmp  %l2, 0                                    
4000e5b0:	02 80 00 16 	be  4000e608 <IMFS_memfile_write+0xc0>         
4000e5b4:	b4 10 00 09 	mov  %o1, %i2                                  
    to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;            
4000e5b8:	b2 27 40 12 	sub  %i5, %l2, %i1                             
4000e5bc:	80 a6 40 1c 	cmp  %i1, %i4                                  
4000e5c0:	38 80 00 02 	bgu,a   4000e5c8 <IMFS_memfile_write+0x80>     
4000e5c4:	b2 10 00 1c 	mov  %i4, %i1                                  
    if ( to_copy > my_length )                                        
      to_copy = my_length;                                            
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4000e5c8:	90 10 00 18 	mov  %i0, %o0                                  
4000e5cc:	92 10 00 1a 	mov  %i2, %o1                                  
4000e5d0:	7f ff fd 9c 	call  4000dc40 <IMFS_memfile_get_block_pointer>
4000e5d4:	94 10 20 00 	clr  %o2                                       
    if ( !block_ptr )                                                 
4000e5d8:	80 a2 20 00 	cmp  %o0, 0                                    
4000e5dc:	02 80 00 22 	be  4000e664 <IMFS_memfile_write+0x11c>        <== NEVER TAKEN
4000e5e0:	82 10 20 00 	clr  %g1                                       
        block,                                                        
        to_copy,                                                      
        src                                                           
      );                                                              
    #endif                                                            
    memcpy( &(*block_ptr)[ start_offset ], src, to_copy );            
4000e5e4:	d0 02 00 00 	ld  [ %o0 ], %o0                               
4000e5e8:	92 10 00 1b 	mov  %i3, %o1                                  
4000e5ec:	90 02 00 12 	add  %o0, %l2, %o0                             
4000e5f0:	40 00 06 a5 	call  40010084 <memcpy>                        
4000e5f4:	94 10 00 19 	mov  %i1, %o2                                  
4000e5f8:	fa 04 22 a0 	ld  [ %l0 + 0x2a0 ], %i5                       
    src += to_copy;                                                   
4000e5fc:	b6 06 c0 19 	add  %i3, %i1, %i3                             
    block++;                                                          
4000e600:	b4 06 a0 01 	inc  %i2                                       
    my_length -= to_copy;                                             
4000e604:	b8 27 00 19 	sub  %i4, %i1, %i4                             
  /*                                                                  
   *  Phase 2: all of zero of more blocks                             
   */                                                                 
                                                                      
  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;                             
  while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {               
4000e608:	80 a7 00 1d 	cmp  %i4, %i5                                  
4000e60c:	1a 80 00 0e 	bcc  4000e644 <IMFS_memfile_write+0xfc>        
4000e610:	92 10 00 1a 	mov  %i2, %o1                                  
   *  Phase 3: possibly the first part of one block                   
   */                                                                 
  IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );            
                                                                      
  to_copy = my_length;                                                
  if ( my_length ) {                                                  
4000e614:	10 80 00 17 	b  4000e670 <IMFS_memfile_write+0x128>         
4000e618:	80 a7 20 00 	cmp  %i4, 0                                    
    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 );                       
4000e61c:	d0 02 00 00 	ld  [ %o0 ], %o0                               
4000e620:	40 00 06 99 	call  40010084 <memcpy>                        
4000e624:	b8 27 00 1d 	sub  %i4, %i5, %i4                             
  /*                                                                  
   *  Phase 2: all of zero of more blocks                             
   */                                                                 
                                                                      
  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;                             
  while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {               
4000e628:	c2 04 22 a0 	ld  [ %l0 + 0x2a0 ], %g1                       
      return copied;                                                  
    #if 0                                                             
      fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
    #endif                                                            
    memcpy( &(*block_ptr)[ 0 ], src, to_copy );                       
    src += to_copy;                                                   
4000e62c:	b6 06 c0 1d 	add  %i3, %i5, %i3                             
    block++;                                                          
4000e630:	b4 06 a0 01 	inc  %i2                                       
  /*                                                                  
   *  Phase 2: all of zero of more blocks                             
   */                                                                 
                                                                      
  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;                             
  while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {               
4000e634:	80 a0 40 1c 	cmp  %g1, %i4                                  
4000e638:	18 80 00 0d 	bgu  4000e66c <IMFS_memfile_write+0x124>       
4000e63c:	b2 06 40 1d 	add  %i1, %i5, %i1                             
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4000e640:	92 10 00 1a 	mov  %i2, %o1                                  
4000e644:	94 10 20 00 	clr  %o2                                       
4000e648:	7f ff fd 7e 	call  4000dc40 <IMFS_memfile_get_block_pointer>
4000e64c:	90 10 00 18 	mov  %i0, %o0                                  
    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 );                       
4000e650:	92 10 00 1b 	mov  %i3, %o1                                  
   */                                                                 
                                                                      
  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;                             
  while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {               
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
    if ( !block_ptr )                                                 
4000e654:	80 a2 20 00 	cmp  %o0, 0                                    
4000e658:	12 bf ff f1 	bne  4000e61c <IMFS_memfile_write+0xd4>        <== ALWAYS TAKEN
4000e65c:	94 10 00 1d 	mov  %i5, %o2                                  
4000e660:	82 10 00 19 	mov  %i1, %g1                                  <== NOT EXECUTED
  }                                                                   
                                                                      
  IMFS_mtime_ctime_update( the_jnode );                               
                                                                      
  return copied;                                                      
}                                                                     
4000e664:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000e668:	91 e8 00 01 	restore  %g0, %g1, %o0                         <== NOT EXECUTED
   *  Phase 3: possibly the first part of one block                   
   */                                                                 
  IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );            
                                                                      
  to_copy = my_length;                                                
  if ( my_length ) {                                                  
4000e66c:	80 a7 20 00 	cmp  %i4, 0                                    
4000e670:	02 80 00 0f 	be  4000e6ac <IMFS_memfile_write+0x164>        
4000e674:	90 07 bf f8 	add  %fp, -8, %o0                              
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4000e678:	90 10 00 18 	mov  %i0, %o0                                  
4000e67c:	92 10 00 1a 	mov  %i2, %o1                                  
4000e680:	7f ff fd 70 	call  4000dc40 <IMFS_memfile_get_block_pointer>
4000e684:	94 10 20 00 	clr  %o2                                       
    if ( !block_ptr )                                                 
4000e688:	80 a2 20 00 	cmp  %o0, 0                                    
4000e68c:	02 bf ff f6 	be  4000e664 <IMFS_memfile_write+0x11c>        <== NEVER TAKEN
4000e690:	82 10 00 19 	mov  %i1, %g1                                  
      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 );                     
4000e694:	d0 02 00 00 	ld  [ %o0 ], %o0                               
4000e698:	92 10 00 1b 	mov  %i3, %o1                                  
4000e69c:	94 10 00 1c 	mov  %i4, %o2                                  
4000e6a0:	40 00 06 79 	call  40010084 <memcpy>                        
4000e6a4:	b2 06 40 1c 	add  %i1, %i4, %i1                             
    my_length = 0;                                                    
    copied += to_copy;                                                
  }                                                                   
                                                                      
  IMFS_mtime_ctime_update( the_jnode );                               
4000e6a8:	90 07 bf f8 	add  %fp, -8, %o0                              
4000e6ac:	7f ff d2 89 	call  400030d0 <gettimeofday>                  
4000e6b0:	92 10 20 00 	clr  %o1                                       
4000e6b4:	c4 07 bf f8 	ld  [ %fp + -8 ], %g2                          
                                                                      
  return copied;                                                      
4000e6b8:	82 10 00 19 	mov  %i1, %g1                                  
    memcpy( &(*block_ptr)[ 0 ], src, my_length );                     
    my_length = 0;                                                    
    copied += to_copy;                                                
  }                                                                   
                                                                      
  IMFS_mtime_ctime_update( the_jnode );                               
4000e6bc:	c4 26 20 44 	st  %g2, [ %i0 + 0x44 ]                        
4000e6c0:	c4 26 20 48 	st  %g2, [ %i0 + 0x48 ]                        
                                                                      
  return copied;                                                      
}                                                                     
4000e6c4:	81 c7 e0 08 	ret                                            
4000e6c8:	91 e8 00 01 	restore  %g0, %g1, %o0                         
   *  If the last byte we are supposed to write is past the end of this
   *  in memory file, then extend the length.                         
   */                                                                 
                                                                      
  last_byte = start + my_length;                                      
  if ( last_byte > the_jnode->info.file.size ) {                      
4000e6cc:	08 bf ff aa 	bleu  4000e574 <IMFS_memfile_write+0x2c>       
4000e6d0:	21 10 00 7a 	sethi  %hi(0x4001e800), %l0                    
    bool zero_fill = start > the_jnode->info.file.size;               
4000e6d4:	80 a6 40 01 	cmp  %i1, %g1                                  
4000e6d8:	04 80 00 0b 	ble  4000e704 <IMFS_memfile_write+0x1bc>       <== ALWAYS TAKEN
4000e6dc:	92 10 20 01 	mov  1, %o1                                    
                                                                      
    status = IMFS_memfile_extend( the_jnode, zero_fill, last_byte );  
4000e6e0:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4000e6e4:	92 0a 60 01 	and  %o1, 1, %o1                               
4000e6e8:	7f ff ff 27 	call  4000e384 <IMFS_memfile_extend>           
4000e6ec:	94 10 20 00 	clr  %o2                                       
    if ( status )                                                     
4000e6f0:	82 92 20 00 	orcc  %o0, 0, %g1                              
4000e6f4:	02 bf ff a0 	be  4000e574 <IMFS_memfile_write+0x2c>         
4000e6f8:	21 10 00 7a 	sethi  %hi(0x4001e800), %l0                    
  }                                                                   
                                                                      
  IMFS_mtime_ctime_update( the_jnode );                               
                                                                      
  return copied;                                                      
}                                                                     
4000e6fc:	81 c7 e0 08 	ret                                            
4000e700:	91 e8 00 01 	restore  %g0, %g1, %o0                         
   *  in memory file, then extend the length.                         
   */                                                                 
                                                                      
  last_byte = start + my_length;                                      
  if ( last_byte > the_jnode->info.file.size ) {                      
    bool zero_fill = start > the_jnode->info.file.size;               
4000e704:	02 80 00 0b 	be  4000e730 <IMFS_memfile_write+0x1e8>        <== ALWAYS TAKEN
4000e708:	80 a6 80 03 	cmp  %i2, %g3                                  
4000e70c:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
                                                                      
    status = IMFS_memfile_extend( the_jnode, zero_fill, last_byte );  
4000e710:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4000e714:	92 0a 60 01 	and  %o1, 1, %o1                               
4000e718:	7f ff ff 1b 	call  4000e384 <IMFS_memfile_extend>           
4000e71c:	94 10 20 00 	clr  %o2                                       
    if ( status )                                                     
4000e720:	82 92 20 00 	orcc  %o0, 0, %g1                              
4000e724:	02 bf ff 94 	be  4000e574 <IMFS_memfile_write+0x2c>         
4000e728:	21 10 00 7a 	sethi  %hi(0x4001e800), %l0                    
4000e72c:	30 bf ff f4 	b,a   4000e6fc <IMFS_memfile_write+0x1b4>      
   *  in memory file, then extend the length.                         
   */                                                                 
                                                                      
  last_byte = start + my_length;                                      
  if ( last_byte > the_jnode->info.file.size ) {                      
    bool zero_fill = start > the_jnode->info.file.size;               
4000e730:	18 bf ff ed 	bgu  4000e6e4 <IMFS_memfile_write+0x19c>       
4000e734:	90 10 00 18 	mov  %i0, %o0                                  
4000e738:	10 bf ff f7 	b  4000e714 <IMFS_memfile_write+0x1cc>         
4000e73c:	92 10 20 00 	clr  %o1                                       
                                                                      

40002804 <IMFS_mknod>: const char *name, size_t namelen, mode_t mode, dev_t dev ) {
40002804:	9d e3 bf 80 	save  %sp, -128, %sp                           
  dev_t dev,                                                          
  IMFS_jnode_types_t *type,                                           
  IMFS_types_union *info                                              
)                                                                     
{                                                                     
  if ( S_ISDIR( mode ) ) {                                            
40002808:	03 00 00 3c 	sethi  %hi(0xf000), %g1                        
4000280c:	05 00 00 10 	sethi  %hi(0x4000), %g2                        
40002810:	82 0e c0 01 	and  %i3, %g1, %g1                             
40002814:	80 a0 40 02 	cmp  %g1, %g2                                  
40002818:	02 80 00 2b 	be  400028c4 <IMFS_mknod+0xc0>                 
4000281c:	05 00 00 20 	sethi  %hi(0x8000), %g2                        
    *type = IMFS_DIRECTORY;                                           
  } else if ( S_ISREG( mode ) ) {                                     
40002820:	80 a0 40 02 	cmp  %g1, %g2                                  
40002824:	02 80 00 2a 	be  400028cc <IMFS_mknod+0xc8>                 
40002828:	09 00 00 2c 	sethi  %hi(0xb000), %g4                        
    *type = IMFS_MEMORY_FILE;                                         
  } else if ( S_ISBLK( mode ) || S_ISCHR( mode ) ) {                  
4000282c:	05 00 00 08 	sethi  %hi(0x2000), %g2                        
40002830:	88 0e c0 04 	and  %i3, %g4, %g4                             
40002834:	80 a1 00 02 	cmp  %g4, %g2                                  
40002838:	02 80 00 07 	be  40002854 <IMFS_mknod+0x50>                 
4000283c:	05 00 00 04 	sethi  %hi(0x1000), %g2                        
    rtems_filesystem_split_dev_t(                                     
      dev,                                                            
      info->device.major,                                             
      info->device.minor                                              
    );                                                                
  } else if (S_ISFIFO( mode )) {                                      
40002840:	80 a0 40 02 	cmp  %g1, %g2                                  
40002844:	22 80 00 06 	be,a   4000285c <IMFS_mknod+0x58>              <== ALWAYS TAKEN
40002848:	86 10 20 06 	mov  6, %g3                                    
  size_t namelen,                                                     
  mode_t mode,                                                        
  const IMFS_types_union *info                                        
)                                                                     
{                                                                     
  const IMFS_fs_info_t *fs_info =                                     
4000284c:	10 80 00 05 	b  40002860 <IMFS_mknod+0x5c>                  <== NOT EXECUTED
40002850:	c4 06 20 14 	ld  [ %i0 + 0x14 ], %g2                        <== NOT EXECUTED
    *type = IMFS_DIRECTORY;                                           
  } else if ( S_ISREG( mode ) ) {                                     
    *type = IMFS_MEMORY_FILE;                                         
  } else if ( S_ISBLK( mode ) || S_ISCHR( mode ) ) {                  
    *type = IMFS_DEVICE;                                              
    rtems_filesystem_split_dev_t(                                     
40002854:	f8 3f bf e8 	std  %i4, [ %fp + -24 ]                        
  if ( S_ISDIR( mode ) ) {                                            
    *type = IMFS_DIRECTORY;                                           
  } else if ( S_ISREG( mode ) ) {                                     
    *type = IMFS_MEMORY_FILE;                                         
  } else if ( S_ISBLK( mode ) || S_ISCHR( mode ) ) {                  
    *type = IMFS_DEVICE;                                              
40002858:	86 10 20 01 	mov  1, %g3                                    
4000285c:	c4 06 20 14 	ld  [ %i0 + 0x14 ], %g2                        
    (const IMFS_fs_info_t *) parentloc->mt_entry->fs_info;            
                                                                      
  return IMFS_create_node_with_control(                               
40002860:	82 00 e0 02 	add  %g3, 2, %g1                               
40002864:	c4 00 a0 08 	ld  [ %g2 + 8 ], %g2                           
40002868:	83 28 60 02 	sll  %g1, 2, %g1                               
4000286c:	d2 00 80 01 	ld  [ %g2 + %g1 ], %o1                         
40002870:	90 10 00 18 	mov  %i0, %o0                                  
40002874:	94 10 00 19 	mov  %i1, %o2                                  
40002878:	96 10 00 1a 	mov  %i2, %o3                                  
4000287c:	98 10 00 1b 	mov  %i3, %o4                                  
40002880:	40 00 23 4f 	call  4000b5bc <IMFS_create_node_with_control> 
40002884:	9a 07 bf e8 	add  %fp, -24, %o5                             
  IMFS_jnode_t *new_node;                                             
                                                                      
  get_type_and_info_by_mode_and_dev( mode, dev, &type, &info );       
                                                                      
  new_node = IMFS_create_node( parentloc, type, name, namelen, mode, &info );
  if ( new_node != NULL ) {                                           
40002888:	80 a2 20 00 	cmp  %o0, 0                                    
4000288c:	02 80 00 12 	be  400028d4 <IMFS_mknod+0xd0>                 
40002890:	92 10 20 00 	clr  %o1                                       
    IMFS_jnode_t *parent = parentloc->node_access;                    
40002894:	fa 06 20 08 	ld  [ %i0 + 8 ], %i5                           
                                                                      
    IMFS_update_ctime( parent );                                      
40002898:	40 00 02 0e 	call  400030d0 <gettimeofday>                  
4000289c:	90 07 bf e0 	add  %fp, -32, %o0                             
400028a0:	c2 07 bf e0 	ld  [ %fp + -32 ], %g1                         
    IMFS_update_mtime( parent );                                      
400028a4:	90 07 bf e0 	add  %fp, -32, %o0                             
                                                                      
  new_node = IMFS_create_node( parentloc, type, name, namelen, mode, &info );
  if ( new_node != NULL ) {                                           
    IMFS_jnode_t *parent = parentloc->node_access;                    
                                                                      
    IMFS_update_ctime( parent );                                      
400028a8:	c2 27 60 48 	st  %g1, [ %i5 + 0x48 ]                        
    IMFS_update_mtime( parent );                                      
400028ac:	40 00 02 09 	call  400030d0 <gettimeofday>                  
400028b0:	92 10 20 00 	clr  %o1                                       
400028b4:	c2 07 bf e0 	ld  [ %fp + -32 ], %g1                         
400028b8:	c2 27 60 44 	st  %g1, [ %i5 + 0x44 ]                        
  size_t namelen,                                                     
  mode_t mode,                                                        
  dev_t dev                                                           
)                                                                     
{                                                                     
  int rv = 0;                                                         
400028bc:	81 c7 e0 08 	ret                                            
400028c0:	91 e8 20 00 	restore  %g0, 0, %o0                           
  IMFS_jnode_types_t *type,                                           
  IMFS_types_union *info                                              
)                                                                     
{                                                                     
  if ( S_ISDIR( mode ) ) {                                            
    *type = IMFS_DIRECTORY;                                           
400028c4:	10 bf ff e6 	b  4000285c <IMFS_mknod+0x58>                  
400028c8:	86 10 20 00 	clr  %g3                                       
  } else if ( S_ISREG( mode ) ) {                                     
    *type = IMFS_MEMORY_FILE;                                         
400028cc:	10 bf ff e4 	b  4000285c <IMFS_mknod+0x58>                  
400028d0:	86 10 20 04 	mov  4, %g3                                    
  } else {                                                            
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
400028d4:	81 c7 e0 08 	ret                                            
400028d8:	91 e8 3f ff 	restore  %g0, -1, %o0                          
                                                                      

400028dc <IMFS_mount>: #endif #include "imfs.h" int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry ) {
400028dc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rv = 0;                                                         
  IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access; 
400028e0:	c2 06 20 20 	ld  [ %i0 + 0x20 ], %g1                        
400028e4:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
  return node->control->imfs_type;                                    
}                                                                     
                                                                      
static inline bool IMFS_is_directory( const IMFS_jnode_t *node )      
{                                                                     
  return node->control->imfs_type == IMFS_DIRECTORY;                  
400028e8:	c4 00 60 4c 	ld  [ %g1 + 0x4c ], %g2                        
                                                                      
  if ( IMFS_is_directory( node ) ) {                                  
400028ec:	c4 00 80 00 	ld  [ %g2 ], %g2                               
400028f0:	80 a0 a0 00 	cmp  %g2, 0                                    
400028f4:	12 80 00 0f 	bne  40002930 <IMFS_mount+0x54>                
400028f8:	01 00 00 00 	nop                                            
    if ( node->info.directory.mt_fs == NULL ) {                       
400028fc:	c4 00 60 5c 	ld  [ %g1 + 0x5c ], %g2                        
40002900:	80 a0 a0 00 	cmp  %g2, 0                                    
40002904:	12 80 00 05 	bne  40002918 <IMFS_mount+0x3c>                <== NEVER TAKEN
40002908:	01 00 00 00 	nop                                            
      node->info.directory.mt_fs = mt_entry;                          
4000290c:	f0 20 60 5c 	st  %i0, [ %g1 + 0x5c ]                        
                                                                      
#include "imfs.h"                                                     
                                                                      
int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry )      
{                                                                     
  int rv = 0;                                                         
40002910:	81 c7 e0 08 	ret                                            
40002914:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      
  if ( IMFS_is_directory( node ) ) {                                  
    if ( node->info.directory.mt_fs == NULL ) {                       
      node->info.directory.mt_fs = mt_entry;                          
    } else {                                                          
      errno = EBUSY;                                                  
40002918:	40 00 33 8a 	call  4000f740 <__errno>                       <== NOT EXECUTED
4000291c:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40002920:	82 10 20 10 	mov  0x10, %g1                                 <== NOT EXECUTED
40002924:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
40002928:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000292c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
      rv = -1;                                                        
    }                                                                 
  } else {                                                            
    errno = ENOTDIR;                                                  
40002930:	40 00 33 84 	call  4000f740 <__errno>                       
40002934:	b0 10 3f ff 	mov  -1, %i0                                   
40002938:	82 10 20 14 	mov  0x14, %g1                                 
4000293c:	c2 22 00 00 	st  %g1, [ %o0 ]                               
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
40002940:	81 c7 e0 08 	ret                                            
40002944:	81 e8 00 00 	restore                                        
                                                                      

4000ba4c <IMFS_node_remove_directory>: } static IMFS_jnode_t *IMFS_node_remove_directory( IMFS_jnode_t *node ) {
4000ba4c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if ( !rtems_chain_is_empty( &node->info.directory.Entries ) ) {     
4000ba50:	c4 06 20 50 	ld  [ %i0 + 0x50 ], %g2                        
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
4000ba54:	82 06 20 54 	add  %i0, 0x54, %g1                            
4000ba58:	80 a0 80 01 	cmp  %g2, %g1                                  
4000ba5c:	12 80 00 08 	bne  4000ba7c <IMFS_node_remove_directory+0x30>
4000ba60:	01 00 00 00 	nop                                            
    errno = ENOTEMPTY;                                                
    node = NULL;                                                      
  } else if ( IMFS_is_mount_point( node ) ) {                         
4000ba64:	c2 06 20 5c 	ld  [ %i0 + 0x5c ], %g1                        
4000ba68:	80 a0 60 00 	cmp  %g1, 0                                    
4000ba6c:	12 80 00 0a 	bne  4000ba94 <IMFS_node_remove_directory+0x48><== NEVER TAKEN
4000ba70:	01 00 00 00 	nop                                            
    errno = EBUSY;                                                    
    node = NULL;                                                      
  }                                                                   
                                                                      
  return node;                                                        
}                                                                     
4000ba74:	81 c7 e0 08 	ret                                            
4000ba78:	81 e8 00 00 	restore                                        
static IMFS_jnode_t *IMFS_node_remove_directory(                      
  IMFS_jnode_t *node                                                  
)                                                                     
{                                                                     
  if ( !rtems_chain_is_empty( &node->info.directory.Entries ) ) {     
    errno = ENOTEMPTY;                                                
4000ba7c:	40 00 0f 31 	call  4000f740 <__errno>                       
4000ba80:	b0 10 20 00 	clr  %i0                                       
4000ba84:	82 10 20 5a 	mov  0x5a, %g1                                 
4000ba88:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4000ba8c:	81 c7 e0 08 	ret                                            
4000ba90:	81 e8 00 00 	restore                                        
    node = NULL;                                                      
  } else if ( IMFS_is_mount_point( node ) ) {                         
    errno = EBUSY;                                                    
4000ba94:	40 00 0f 2b 	call  4000f740 <__errno>                       <== NOT EXECUTED
4000ba98:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
4000ba9c:	82 10 20 10 	mov  0x10, %g1                                 <== NOT EXECUTED
4000baa0:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
    node = NULL;                                                      
  }                                                                   
                                                                      
  return node;                                                        
}                                                                     
4000baa4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000baa8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40002948 <IMFS_node_type>: rtems_filesystem_node_types_t IMFS_node_type( const rtems_filesystem_location_info_t *loc ) { const IMFS_jnode_t *node = loc->node_access;
40002948:	c4 02 20 08 	ld  [ %o0 + 8 ], %g2                           
  rtems_chain_extract_unprotected( &node->Node );                     
}                                                                     
                                                                      
static inline IMFS_jnode_types_t IMFS_type( const IMFS_jnode_t *node )
{                                                                     
  return node->control->imfs_type;                                    
4000294c:	c2 00 a0 4c 	ld  [ %g2 + 0x4c ], %g1                        
40002950:	c2 00 40 00 	ld  [ %g1 ], %g1                               
  IMFS_jnode_types_t imfs_type = IMFS_type( node );                   
  rtems_filesystem_node_types_t type;                                 
                                                                      
  switch ( imfs_type ) {                                              
40002954:	80 a0 60 02 	cmp  %g1, 2                                    
40002958:	02 80 00 06 	be  40002970 <IMFS_node_type+0x28>             
4000295c:	80 a0 60 05 	cmp  %g1, 5                                    
40002960:	02 80 00 08 	be  40002980 <IMFS_node_type+0x38>             <== NEVER TAKEN
40002964:	90 10 20 04 	mov  4, %o0                                    
      type = imfs_type;                                               
      break;                                                          
  }                                                                   
                                                                      
  return type;                                                        
}                                                                     
40002968:	81 c3 e0 08 	retl                                           
4000296c:	90 10 00 01 	mov  %g1, %o0                                  
40002970:	c2 00 a0 50 	ld  [ %g2 + 0x50 ], %g1                        
40002974:	c2 00 60 4c 	ld  [ %g1 + 0x4c ], %g1                        
  rtems_filesystem_node_types_t type;                                 
                                                                      
  switch ( imfs_type ) {                                              
    case IMFS_HARD_LINK:                                              
      type = IMFS_type( node->info.hard_link.link_node );             
      break;                                                          
40002978:	81 c3 e0 08 	retl                                           
4000297c:	d0 00 40 00 	ld  [ %g1 ], %o0                               
40002980:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
                                                                      

40002988 <IMFS_readlink>: node = loc->node_access; IMFS_assert( node->control->imfs_type == IMFS_SYM_LINK ); for( i=0; ((i<bufsize) && (node->info.sym_link.name[i] != '\0')); i++ )
40002988:	80 a2 a0 00 	cmp  %o2, 0                                    
4000298c:	02 80 00 16 	be  400029e4 <IMFS_readlink+0x5c>              <== NEVER TAKEN
40002990:	c8 02 20 08 	ld  [ %o0 + 8 ], %g4                           
40002994:	c2 01 20 50 	ld  [ %g4 + 0x50 ], %g1                        
40002998:	c4 48 40 00 	ldsb  [ %g1 ], %g2                             
4000299c:	80 a0 a0 00 	cmp  %g2, 0                                    
400029a0:	02 80 00 11 	be  400029e4 <IMFS_readlink+0x5c>              <== NEVER TAKEN
400029a4:	c2 08 40 00 	ldub  [ %g1 ], %g1                             
400029a8:	84 10 20 00 	clr  %g2                                       
400029ac:	10 80 00 07 	b  400029c8 <IMFS_readlink+0x40>               
400029b0:	90 10 20 00 	clr  %o0                                       
400029b4:	c2 01 20 50 	ld  [ %g4 + 0x50 ], %g1                        
400029b8:	c6 48 40 08 	ldsb  [ %g1 + %o0 ], %g3                       
400029bc:	80 a0 e0 00 	cmp  %g3, 0                                    
400029c0:	02 80 00 07 	be  400029dc <IMFS_readlink+0x54>              
400029c4:	c2 08 40 08 	ldub  [ %g1 + %o0 ], %g1                       
    buf[i] = node->info.sym_link.name[i];                             
400029c8:	c2 2a 40 02 	stb  %g1, [ %o1 + %g2 ]                        
                                                                      
  node = loc->node_access;                                            
                                                                      
  IMFS_assert( node->control->imfs_type == IMFS_SYM_LINK );           
                                                                      
  for( i=0; ((i<bufsize) && (node->info.sym_link.name[i] != '\0')); i++ )
400029cc:	90 02 20 01 	inc  %o0                                       
400029d0:	80 a2 00 0a 	cmp  %o0, %o2                                  
400029d4:	12 bf ff f8 	bne  400029b4 <IMFS_readlink+0x2c>             
400029d8:	84 10 00 08 	mov  %o0, %g2                                  
    buf[i] = node->info.sym_link.name[i];                             
                                                                      
  return i;                                                           
}                                                                     
400029dc:	81 c3 e0 08 	retl                                           
400029e0:	01 00 00 00 	nop                                            
400029e4:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
400029e8:	90 10 20 00 	clr  %o0	! 0 <PROM_START>                      <== NOT EXECUTED
                                                                      

400029ec <IMFS_rename>: const rtems_filesystem_location_info_t *oldloc, const rtems_filesystem_location_info_t *newparentloc, const char *name, size_t namelen ) {
400029ec:	9d e3 bf 98 	save  %sp, -104, %sp                           
  int rv = 0;                                                         
  IMFS_jnode_t *node = oldloc->node_access;                           
400029f0:	fa 06 60 08 	ld  [ %i1 + 8 ], %i5                           
  /*                                                                  
   * FIXME: Due to insufficient checks we can create inaccessible nodes with
   * this operation.                                                  
   */                                                                 
                                                                      
  if ( node->Parent != NULL ) {                                       
400029f4:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
400029f8:	80 a0 60 00 	cmp  %g1, 0                                    
400029fc:	02 80 00 22 	be  40002a84 <IMFS_rename+0x98>                <== NEVER TAKEN
40002a00:	f4 06 a0 08 	ld  [ %i2 + 8 ], %i2                           
    if ( namelen < IMFS_NAME_MAX ) {                                  
40002a04:	80 a7 20 1f 	cmp  %i4, 0x1f                                 
40002a08:	18 80 00 19 	bgu  40002a6c <IMFS_rename+0x80>               <== NEVER TAKEN
40002a0c:	94 10 00 1c 	mov  %i4, %o2                                  
      memcpy( node->name, name, namelen );                            
40002a10:	92 10 00 1b 	mov  %i3, %o1                                  
40002a14:	40 00 35 9c 	call  40010084 <memcpy>                        
40002a18:	90 07 60 0c 	add  %i5, 0xc, %o0                             
      node->name [namelen] = '\0';                                    
40002a1c:	b8 07 40 1c 	add  %i5, %i4, %i4                             
40002a20:	c0 2f 20 0c 	clrb  [ %i4 + 0xc ]                            
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
40002a24:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
40002a28:	c4 07 40 00 	ld  [ %i5 ], %g2                               
RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected(                  
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
40002a2c:	86 06 a0 54 	add  %i2, 0x54, %g3                            
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
  next->previous = previous;                                          
40002a30:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]                           
  previous->next = next;                                              
40002a34:	c4 20 40 00 	st  %g2, [ %g1 ]                               
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
40002a38:	c2 06 a0 58 	ld  [ %i2 + 0x58 ], %g1                        
static inline void IMFS_add_to_directory(                             
  IMFS_jnode_t *dir,                                                  
  IMFS_jnode_t *node                                                  
)                                                                     
{                                                                     
  node->Parent = dir;                                                 
40002a3c:	f4 27 60 08 	st  %i2, [ %i5 + 8 ]                           
                                                                      
  the_node->next = tail;                                              
40002a40:	c6 27 40 00 	st  %g3, [ %i5 ]                               
  tail->previous = the_node;                                          
40002a44:	fa 26 a0 58 	st  %i5, [ %i2 + 0x58 ]                        
  old_last->next = the_node;                                          
40002a48:	fa 20 40 00 	st  %i5, [ %g1 ]                               
  the_node->previous = old_last;                                      
40002a4c:	c2 27 60 04 	st  %g1, [ %i5 + 4 ]                           
                                                                      
      IMFS_remove_from_directory( node );                             
      IMFS_add_to_directory( new_parent, node );                      
      IMFS_update_ctime( node );                                      
40002a50:	90 07 bf f8 	add  %fp, -8, %o0                              
40002a54:	40 00 01 9f 	call  400030d0 <gettimeofday>                  
40002a58:	92 10 20 00 	clr  %o1                                       
40002a5c:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
40002a60:	c2 27 60 48 	st  %g1, [ %i5 + 0x48 ]                        
  const rtems_filesystem_location_info_t *newparentloc,               
  const char *name,                                                   
  size_t namelen                                                      
)                                                                     
{                                                                     
  int rv = 0;                                                         
40002a64:	81 c7 e0 08 	ret                                            
40002a68:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      
      IMFS_remove_from_directory( node );                             
      IMFS_add_to_directory( new_parent, node );                      
      IMFS_update_ctime( node );                                      
    } else {                                                          
      errno = ENAMETOOLONG;                                           
40002a6c:	40 00 33 35 	call  4000f740 <__errno>                       <== NOT EXECUTED
40002a70:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40002a74:	82 10 20 5b 	mov  0x5b, %g1                                 <== NOT EXECUTED
40002a78:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
40002a7c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40002a80:	81 e8 00 00 	restore                                        <== NOT EXECUTED
      rv = -1;                                                        
    }                                                                 
  } else {                                                            
    errno = EINVAL;                                                   
40002a84:	40 00 33 2f 	call  4000f740 <__errno>                       <== NOT EXECUTED
40002a88:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40002a8c:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
40002a90:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
40002a94:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40002a98:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40002b88 <IMFS_unmount>: #endif #include "imfs.h" int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry ) {
40002b88:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rv = 0;                                                         
  IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access; 
40002b8c:	c2 06 20 20 	ld  [ %i0 + 0x20 ], %g1                        
40002b90:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
  return node->control->imfs_type;                                    
}                                                                     
                                                                      
static inline bool IMFS_is_directory( const IMFS_jnode_t *node )      
{                                                                     
  return node->control->imfs_type == IMFS_DIRECTORY;                  
40002b94:	c4 00 60 4c 	ld  [ %g1 + 0x4c ], %g2                        
                                                                      
  if ( IMFS_is_directory( node ) ) {                                  
40002b98:	c4 00 80 00 	ld  [ %g2 ], %g2                               
40002b9c:	80 a0 a0 00 	cmp  %g2, 0                                    
40002ba0:	12 80 00 0f 	bne  40002bdc <IMFS_unmount+0x54>              <== NEVER TAKEN
40002ba4:	01 00 00 00 	nop                                            
    if ( node->info.directory.mt_fs == mt_entry ) {                   
40002ba8:	c4 00 60 5c 	ld  [ %g1 + 0x5c ], %g2                        
40002bac:	80 a0 80 18 	cmp  %g2, %i0                                  
40002bb0:	12 80 00 05 	bne  40002bc4 <IMFS_unmount+0x3c>              <== NEVER TAKEN
40002bb4:	01 00 00 00 	nop                                            
      node->info.directory.mt_fs = NULL;                              
40002bb8:	c0 20 60 5c 	clr  [ %g1 + 0x5c ]                            
                                                                      
#include "imfs.h"                                                     
                                                                      
int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry )    
{                                                                     
  int rv = 0;                                                         
40002bbc:	81 c7 e0 08 	ret                                            
40002bc0:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      
  if ( IMFS_is_directory( node ) ) {                                  
    if ( node->info.directory.mt_fs == mt_entry ) {                   
      node->info.directory.mt_fs = NULL;                              
    } else {                                                          
      errno = EINVAL;                                                 
40002bc4:	40 00 32 df 	call  4000f740 <__errno>                       <== NOT EXECUTED
40002bc8:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40002bcc:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
40002bd0:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
40002bd4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40002bd8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
      rv = -1;                                                        
    }                                                                 
  } else {                                                            
    errno = ENOTDIR;                                                  
40002bdc:	40 00 32 d9 	call  4000f740 <__errno>                       <== NOT EXECUTED
40002be0:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40002be4:	82 10 20 14 	mov  0x14, %g1                                 <== NOT EXECUTED
40002be8:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
40002bec:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40002bf0:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

400032d0 <RTEMS_Malloc_Initialize>: void RTEMS_Malloc_Initialize( const Heap_Area *areas, size_t area_count, Heap_Initialization_or_extend_handler extend ) {
400032d0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Heap_Control *heap = RTEMS_Malloc_Heap;                             
                                                                      
  if ( !rtems_configuration_get_unified_work_area() ) {               
400032d4:	03 10 00 71 	sethi  %hi(0x4001c400), %g1                    
400032d8:	c2 08 60 49 	ldub  [ %g1 + 0x49 ], %g1	! 4001c449 <Configuration+0x31>
  const Heap_Area *areas,                                             
  size_t area_count,                                                  
  Heap_Initialization_or_extend_handler extend                        
)                                                                     
{                                                                     
  Heap_Control *heap = RTEMS_Malloc_Heap;                             
400032dc:	05 10 00 78 	sethi  %hi(0x4001e000), %g2                    
                                                                      
  if ( !rtems_configuration_get_unified_work_area() ) {               
400032e0:	80 a0 60 00 	cmp  %g1, 0                                    
400032e4:	12 80 00 17 	bne  40003340 <RTEMS_Malloc_Initialize+0x70>   
400032e8:	f6 00 a3 60 	ld  [ %g2 + 0x360 ], %i3                       
    Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
    uintptr_t page_size = CPU_HEAP_ALIGNMENT;                         
    size_t i;                                                         
                                                                      
    for (i = 0; i < area_count; ++i) {                                
400032ec:	80 a6 60 00 	cmp  %i1, 0                                    
400032f0:	02 80 00 23 	be  4000337c <RTEMS_Malloc_Initialize+0xac>    
400032f4:	21 10 00 21 	sethi  %hi(0x40008400), %l0                    
400032f8:	ba 10 20 00 	clr  %i5                                       
400032fc:	a0 14 22 98 	or  %l0, 0x298, %l0                            
40003300:	b8 10 00 10 	mov  %l0, %i4                                  
      const Heap_Area *area = &areas [i];                             
      uintptr_t space_available = (*init_or_extend)(                  
40003304:	d2 06 00 00 	ld  [ %i0 ], %o1                               
40003308:	d4 06 20 04 	ld  [ %i0 + 4 ], %o2                           
4000330c:	90 10 00 1b 	mov  %i3, %o0                                  
40003310:	9f c7 00 00 	call  %i4                                      
40003314:	96 10 20 08 	mov  8, %o3                                    
        area->begin,                                                  
        area->size,                                                   
        page_size                                                     
      );                                                              
                                                                      
      if ( space_available > 0 ) {                                    
40003318:	80 a2 20 00 	cmp  %o0, 0                                    
4000331c:	32 80 00 02 	bne,a   40003324 <RTEMS_Malloc_Initialize+0x54><== ALWAYS TAKEN
40003320:	b8 10 00 1a 	mov  %i2, %i4                                  
  if ( !rtems_configuration_get_unified_work_area() ) {               
    Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
    uintptr_t page_size = CPU_HEAP_ALIGNMENT;                         
    size_t i;                                                         
                                                                      
    for (i = 0; i < area_count; ++i) {                                
40003324:	ba 07 60 01 	inc  %i5                                       
40003328:	80 a7 40 19 	cmp  %i5, %i1                                  
4000332c:	12 bf ff f6 	bne  40003304 <RTEMS_Malloc_Initialize+0x34>   <== NEVER TAKEN
40003330:	b0 06 20 08 	add  %i0, 8, %i0                               
      if ( space_available > 0 ) {                                    
        init_or_extend = extend;                                      
      }                                                               
    }                                                                 
                                                                      
    if ( init_or_extend == _Heap_Initialize ) {                       
40003334:	80 a7 00 10 	cmp  %i4, %l0                                  
40003338:	02 80 00 12 	be  40003380 <RTEMS_Malloc_Initialize+0xb0>    <== NEVER TAKEN
4000333c:	90 10 20 00 	clr  %o0                                       
  }                                                                   
                                                                      
  /*                                                                  
   *  If configured, initialize the statistics support                
   */                                                                 
  if ( rtems_malloc_statistics_helpers != NULL ) {                    
40003340:	03 10 00 7a 	sethi  %hi(0x4001e800), %g1                    
40003344:	c2 00 62 90 	ld  [ %g1 + 0x290 ], %g1	! 4001ea90 <rtems_malloc_statistics_helpers>
40003348:	80 a0 60 00 	cmp  %g1, 0                                    
4000334c:	02 80 00 05 	be  40003360 <RTEMS_Malloc_Initialize+0x90>    
40003350:	3b 10 00 7b 	sethi  %hi(0x4001ec00), %i5                    
    (*rtems_malloc_statistics_helpers->initialize)();                 
40003354:	c2 00 40 00 	ld  [ %g1 ], %g1                               
40003358:	9f c0 40 00 	call  %g1                                      
4000335c:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  MSBUMP( space_available, _Protected_heap_Get_size( heap ) );        
40003360:	f8 07 61 40 	ld  [ %i5 + 0x140 ], %i4                       
40003364:	40 00 17 db 	call  400092d0 <_Protected_heap_Get_size>      
40003368:	90 10 00 1b 	mov  %i3, %o0                                  
4000336c:	90 02 00 1c 	add  %o0, %i4, %o0                             
40003370:	d0 27 61 40 	st  %o0, [ %i5 + 0x140 ]                       
40003374:	81 c7 e0 08 	ret                                            
40003378:	81 e8 00 00 	restore                                        
        init_or_extend = extend;                                      
      }                                                               
    }                                                                 
                                                                      
    if ( init_or_extend == _Heap_Initialize ) {                       
      _Internal_error_Occurred(                                       
4000337c:	90 10 20 00 	clr  %o0                                       
40003380:	92 10 20 01 	mov  1, %o1                                    
40003384:	40 00 15 62 	call  4000890c <_Internal_error_Occurred>      
40003388:	94 10 20 17 	mov  0x17, %o2                                 
                                                                      

40024f5c <Stack_check_Dump_threads_usage>: static rtems_printk_plugin_t print_handler; static void Stack_check_Dump_threads_usage( Thread_Control *the_thread ) {
40024f5c:	9d e3 bf 98 	save  %sp, -104, %sp                           <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Obtain interrupt stack information                              
   */                                                                 
  #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)                          
    if (the_thread == (Thread_Control *) -1) {                        
40024f60:	80 a6 3f ff 	cmp  %i0, -1                                   <== NOT EXECUTED
40024f64:	02 80 00 56 	be  400250bc <Stack_check_Dump_threads_usage+0x160><== NOT EXECUTED
40024f68:	ba 06 20 b4 	add  %i0, 0xb4, %i5                            <== NOT EXECUTED
      current = 0;                                                    
    } else                                                            
  #endif                                                              
    {                                                                 
      stack  = &the_thread->Start.Initial_stack;                      
      current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
40024f6c:	e2 06 21 38 	ld  [ %i0 + 0x138 ], %l1                       <== NOT EXECUTED
40024f70:	f8 06 20 b8 	ld  [ %i0 + 0xb8 ], %i4                        <== NOT EXECUTED
    }                                                                 
                                                                      
  low  = Stack_check_usable_stack_start(stack);                       
  size = Stack_check_usable_stack_size(stack);                        
40024f74:	f4 07 40 00 	ld  [ %i5 ], %i2                               <== NOT EXECUTED
    /*                                                                
     * start at lower memory and find first word that does not        
     * match pattern                                                  
     */                                                               
                                                                      
    base += PATTERN_SIZE_WORDS;                                       
40024f78:	82 07 20 20 	add  %i4, 0x20, %g1                            <== NOT EXECUTED
      stack  = &the_thread->Start.Initial_stack;                      
      current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
    }                                                                 
                                                                      
  low  = Stack_check_usable_stack_start(stack);                       
  size = Stack_check_usable_stack_size(stack);                        
40024f7c:	b4 06 bf f0 	add  %i2, -16, %i2                             <== 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++)                 
40024f80:	86 0e bf fc 	and  %i2, -4, %g3                              <== NOT EXECUTED
40024f84:	86 00 40 03 	add  %g1, %g3, %g3                             <== NOT EXECUTED
40024f88:	80 a0 40 03 	cmp  %g1, %g3                                  <== NOT EXECUTED
40024f8c:	1a 80 00 10 	bcc  40024fcc <Stack_check_Dump_threads_usage+0x70><== NOT EXECUTED
40024f90:	05 29 69 69 	sethi  %hi(0xa5a5a400), %g2                    <== NOT EXECUTED
      if (*base != U32_PATTERN)                                       
40024f94:	c8 07 20 20 	ld  [ %i4 + 0x20 ], %g4                        <== NOT EXECUTED
40024f98:	84 10 a1 a5 	or  %g2, 0x1a5, %g2                            <== NOT EXECUTED
40024f9c:	80 a1 00 02 	cmp  %g4, %g2                                  <== NOT EXECUTED
40024fa0:	22 80 00 08 	be,a   40024fc0 <Stack_check_Dump_threads_usage+0x64><== NOT EXECUTED
40024fa4:	82 00 60 04 	add  %g1, 4, %g1                               <== NOT EXECUTED
    {                                                                 
      stack  = &the_thread->Start.Initial_stack;                      
      current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
    }                                                                 
                                                                      
  low  = Stack_check_usable_stack_start(stack);                       
40024fa8:	10 80 00 37 	b  40025084 <Stack_check_Dump_threads_usage+0x128><== NOT EXECUTED
40024fac:	a0 07 20 10 	add  %i4, 0x10, %l0                            <== NOT EXECUTED
     * match pattern                                                  
     */                                                               
                                                                      
    base += PATTERN_SIZE_WORDS;                                       
    for (ebase = base + length; base < ebase; base++)                 
      if (*base != U32_PATTERN)                                       
40024fb0:	80 a0 80 04 	cmp  %g2, %g4                                  <== NOT EXECUTED
40024fb4:	12 80 00 34 	bne  40025084 <Stack_check_Dump_threads_usage+0x128><== NOT EXECUTED
40024fb8:	a0 07 20 10 	add  %i4, 0x10, %l0                            <== 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++)                 
40024fbc:	82 00 60 04 	add  %g1, 4, %g1                               <== NOT EXECUTED
40024fc0:	80 a0 c0 01 	cmp  %g3, %g1                                  <== NOT EXECUTED
40024fc4:	38 bf ff fb 	bgu,a   40024fb0 <Stack_check_Dump_threads_usage+0x54><== NOT EXECUTED
40024fc8:	c4 00 40 00 	ld  [ %g1 ], %g2                               <== NOT EXECUTED
  else                                                                
    used = 0;                                                         
                                                                      
                                                                      
  #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)                          
    if ( the_thread )                                                 
40024fcc:	80 a6 20 00 	cmp  %i0, 0                                    <== NOT EXECUTED
40024fd0:	02 80 00 31 	be  40025094 <Stack_check_Dump_threads_usage+0x138><== NOT EXECUTED
40024fd4:	a0 10 20 00 	clr  %l0                                       <== NOT EXECUTED
  #endif                                                              
    {                                                                 
      (*print_handler)(                                               
40024fd8:	f2 06 20 08 	ld  [ %i0 + 8 ], %i1                           <== NOT EXECUTED
40024fdc:	39 10 01 9f 	sethi  %hi(0x40067c00), %i4                    <== NOT EXECUTED
40024fe0:	37 10 01 9f 	sethi  %hi(0x40067c00), %i3                    <== NOT EXECUTED
40024fe4:	e4 07 20 fc 	ld  [ %i4 + 0xfc ], %l2                        <== NOT EXECUTED
40024fe8:	f0 06 e1 00 	ld  [ %i3 + 0x100 ], %i0                       <== NOT EXECUTED
40024fec:	94 07 bf f8 	add  %fp, -8, %o2                              <== NOT EXECUTED
40024ff0:	92 10 20 05 	mov  5, %o1                                    <== NOT EXECUTED
40024ff4:	7f ff a8 86 	call  4000f20c <rtems_object_get_name>         <== NOT EXECUTED
40024ff8:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
40024ffc:	13 10 01 7a 	sethi  %hi(0x4005e800), %o1                    <== NOT EXECUTED
40025000:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
40025004:	94 10 00 19 	mov  %i1, %o2                                  <== NOT EXECUTED
40025008:	90 10 00 12 	mov  %l2, %o0                                  <== NOT EXECUTED
4002500c:	9f c6 00 00 	call  %i0                                      <== NOT EXECUTED
40025010:	92 12 62 f0 	or  %o1, 0x2f0, %o1                            <== NOT EXECUTED
                                                                      
  (*print_handler)(                                                   
    print_context,                                                    
    " %010p - %010p %010p  %8" PRId32 "   ",                          
    stack->area,                                                      
    stack->area + stack->size - 1,                                    
40025014:	d4 07 60 04 	ld  [ %i5 + 4 ], %o2                           <== NOT EXECUTED
40025018:	d6 07 40 00 	ld  [ %i5 ], %o3                               <== NOT EXECUTED
      else {                                                          
        (*print_handler)( print_context, "0x%08" PRIx32 "  INTR", ~0 );
      }                                                               
    #endif                                                            
                                                                      
  (*print_handler)(                                                   
4002501c:	c4 06 e1 00 	ld  [ %i3 + 0x100 ], %g2                       <== NOT EXECUTED
40025020:	d0 07 20 fc 	ld  [ %i4 + 0xfc ], %o0                        <== NOT EXECUTED
    print_context,                                                    
    " %010p - %010p %010p  %8" PRId32 "   ",                          
    stack->area,                                                      
    stack->area + stack->size - 1,                                    
40025024:	96 02 ff ff 	add  %o3, -1, %o3                              <== NOT EXECUTED
      else {                                                          
        (*print_handler)( print_context, "0x%08" PRIx32 "  INTR", ~0 );
      }                                                               
    #endif                                                            
                                                                      
  (*print_handler)(                                                   
40025028:	13 10 01 7a 	sethi  %hi(0x4005e800), %o1                    <== NOT EXECUTED
4002502c:	96 02 80 0b 	add  %o2, %o3, %o3                             <== NOT EXECUTED
40025030:	92 12 63 10 	or  %o1, 0x310, %o1                            <== NOT EXECUTED
40025034:	98 10 00 11 	mov  %l1, %o4                                  <== NOT EXECUTED
40025038:	9f c0 80 00 	call  %g2                                      <== NOT EXECUTED
4002503c:	9a 10 00 1a 	mov  %i2, %o5                                  <== NOT EXECUTED
    stack->area + stack->size - 1,                                    
    current,                                                          
    size                                                              
  );                                                                  
                                                                      
  if (Stack_check_Initialized == 0) {                                 
40025040:	05 10 01 9f 	sethi  %hi(0x40067c00), %g2                    <== NOT EXECUTED
40025044:	c4 00 a0 f8 	ld  [ %g2 + 0xf8 ], %g2	! 40067cf8 <Stack_check_Initialized><== NOT EXECUTED
    (*print_handler)( print_context, "Unavailable\n" );               
40025048:	c2 06 e1 00 	ld  [ %i3 + 0x100 ], %g1                       <== NOT EXECUTED
    stack->area + stack->size - 1,                                    
    current,                                                          
    size                                                              
  );                                                                  
                                                                      
  if (Stack_check_Initialized == 0) {                                 
4002504c:	80 a0 a0 00 	cmp  %g2, 0                                    <== NOT EXECUTED
40025050:	12 80 00 07 	bne  4002506c <Stack_check_Dump_threads_usage+0x110><== NOT EXECUTED
40025054:	d0 07 20 fc 	ld  [ %i4 + 0xfc ], %o0                        <== NOT EXECUTED
    (*print_handler)( print_context, "Unavailable\n" );               
40025058:	13 10 01 7a 	sethi  %hi(0x4005e800), %o1                    <== NOT EXECUTED
4002505c:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
40025060:	92 12 63 30 	or  %o1, 0x330, %o1	! 4005eb30 <RTEMS_BDPART_MBR_MASTER_TYPE+0x300><== NOT EXECUTED
40025064:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40025068:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  } else {                                                            
    (*print_handler)( print_context, "%8" PRId32 "\n", used );        
4002506c:	94 10 00 10 	mov  %l0, %o2                                  <== NOT EXECUTED
40025070:	13 10 01 7a 	sethi  %hi(0x4005e800), %o1                    <== NOT EXECUTED
40025074:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
40025078:	92 12 63 40 	or  %o1, 0x340, %o1	! 4005eb40 <RTEMS_BDPART_MBR_MASTER_TYPE+0x310><== NOT EXECUTED
4002507c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40025080:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  else                                                                
    used = 0;                                                         
                                                                      
                                                                      
  #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)                          
    if ( the_thread )                                                 
40025084:	80 a6 20 00 	cmp  %i0, 0                                    <== NOT EXECUTED
  size = Stack_check_usable_stack_size(stack);                        
                                                                      
  high_water_mark = Stack_check_find_high_water_mark(low, size);      
                                                                      
  if ( high_water_mark )                                              
    used = Stack_check_Calculate_used( low, size, high_water_mark );  
40025088:	a0 04 00 1a 	add  %l0, %i2, %l0                             <== NOT EXECUTED
  else                                                                
    used = 0;                                                         
                                                                      
                                                                      
  #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)                          
    if ( the_thread )                                                 
4002508c:	12 bf ff d3 	bne  40024fd8 <Stack_check_Dump_threads_usage+0x7c><== NOT EXECUTED
40025090:	a0 24 00 01 	sub  %l0, %g1, %l0                             <== NOT EXECUTED
        rtems_object_get_name( the_thread->Object.id, sizeof(name), name )
      );                                                              
    }                                                                 
    #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)                        
      else {                                                          
        (*print_handler)( print_context, "0x%08" PRIx32 "  INTR", ~0 );
40025094:	37 10 01 9f 	sethi  %hi(0x40067c00), %i3                    <== NOT EXECUTED
40025098:	39 10 01 9f 	sethi  %hi(0x40067c00), %i4                    <== NOT EXECUTED
4002509c:	c2 06 e1 00 	ld  [ %i3 + 0x100 ], %g1                       <== NOT EXECUTED
400250a0:	d0 07 20 fc 	ld  [ %i4 + 0xfc ], %o0                        <== NOT EXECUTED
400250a4:	94 10 3f ff 	mov  -1, %o2                                   <== NOT EXECUTED
400250a8:	13 10 01 7a 	sethi  %hi(0x4005e800), %o1                    <== NOT EXECUTED
400250ac:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
400250b0:	92 12 63 00 	or  %o1, 0x300, %o1	! 4005eb00 <RTEMS_BDPART_MBR_MASTER_TYPE+0x2d0><== NOT EXECUTED
                                                                      
  (*print_handler)(                                                   
    print_context,                                                    
    " %010p - %010p %010p  %8" PRId32 "   ",                          
    stack->area,                                                      
    stack->area + stack->size - 1,                                    
400250b4:	10 bf ff d9 	b  40025018 <Stack_check_Dump_threads_usage+0xbc><== NOT EXECUTED
400250b8:	d4 07 60 04 	ld  [ %i5 + 4 ], %o2                           <== NOT EXECUTED
  /*                                                                  
   *  Obtain interrupt stack information                              
   */                                                                 
  #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)                          
    if (the_thread == (Thread_Control *) -1) {                        
      if (!Stack_check_Interrupt_stack.area)                          
400250bc:	3b 10 01 a3 	sethi  %hi(0x40068c00), %i5                    <== NOT EXECUTED
400250c0:	ba 17 62 ec 	or  %i5, 0x2ec, %i5	! 40068eec <Stack_check_Interrupt_stack><== NOT EXECUTED
400250c4:	f8 07 60 04 	ld  [ %i5 + 4 ], %i4                           <== NOT EXECUTED
400250c8:	80 a7 20 00 	cmp  %i4, 0                                    <== NOT EXECUTED
400250cc:	02 bf ff e6 	be  40025064 <Stack_check_Dump_threads_usage+0x108><== NOT EXECUTED
400250d0:	a2 10 20 00 	clr  %l1                                       <== NOT EXECUTED
        return;                                                       
      stack = &Stack_check_Interrupt_stack;                           
      the_thread = 0;                                                 
400250d4:	10 bf ff a8 	b  40024f74 <Stack_check_Dump_threads_usage+0x18><== NOT EXECUTED
400250d8:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
                                                                      

400251d0 <Stack_check_report_blown_task>: Thread_Control *running, bool pattern_ok ) RTEMS_COMPILER_NO_RETURN_ATTRIBUTE; void Stack_check_report_blown_task(Thread_Control *running, bool pattern_ok) {
400251d0:	9d e3 bf 80 	save  %sp, -128, %sp                           <== NOT EXECUTED
  Stack_Control *stack = &running->Start.Initial_stack;               
  void          *pattern_area = Stack_check_Get_pattern(stack);       
  char           name[32];                                            
                                                                      
  printk("BLOWN STACK!!!\n");                                         
400251d4:	11 10 01 7a 	sethi  %hi(0x4005e800), %o0                    <== NOT EXECUTED
) RTEMS_COMPILER_NO_RETURN_ATTRIBUTE;                                 
                                                                      
void Stack_check_report_blown_task(Thread_Control *running, bool pattern_ok)
{                                                                     
  Stack_Control *stack = &running->Start.Initial_stack;               
  void          *pattern_area = Stack_check_Get_pattern(stack);       
400251d8:	fa 06 20 b8 	ld  [ %i0 + 0xb8 ], %i5                        <== NOT EXECUTED
  char           name[32];                                            
                                                                      
  printk("BLOWN STACK!!!\n");                                         
400251dc:	7f ff 79 ed 	call  40003990 <printk>                        <== NOT EXECUTED
400251e0:	90 12 23 48 	or  %o0, 0x348, %o0                            <== NOT EXECUTED
  printk("task control block: 0x%08" PRIxPTR "\n", running);          
400251e4:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
400251e8:	11 10 01 7a 	sethi  %hi(0x4005e800), %o0                    <== NOT EXECUTED
400251ec:	7f ff 79 e9 	call  40003990 <printk>                        <== NOT EXECUTED
400251f0:	90 12 23 58 	or  %o0, 0x358, %o0	! 4005eb58 <RTEMS_BDPART_MBR_MASTER_TYPE+0x328><== NOT EXECUTED
  printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id);   
400251f4:	d2 06 20 08 	ld  [ %i0 + 8 ], %o1                           <== NOT EXECUTED
400251f8:	11 10 01 7a 	sethi  %hi(0x4005e800), %o0                    <== NOT EXECUTED
400251fc:	7f ff 79 e5 	call  40003990 <printk>                        <== NOT EXECUTED
40025200:	90 12 23 78 	or  %o0, 0x378, %o0	! 4005eb78 <RTEMS_BDPART_MBR_MASTER_TYPE+0x348><== NOT EXECUTED
  printk(                                                             
40025204:	d2 06 20 0c 	ld  [ %i0 + 0xc ], %o1                         <== NOT EXECUTED
40025208:	11 10 01 7a 	sethi  %hi(0x4005e800), %o0                    <== NOT EXECUTED
4002520c:	7f ff 79 e1 	call  40003990 <printk>                        <== NOT EXECUTED
40025210:	90 12 23 90 	or  %o0, 0x390, %o0	! 4005eb90 <RTEMS_BDPART_MBR_MASTER_TYPE+0x360><== NOT EXECUTED
    "task name: 0x%08" PRIx32 "\n",                                   
    running->Object.name.name_u32                                     
  );                                                                  
  printk(                                                             
40025214:	d0 06 20 08 	ld  [ %i0 + 8 ], %o0                           <== NOT EXECUTED
40025218:	94 07 bf e0 	add  %fp, -32, %o2                             <== NOT EXECUTED
4002521c:	7f ff a7 fc 	call  4000f20c <rtems_object_get_name>         <== NOT EXECUTED
40025220:	92 10 20 20 	mov  0x20, %o1                                 <== NOT EXECUTED
40025224:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40025228:	11 10 01 7a 	sethi  %hi(0x4005e800), %o0                    <== NOT EXECUTED
4002522c:	7f ff 79 d9 	call  40003990 <printk>                        <== NOT EXECUTED
40025230:	90 12 23 a8 	or  %o0, 0x3a8, %o0	! 4005eba8 <RTEMS_BDPART_MBR_MASTER_TYPE+0x378><== NOT EXECUTED
  );                                                                  
  printk(                                                             
    "task stack area (%lu Bytes): 0x%08" PRIxPTR " .. 0x%08" PRIxPTR "\n",
    (unsigned long) stack->size,                                      
    stack->area,                                                      
    ((char *) stack->area + stack->size)                              
40025234:	d4 06 20 b8 	ld  [ %i0 + 0xb8 ], %o2                        <== NOT EXECUTED
40025238:	d2 06 20 b4 	ld  [ %i0 + 0xb4 ], %o1                        <== NOT EXECUTED
  );                                                                  
  printk(                                                             
    "task name string: %s\n",                                         
    rtems_object_get_name(running->Object.id, sizeof(name), name)     
  );                                                                  
  printk(                                                             
4002523c:	11 10 01 7a 	sethi  %hi(0x4005e800), %o0                    <== NOT EXECUTED
40025240:	96 02 80 09 	add  %o2, %o1, %o3                             <== NOT EXECUTED
40025244:	7f ff 79 d3 	call  40003990 <printk>                        <== NOT EXECUTED
40025248:	90 12 23 c0 	or  %o0, 0x3c0, %o0                            <== NOT EXECUTED
    "task stack area (%lu Bytes): 0x%08" PRIxPTR " .. 0x%08" PRIxPTR "\n",
    (unsigned long) stack->size,                                      
    stack->area,                                                      
    ((char *) stack->area + stack->size)                              
  );                                                                  
  if (!pattern_ok) {                                                  
4002524c:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
40025250:	02 80 00 05 	be  40025264 <Stack_check_report_blown_task+0x94><== NOT EXECUTED
40025254:	92 10 20 10 	mov  0x10, %o1                                 <== NOT EXECUTED
          rtems_configuration_get_user_multiprocessing_table()->node  
      );                                                              
    }                                                                 
  #endif                                                              
                                                                      
  rtems_fatal(                                                        
40025258:	d2 06 20 0c 	ld  [ %i0 + 0xc ], %o1                         <== NOT EXECUTED
4002525c:	7f ff 88 b8 	call  4000753c <rtems_fatal>                   <== NOT EXECUTED
40025260:	90 10 20 09 	mov  9, %o0                                    <== NOT EXECUTED
    (unsigned long) stack->size,                                      
    stack->area,                                                      
    ((char *) stack->area + stack->size)                              
  );                                                                  
  if (!pattern_ok) {                                                  
    printk(                                                           
40025264:	11 10 01 7a 	sethi  %hi(0x4005e800), %o0                    <== NOT EXECUTED
40025268:	94 07 60 08 	add  %i5, 8, %o2                               <== NOT EXECUTED
4002526c:	90 12 23 f0 	or  %o0, 0x3f0, %o0                            <== NOT EXECUTED
40025270:	7f ff 79 c8 	call  40003990 <printk>                        <== NOT EXECUTED
40025274:	96 07 60 18 	add  %i5, 0x18, %o3                            <== NOT EXECUTED
          rtems_configuration_get_user_multiprocessing_table()->node  
      );                                                              
    }                                                                 
  #endif                                                              
                                                                      
  rtems_fatal(                                                        
40025278:	10 bf ff f9 	b  4002525c <Stack_check_report_blown_task+0x8c><== NOT EXECUTED
4002527c:	d2 06 20 0c 	ld  [ %i0 + 0xc ], %o1                         <== NOT EXECUTED
                                                                      

40007d78 <_API_extensions_Add_post_switch>: */ RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain( const Chain_Node *node ) { return (node->next == NULL) && (node->previous == NULL);
40007d78:	c2 02 00 00 	ld  [ %o0 ], %g1                               
40007d7c:	80 a0 60 00 	cmp  %g1, 0                                    
40007d80:	22 80 00 04 	be,a   40007d90 <_API_extensions_Add_post_switch+0x18>
40007d84:	c2 02 20 04 	ld  [ %o0 + 4 ], %g1                           
40007d88:	81 c3 e0 08 	retl                                           
40007d8c:	01 00 00 00 	nop                                            
40007d90:	80 a0 60 00 	cmp  %g1, 0                                    
40007d94:	12 bf ff fd 	bne  40007d88 <_API_extensions_Add_post_switch+0x10><== NEVER TAKEN
40007d98:	03 10 00 7b 	sethi  %hi(0x4001ec00), %g1                    
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
40007d9c:	82 10 63 30 	or  %g1, 0x330, %g1	! 4001ef30 <_API_extensions_Post_switch_list>
40007da0:	c4 00 60 08 	ld  [ %g1 + 8 ], %g2                           
                                                                      
  the_node->next = tail;                                              
40007da4:	86 00 60 04 	add  %g1, 4, %g3                               
  tail->previous = the_node;                                          
40007da8:	d0 20 60 08 	st  %o0, [ %g1 + 8 ]                           
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
                                                                      
  the_node->next = tail;                                              
40007dac:	c6 22 00 00 	st  %g3, [ %o0 ]                               
  tail->previous = the_node;                                          
  old_last->next = the_node;                                          
40007db0:	d0 20 80 00 	st  %o0, [ %g2 ]                               
  the_node->previous = old_last;                                      
40007db4:	81 c3 e0 08 	retl                                           
40007db8:	c4 22 20 04 	st  %g2, [ %o0 + 4 ]                           
                                                                      

40007dbc <_API_extensions_Run_postdriver>: } } #endif void _API_extensions_Run_postdriver( void ) {
40007dbc:	9d e3 bf a0 	save  %sp, -96, %sp                            
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return _Chain_Head( the_chain )->next;                              
40007dc0:	39 10 00 7c 	sethi  %hi(0x4001f000), %i4                    
40007dc4:	fa 07 20 78 	ld  [ %i4 + 0x78 ], %i5	! 4001f078 <_API_extensions_List>
40007dc8:	b8 17 20 78 	or  %i4, 0x78, %i4                             
  Chain_Node             *the_node;                                   
  API_extensions_Control *the_extension;                              
                                                                      
  for ( the_node = _Chain_First( &_API_extensions_List );             
40007dcc:	b8 07 20 04 	add  %i4, 4, %i4                               
40007dd0:	80 a7 40 1c 	cmp  %i5, %i4                                  
40007dd4:	02 80 00 09 	be  40007df8 <_API_extensions_Run_postdriver+0x3c><== NEVER TAKEN
40007dd8:	01 00 00 00 	nop                                            
     *  Currently all APIs configure this hook so it is always non-NULL.
     */                                                               
#if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API)              
    if ( the_extension->postdriver_hook )                             
#endif                                                                
      (*the_extension->postdriver_hook)();                            
40007ddc:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
40007de0:	9f c0 40 00 	call  %g1                                      
40007de4:	01 00 00 00 	nop                                            
  Chain_Node             *the_node;                                   
  API_extensions_Control *the_extension;                              
                                                                      
  for ( the_node = _Chain_First( &_API_extensions_List );             
        !_Chain_Is_tail( &_API_extensions_List, the_node ) ;          
        the_node = the_node->next ) {                                 
40007de8:	fa 07 40 00 	ld  [ %i5 ], %i5                               
void _API_extensions_Run_postdriver( void )                           
{                                                                     
  Chain_Node             *the_node;                                   
  API_extensions_Control *the_extension;                              
                                                                      
  for ( the_node = _Chain_First( &_API_extensions_List );             
40007dec:	80 a7 40 1c 	cmp  %i5, %i4                                  
40007df0:	32 bf ff fc 	bne,a   40007de0 <_API_extensions_Run_postdriver+0x24>
40007df4:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
40007df8:	81 c7 e0 08 	ret                                            
40007dfc:	81 e8 00 00 	restore                                        
                                                                      

4000a12c <_CORE_RWLock_Release>: #include <rtems/score/watchdog.h> CORE_RWLock_Status _CORE_RWLock_Release( CORE_RWLock_Control *the_rwlock ) {
4000a12c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  ISR_Level       level;                                              
  Thread_Control *executing = _Thread_Executing;                      
4000a130:	03 10 00 6b 	sethi  %hi(0x4001ac00), %g1                    
   *  Otherwise, we have to block.                                    
   *  If locked for reading and no waiters, then OK to read.          
   *  If any thread is waiting, then we wait.                         
   */                                                                 
                                                                      
  _ISR_Disable( level );                                              
4000a134:	7f ff e4 c6 	call  4000344c <sparc_disable_interrupts>      
4000a138:	fa 00 61 00 	ld  [ %g1 + 0x100 ], %i5	! 4001ad00 <_Per_CPU_Information+0x10>
4000a13c:	84 10 00 08 	mov  %o0, %g2                                  
    if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){          
4000a140:	c2 06 20 44 	ld  [ %i0 + 0x44 ], %g1                        
4000a144:	80 a0 60 00 	cmp  %g1, 0                                    
4000a148:	02 80 00 2b 	be  4000a1f4 <_CORE_RWLock_Release+0xc8>       
4000a14c:	80 a0 60 01 	cmp  %g1, 1                                    
      _ISR_Enable( level );                                           
      executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;          
      return CORE_RWLOCK_SUCCESSFUL;                                  
    }                                                                 
    if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
4000a150:	22 80 00 22 	be,a   4000a1d8 <_CORE_RWLock_Release+0xac>    
4000a154:	c2 06 20 48 	ld  [ %i0 + 0x48 ], %g1                        
          return CORE_RWLOCK_SUCCESSFUL;                              
        }                                                             
    }                                                                 
                                                                      
    /* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */      
    executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;             
4000a158:	c0 27 60 34 	clr  [ %i5 + 0x34 ]                            
                                                                      
    /*                                                                
     * Implicitly transition to "unlocked" and find another thread interested
     * in obtaining this rwlock.                                      
     */                                                               
    the_rwlock->current_state = CORE_RWLOCK_UNLOCKED;                 
4000a15c:	c0 26 20 44 	clr  [ %i0 + 0x44 ]                            
  _ISR_Enable( level );                                               
4000a160:	7f ff e4 bf 	call  4000345c <sparc_enable_interrupts>       
4000a164:	90 10 00 02 	mov  %g2, %o0                                  
                                                                      
  next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );            
4000a168:	40 00 07 e0 	call  4000c0e8 <_Thread_queue_Dequeue>         
4000a16c:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
  if ( next ) {                                                       
4000a170:	80 a2 20 00 	cmp  %o0, 0                                    
4000a174:	22 80 00 24 	be,a   4000a204 <_CORE_RWLock_Release+0xd8>    
4000a178:	b0 10 20 00 	clr  %i0                                       
    if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
4000a17c:	c2 02 20 30 	ld  [ %o0 + 0x30 ], %g1                        
4000a180:	80 a0 60 01 	cmp  %g1, 1                                    
4000a184:	02 80 00 22 	be  4000a20c <_CORE_RWLock_Release+0xe0>       
4000a188:	84 10 20 01 	mov  1, %g2                                    
    }                                                                 
                                                                      
    /*                                                                
     * Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING                 
     */                                                               
    the_rwlock->number_of_readers += 1;                               
4000a18c:	c2 06 20 48 	ld  [ %i0 + 0x48 ], %g1                        
4000a190:	82 00 60 01 	inc  %g1                                       
    the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;       
4000a194:	c4 26 20 44 	st  %g2, [ %i0 + 0x44 ]                        
    }                                                                 
                                                                      
    /*                                                                
     * Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING                 
     */                                                               
    the_rwlock->number_of_readers += 1;                               
4000a198:	10 80 00 09 	b  4000a1bc <_CORE_RWLock_Release+0x90>        
4000a19c:	c2 26 20 48 	st  %g1, [ %i0 + 0x48 ]                        
    /*                                                                
     * Now see if more readers can be let go.                         
     */                                                               
    while ( 1 ) {                                                     
      next = _Thread_queue_First( &the_rwlock->Wait_queue );          
      if ( !next ||                                                   
4000a1a0:	80 a0 60 01 	cmp  %g1, 1                                    
4000a1a4:	02 80 00 0b 	be  4000a1d0 <_CORE_RWLock_Release+0xa4>       <== NEVER TAKEN
4000a1a8:	90 10 00 18 	mov  %i0, %o0                                  
           next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE )
        return CORE_RWLOCK_SUCCESSFUL;                                
      the_rwlock->number_of_readers += 1;                             
4000a1ac:	c2 06 20 48 	ld  [ %i0 + 0x48 ], %g1                        
4000a1b0:	82 00 60 01 	inc  %g1                                       
      _Thread_queue_Extract( &the_rwlock->Wait_queue, next );         
4000a1b4:	40 00 08 dd 	call  4000c528 <_Thread_queue_Extract>         
4000a1b8:	c2 26 20 48 	st  %g1, [ %i0 + 0x48 ]                        
                                                                      
    /*                                                                
     * Now see if more readers can be let go.                         
     */                                                               
    while ( 1 ) {                                                     
      next = _Thread_queue_First( &the_rwlock->Wait_queue );          
4000a1bc:	40 00 09 2c 	call  4000c66c <_Thread_queue_First>           
4000a1c0:	90 10 00 18 	mov  %i0, %o0                                  
      if ( !next ||                                                   
4000a1c4:	92 92 20 00 	orcc  %o0, 0, %o1                              
4000a1c8:	32 bf ff f6 	bne,a   4000a1a0 <_CORE_RWLock_Release+0x74>   
4000a1cc:	c2 02 60 30 	ld  [ %o1 + 0x30 ], %g1                        
  }                                                                   
                                                                      
  /* indentation is to match _ISR_Disable at top */                   
                                                                      
  return CORE_RWLOCK_SUCCESSFUL;                                      
}                                                                     
4000a1d0:	81 c7 e0 08 	ret                                            
4000a1d4:	91 e8 20 00 	restore  %g0, 0, %o0                           
      _ISR_Enable( level );                                           
      executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;          
      return CORE_RWLOCK_SUCCESSFUL;                                  
    }                                                                 
    if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
	the_rwlock->number_of_readers -= 1;                                  
4000a1d8:	82 00 7f ff 	add  %g1, -1, %g1                              
	if ( the_rwlock->number_of_readers != 0 ) {                          
4000a1dc:	80 a0 60 00 	cmp  %g1, 0                                    
4000a1e0:	02 bf ff de 	be  4000a158 <_CORE_RWLock_Release+0x2c>       
4000a1e4:	c2 26 20 48 	st  %g1, [ %i0 + 0x48 ]                        
          /* must be unlocked again */                                
	  _ISR_Enable( level );                                              
4000a1e8:	7f ff e4 9d 	call  4000345c <sparc_enable_interrupts>       
4000a1ec:	b0 10 20 00 	clr  %i0                                       
          return CORE_RWLOCK_SUCCESSFUL;                              
4000a1f0:	30 80 00 05 	b,a   4000a204 <_CORE_RWLock_Release+0xd8>     
   *  If any thread is waiting, then we wait.                         
   */                                                                 
                                                                      
  _ISR_Disable( level );                                              
    if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){          
      _ISR_Enable( level );                                           
4000a1f4:	7f ff e4 9a 	call  4000345c <sparc_enable_interrupts>       
4000a1f8:	b0 10 20 00 	clr  %i0                                       
      executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;          
4000a1fc:	82 10 20 02 	mov  2, %g1                                    
4000a200:	c2 27 60 34 	st  %g1, [ %i5 + 0x34 ]                        
  }                                                                   
                                                                      
  /* indentation is to match _ISR_Disable at top */                   
                                                                      
  return CORE_RWLOCK_SUCCESSFUL;                                      
}                                                                     
4000a204:	81 c7 e0 08 	ret                                            
4000a208:	81 e8 00 00 	restore                                        
                                                                      
  next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );            
                                                                      
  if ( next ) {                                                       
    if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
      the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;     
4000a20c:	82 10 20 02 	mov  2, %g1                                    
4000a210:	c2 26 20 44 	st  %g1, [ %i0 + 0x44 ]                        
  }                                                                   
                                                                      
  /* indentation is to match _ISR_Disable at top */                   
                                                                      
  return CORE_RWLOCK_SUCCESSFUL;                                      
}                                                                     
4000a214:	81 c7 e0 08 	ret                                            
4000a218:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

4000a21c <_CORE_RWLock_Timeout>: void _CORE_RWLock_Timeout( Objects_Id id, void *ignored ) {
4000a21c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Thread_Control       *the_thread;                                   
  Objects_Locations     location;                                     
                                                                      
  the_thread = _Thread_Get( id, &location );                          
4000a220:	90 10 00 18 	mov  %i0, %o0                                  
4000a224:	40 00 06 e4 	call  4000bdb4 <_Thread_Get>                   
4000a228:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
4000a22c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4000a230:	80 a0 60 00 	cmp  %g1, 0                                    
4000a234:	12 80 00 08 	bne  4000a254 <_CORE_RWLock_Timeout+0x38>      <== NEVER TAKEN
4000a238:	01 00 00 00 	nop                                            
#if defined(RTEMS_MULTIPROCESSING)                                    
    case OBJECTS_REMOTE:  /* impossible */                            
#endif                                                                
      break;                                                          
    case OBJECTS_LOCAL:                                               
      _Thread_queue_Process_timeout( the_thread );                    
4000a23c:	40 00 09 4d 	call  4000c770 <_Thread_queue_Process_timeout> 
4000a240:	01 00 00 00 	nop                                            
   *                                                                  
   * This routine decrements the thread dispatch level.               
   */                                                                 
  RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
  {                                                                   
    uint32_t level = _Thread_Dispatch_disable_level;                  
4000a244:	03 10 00 69 	sethi  %hi(0x4001a400), %g1                    
4000a248:	c4 00 63 e0 	ld  [ %g1 + 0x3e0 ], %g2	! 4001a7e0 <_Thread_Dispatch_disable_level>
                                                                      
    --level;                                                          
4000a24c:	84 00 bf ff 	add  %g2, -1, %g2                              
    _Thread_Dispatch_disable_level = level;                           
4000a250:	c4 20 63 e0 	st  %g2, [ %g1 + 0x3e0 ]                       
4000a254:	81 c7 e0 08 	ret                                            
4000a258:	81 e8 00 00 	restore                                        
                                                                      

4000811c <_CORE_mutex_Seize>: Objects_Id _id, bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) {
4000811c:	9d e3 bf a0 	save  %sp, -96, %sp                            
   * This routine returns true if thread dispatch indicates           
   * that we are in a critical section.                               
   */                                                                 
  RTEMS_INLINE_ROUTINE bool _Thread_Dispatch_in_critical_section(void)
  {                                                                   
     if (  _Thread_Dispatch_disable_level == 0 )                      
40008120:	3b 10 00 7b 	sethi  %hi(0x4001ec00), %i5                    
40008124:	c2 07 62 c0 	ld  [ %i5 + 0x2c0 ], %g1	! 4001eec0 <_Thread_Dispatch_disable_level>
40008128:	80 a0 60 00 	cmp  %g1, 0                                    
4000812c:	02 80 00 1f 	be  400081a8 <_CORE_mutex_Seize+0x8c>          
40008130:	f8 27 a0 54 	st  %i4, [ %fp + 0x54 ]                        
  _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 
40008134:	80 a6 a0 00 	cmp  %i2, 0                                    
40008138:	02 80 00 2c 	be  400081e8 <_CORE_mutex_Seize+0xcc>          
4000813c:	90 10 00 18 	mov  %i0, %o0                                  
40008140:	03 10 00 7c 	sethi  %hi(0x4001f000), %g1                    
40008144:	c2 00 63 c8 	ld  [ %g1 + 0x3c8 ], %g1	! 4001f3c8 <_System_state_Current>
40008148:	80 a0 60 01 	cmp  %g1, 1                                    
4000814c:	38 80 00 2e 	bgu,a   40008204 <_CORE_mutex_Seize+0xe8>      
40008150:	90 10 20 00 	clr  %o0                                       
40008154:	40 00 14 6a 	call  4000d2fc <_CORE_mutex_Seize_interrupt_trylock>
40008158:	92 07 a0 54 	add  %fp, 0x54, %o1                            
4000815c:	80 a2 20 00 	cmp  %o0, 0                                    
40008160:	02 80 00 27 	be  400081fc <_CORE_mutex_Seize+0xe0>          <== ALWAYS TAKEN
40008164:	01 00 00 00 	nop                                            
   *                                                                  
   * This rountine increments the thread dispatch level               
   */                                                                 
  RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
  {                                                                   
    uint32_t level = _Thread_Dispatch_disable_level;                  
40008168:	c4 07 62 c0 	ld  [ %i5 + 0x2c0 ], %g2                       
4000816c:	03 10 00 7c 	sethi  %hi(0x4001f000), %g1                    
40008170:	c2 00 63 e0 	ld  [ %g1 + 0x3e0 ], %g1	! 4001f3e0 <_Per_CPU_Information+0x10>
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (      
  Thread_queue_Control *the_thread_queue                              
)                                                                     
{                                                                     
  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
40008174:	86 10 20 01 	mov  1, %g3                                    
40008178:	c6 26 20 30 	st  %g3, [ %i0 + 0x30 ]                        
4000817c:	f0 20 60 44 	st  %i0, [ %g1 + 0x44 ]                        
40008180:	f2 20 60 20 	st  %i1, [ %g1 + 0x20 ]                        
                                                                      
    ++level;                                                          
40008184:	82 00 a0 01 	add  %g2, 1, %g1                               
    _Thread_Dispatch_disable_level = level;                           
40008188:	c2 27 62 c0 	st  %g1, [ %i5 + 0x2c0 ]                       
4000818c:	7f ff e7 ca 	call  400020b4 <sparc_enable_interrupts>       
40008190:	d0 07 a0 54 	ld  [ %fp + 0x54 ], %o0                        
40008194:	90 10 00 18 	mov  %i0, %o0                                  
40008198:	7f ff ff ba 	call  40008080 <_CORE_mutex_Seize_interrupt_blocking>
4000819c:	92 10 00 1b 	mov  %i3, %o1                                  
400081a0:	81 c7 e0 08 	ret                                            
400081a4:	81 e8 00 00 	restore                                        
400081a8:	90 10 00 18 	mov  %i0, %o0                                  
400081ac:	40 00 14 54 	call  4000d2fc <_CORE_mutex_Seize_interrupt_trylock>
400081b0:	92 07 a0 54 	add  %fp, 0x54, %o1                            
400081b4:	80 a2 20 00 	cmp  %o0, 0                                    
400081b8:	02 bf ff fa 	be  400081a0 <_CORE_mutex_Seize+0x84>          
400081bc:	80 a6 a0 00 	cmp  %i2, 0                                    
400081c0:	12 bf ff ea 	bne  40008168 <_CORE_mutex_Seize+0x4c>         
400081c4:	01 00 00 00 	nop                                            
400081c8:	7f ff e7 bb 	call  400020b4 <sparc_enable_interrupts>       
400081cc:	d0 07 a0 54 	ld  [ %fp + 0x54 ], %o0                        
400081d0:	03 10 00 7c 	sethi  %hi(0x4001f000), %g1                    
400081d4:	c2 00 63 e0 	ld  [ %g1 + 0x3e0 ], %g1	! 4001f3e0 <_Per_CPU_Information+0x10>
400081d8:	84 10 20 01 	mov  1, %g2                                    
400081dc:	c4 20 60 34 	st  %g2, [ %g1 + 0x34 ]                        
400081e0:	81 c7 e0 08 	ret                                            
400081e4:	81 e8 00 00 	restore                                        
400081e8:	40 00 14 45 	call  4000d2fc <_CORE_mutex_Seize_interrupt_trylock>
400081ec:	92 07 a0 54 	add  %fp, 0x54, %o1                            
400081f0:	80 a2 20 00 	cmp  %o0, 0                                    
400081f4:	12 bf ff f5 	bne  400081c8 <_CORE_mutex_Seize+0xac>         <== NEVER TAKEN
400081f8:	01 00 00 00 	nop                                            
400081fc:	81 c7 e0 08 	ret                                            
40008200:	81 e8 00 00 	restore                                        
40008204:	92 10 20 00 	clr  %o1                                       
40008208:	40 00 01 c1 	call  4000890c <_Internal_error_Occurred>      
4000820c:	94 10 20 12 	mov  0x12, %o2                                 
                                                                      

4000838c <_CORE_semaphore_Surrender>: CORE_semaphore_Status _CORE_semaphore_Surrender( CORE_semaphore_Control *the_semaphore, Objects_Id id, CORE_semaphore_API_mp_support_callout api_semaphore_mp_support ) {
4000838c:	9d e3 bf a0 	save  %sp, -96, %sp                            
40008390:	ba 10 00 18 	mov  %i0, %i5                                  
  Thread_Control *the_thread;                                         
  ISR_Level       level;                                              
  CORE_semaphore_Status status;                                       
                                                                      
  status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;                          
40008394:	b0 10 20 00 	clr  %i0                                       
                                                                      
  if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
40008398:	40 00 07 a5 	call  4000a22c <_Thread_queue_Dequeue>         
4000839c:	90 10 00 1d 	mov  %i5, %o0                                  
400083a0:	80 a2 20 00 	cmp  %o0, 0                                    
400083a4:	02 80 00 04 	be  400083b4 <_CORE_semaphore_Surrender+0x28>  
400083a8:	01 00 00 00 	nop                                            
        status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;               
    _ISR_Enable( level );                                             
  }                                                                   
                                                                      
  return status;                                                      
}                                                                     
400083ac:	81 c7 e0 08 	ret                                            
400083b0:	81 e8 00 00 	restore                                        
    if ( !_Objects_Is_local_id( the_thread->Object.id ) )             
      (*api_semaphore_mp_support) ( the_thread, id );                 
#endif                                                                
                                                                      
  } else {                                                            
    _ISR_Disable( level );                                            
400083b4:	7f ff e7 3c 	call  400020a4 <sparc_disable_interrupts>      
400083b8:	01 00 00 00 	nop                                            
      if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
400083bc:	c2 07 60 48 	ld  [ %i5 + 0x48 ], %g1                        
400083c0:	c4 07 60 40 	ld  [ %i5 + 0x40 ], %g2                        
400083c4:	80 a0 40 02 	cmp  %g1, %g2                                  
400083c8:	1a 80 00 05 	bcc  400083dc <_CORE_semaphore_Surrender+0x50> <== NEVER TAKEN
400083cc:	b0 10 20 04 	mov  4, %i0                                    
        the_semaphore->count += 1;                                    
400083d0:	82 00 60 01 	inc  %g1                                       
{                                                                     
  Thread_Control *the_thread;                                         
  ISR_Level       level;                                              
  CORE_semaphore_Status status;                                       
                                                                      
  status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;                          
400083d4:	b0 10 20 00 	clr  %i0                                       
#endif                                                                
                                                                      
  } else {                                                            
    _ISR_Disable( level );                                            
      if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
        the_semaphore->count += 1;                                    
400083d8:	c2 27 60 48 	st  %g1, [ %i5 + 0x48 ]                        
      else                                                            
        status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;               
    _ISR_Enable( level );                                             
400083dc:	7f ff e7 36 	call  400020b4 <sparc_enable_interrupts>       
400083e0:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  return status;                                                      
}                                                                     
400083e4:	81 c7 e0 08 	ret                                            
400083e8:	81 e8 00 00 	restore                                        
                                                                      

40007f4c <_Chain_Initialize>: Chain_Control *the_chain, void *starting_address, size_t number_nodes, size_t node_size ) {
40007f4c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *current = head;                                         
  Chain_Node *next = starting_address;                                
                                                                      
  head->previous = NULL;                                              
40007f50:	c0 26 20 04 	clr  [ %i0 + 4 ]                               
  size_t         node_size                                            
)                                                                     
{                                                                     
  size_t count = number_nodes;                                        
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
40007f54:	ba 06 20 04 	add  %i0, 4, %i5                               
  Chain_Node *current = head;                                         
  Chain_Node *next = starting_address;                                
                                                                      
  head->previous = NULL;                                              
                                                                      
  while ( count-- ) {                                                 
40007f58:	80 a6 a0 00 	cmp  %i2, 0                                    
40007f5c:	02 80 00 13 	be  40007fa8 <_Chain_Initialize+0x5c>          <== NEVER TAKEN
40007f60:	92 06 bf ff 	add  %i2, -1, %o1                              
40007f64:	86 10 00 09 	mov  %o1, %g3                                  
40007f68:	82 10 00 19 	mov  %i1, %g1                                  
40007f6c:	84 10 00 18 	mov  %i0, %g2                                  
    current->next  = next;                                            
40007f70:	c2 20 80 00 	st  %g1, [ %g2 ]                               
    next->previous = current;                                         
40007f74:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
  Chain_Node *current = head;                                         
  Chain_Node *next = starting_address;                                
                                                                      
  head->previous = NULL;                                              
                                                                      
  while ( count-- ) {                                                 
40007f78:	86 00 ff ff 	add  %g3, -1, %g3                              
40007f7c:	84 10 00 01 	mov  %g1, %g2                                  
40007f80:	80 a0 ff ff 	cmp  %g3, -1                                   
40007f84:	12 bf ff fb 	bne  40007f70 <_Chain_Initialize+0x24>         
40007f88:	82 00 40 1b 	add  %g1, %i3, %g1                             
#include <rtems/system.h>                                             
#include <rtems/score/address.h>                                      
#include <rtems/score/chain.h>                                        
#include <rtems/score/isr.h>                                          
                                                                      
void _Chain_Initialize(                                               
40007f8c:	40 00 42 00 	call  4001878c <.umul>                         
40007f90:	90 10 00 1b 	mov  %i3, %o0                                  
40007f94:	90 06 40 08 	add  %i1, %o0, %o0                             
    current        = next;                                            
    next           = (Chain_Node *)                                   
                        _Addresses_Add_offset( (void *) next, node_size );
  }                                                                   
                                                                      
  current->next = tail;                                               
40007f98:	fa 22 00 00 	st  %i5, [ %o0 ]                               
  tail->previous = current;                                           
40007f9c:	d0 26 20 08 	st  %o0, [ %i0 + 8 ]                           
40007fa0:	81 c7 e0 08 	ret                                            
40007fa4:	81 e8 00 00 	restore                                        
)                                                                     
{                                                                     
  size_t count = number_nodes;                                        
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *current = head;                                         
40007fa8:	10 bf ff fc 	b  40007f98 <_Chain_Initialize+0x4c>           <== NOT EXECUTED
40007fac:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
                                                                      

40006ef8 <_Event_Surrender>: rtems_event_set event_in, Event_Control *event, Thread_blocking_operation_States *sync_state, States_Control wait_state ) {
40006ef8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_event_set seized_events;                                      
  rtems_option    option_set;                                         
                                                                      
  option_set = the_thread->Wait.option;                               
                                                                      
  _ISR_Disable( level );                                              
40006efc:	7f ff ec 6a 	call  400020a4 <sparc_disable_interrupts>      
40006f00:	fa 06 20 30 	ld  [ %i0 + 0x30 ], %i5                        
RTEMS_INLINE_ROUTINE void _Event_sets_Post(                           
  rtems_event_set  the_new_events,                                    
  rtems_event_set *the_event_set                                      
)                                                                     
{                                                                     
  *the_event_set |= the_new_events;                                   
40006f04:	c2 06 80 00 	ld  [ %i2 ], %g1                               
40006f08:	b2 16 40 01 	or  %i1, %g1, %i1                              
40006f0c:	f2 26 80 00 	st  %i1, [ %i2 ]                               
  _Event_sets_Post( event_in, &event->pending_events );               
  pending_events  = event->pending_events;                            
  event_condition = the_thread->Wait.count;                           
40006f10:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
  seized_events = _Event_sets_Get( pending_events, event_condition ); 
                                                                      
  /*                                                                  
   *  No events were seized in this operation                         
   */                                                                 
  if ( _Event_sets_Is_empty( seized_events ) ) {                      
40006f14:	84 8e 40 01 	andcc  %i1, %g1, %g2                           
40006f18:	02 80 00 35 	be  40006fec <_Event_Surrender+0xf4>           
40006f1c:	07 10 00 7c 	sethi  %hi(0x4001f000), %g3                    
                                                                      
  /*                                                                  
   *  If we are in an ISR and sending to the current thread, then     
   *  we have a critical section issue to deal with.                  
   */                                                                 
  if ( _ISR_Is_in_progress() &&                                       
40006f20:	86 10 e3 d0 	or  %g3, 0x3d0, %g3	! 4001f3d0 <_Per_CPU_Information>
40006f24:	c8 00 e0 08 	ld  [ %g3 + 8 ], %g4                           
40006f28:	80 a1 20 00 	cmp  %g4, 0                                    
40006f2c:	32 80 00 1c 	bne,a   40006f9c <_Event_Surrender+0xa4>       
40006f30:	c6 00 e0 10 	ld  [ %g3 + 0x10 ], %g3                        
RTEMS_INLINE_ROUTINE bool _States_Are_set (                           
  States_Control the_states,                                          
  States_Control mask                                                 
)                                                                     
{                                                                     
   return ( (the_states & mask) != STATES_READY);                     
40006f34:	c6 06 20 10 	ld  [ %i0 + 0x10 ], %g3                        
  }                                                                   
                                                                      
  /*                                                                  
   *  Otherwise, this is a normal send to another thread              
   */                                                                 
  if ( _States_Are_set( the_thread->current_state, wait_state ) ) {   
40006f38:	80 8f 00 03 	btst  %i4, %g3                                 
40006f3c:	02 80 00 2c 	be  40006fec <_Event_Surrender+0xf4>           
40006f40:	80 a0 40 02 	cmp  %g1, %g2                                  
    if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
40006f44:	02 80 00 04 	be  40006f54 <_Event_Surrender+0x5c>           
40006f48:	80 8f 60 02 	btst  2, %i5                                   
40006f4c:	02 80 00 28 	be  40006fec <_Event_Surrender+0xf4>           <== NEVER TAKEN
40006f50:	01 00 00 00 	nop                                            
      event->pending_events = _Event_sets_Clear(                      
        pending_events,                                               
        seized_events                                                 
      );                                                              
      the_thread->Wait.count = 0;                                     
      *(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
40006f54:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear(               
 rtems_event_set the_event_set,                                       
 rtems_event_set the_mask                                             
)                                                                     
{                                                                     
   return ( the_event_set & ~(the_mask) );                            
40006f58:	b2 2e 40 02 	andn  %i1, %g2, %i1                            
  /*                                                                  
   *  Otherwise, this is a normal send to another thread              
   */                                                                 
  if ( _States_Are_set( the_thread->current_state, wait_state ) ) {   
    if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
      event->pending_events = _Event_sets_Clear(                      
40006f5c:	f2 26 80 00 	st  %i1, [ %i2 ]                               
        pending_events,                                               
        seized_events                                                 
      );                                                              
      the_thread->Wait.count = 0;                                     
40006f60:	c0 26 20 24 	clr  [ %i0 + 0x24 ]                            
      *(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
40006f64:	c4 20 40 00 	st  %g2, [ %g1 ]                               
                                                                      
      _ISR_Flash( level );                                            
40006f68:	7f ff ec 53 	call  400020b4 <sparc_enable_interrupts>       
40006f6c:	01 00 00 00 	nop                                            
40006f70:	7f ff ec 4d 	call  400020a4 <sparc_disable_interrupts>      
40006f74:	01 00 00 00 	nop                                            
                                                                      
      if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {             
40006f78:	c2 06 20 50 	ld  [ %i0 + 0x50 ], %g1                        
40006f7c:	80 a0 60 02 	cmp  %g1, 2                                    
40006f80:	02 80 00 1d 	be  40006ff4 <_Event_Surrender+0xfc>           
40006f84:	82 10 20 03 	mov  3, %g1                                    
        _ISR_Enable( level );                                         
40006f88:	7f ff ec 4b 	call  400020b4 <sparc_enable_interrupts>       
40006f8c:	33 04 01 ff 	sethi  %hi(0x1007fc00), %i1                    
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Unblock (                           
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
  _Thread_Clear_state( the_thread, STATES_BLOCKED );                  
40006f90:	b2 16 63 f8 	or  %i1, 0x3f8, %i1	! 1007fff8 <RAM_SIZE+0xfc7fff8>
40006f94:	40 00 0a e0 	call  40009b14 <_Thread_Clear_state>           
40006f98:	81 e8 00 00 	restore                                        
                                                                      
  /*                                                                  
   *  If we are in an ISR and sending to the current thread, then     
   *  we have a critical section issue to deal with.                  
   */                                                                 
  if ( _ISR_Is_in_progress() &&                                       
40006f9c:	80 a6 00 03 	cmp  %i0, %g3                                  
40006fa0:	32 bf ff e6 	bne,a   40006f38 <_Event_Surrender+0x40>       
40006fa4:	c6 06 20 10 	ld  [ %i0 + 0x10 ], %g3                        
       _Thread_Is_executing( the_thread ) &&                          
       ((*sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||         
40006fa8:	c6 06 c0 00 	ld  [ %i3 ], %g3                               
40006fac:	86 00 ff ff 	add  %g3, -1, %g3                              
  /*                                                                  
   *  If we are in an ISR and sending to the current thread, then     
   *  we have a critical section issue to deal with.                  
   */                                                                 
  if ( _ISR_Is_in_progress() &&                                       
       _Thread_Is_executing( the_thread ) &&                          
40006fb0:	80 a0 e0 01 	cmp  %g3, 1                                    
40006fb4:	38 bf ff e1 	bgu,a   40006f38 <_Event_Surrender+0x40>       
40006fb8:	c6 06 20 10 	ld  [ %i0 + 0x10 ], %g3                        
       ((*sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||         
        (*sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
    if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
40006fbc:	80 a0 40 02 	cmp  %g1, %g2                                  
40006fc0:	02 80 00 04 	be  40006fd0 <_Event_Surrender+0xd8>           
40006fc4:	80 8f 60 02 	btst  2, %i5                                   
40006fc8:	02 80 00 09 	be  40006fec <_Event_Surrender+0xf4>           <== NEVER TAKEN
40006fcc:	01 00 00 00 	nop                                            
      event->pending_events = _Event_sets_Clear(                      
        pending_events,                                               
        seized_events                                                 
      );                                                              
      the_thread->Wait.count = 0;                                     
      *(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
40006fd0:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
40006fd4:	b2 2e 40 02 	andn  %i1, %g2, %i1                            
  if ( _ISR_Is_in_progress() &&                                       
       _Thread_Is_executing( the_thread ) &&                          
       ((*sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||         
        (*sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
    if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
      event->pending_events = _Event_sets_Clear(                      
40006fd8:	f2 26 80 00 	st  %i1, [ %i2 ]                               
        pending_events,                                               
        seized_events                                                 
      );                                                              
      the_thread->Wait.count = 0;                                     
40006fdc:	c0 26 20 24 	clr  [ %i0 + 0x24 ]                            
      *(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
40006fe0:	c4 20 40 00 	st  %g2, [ %g1 ]                               
      *sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;              
40006fe4:	82 10 20 03 	mov  3, %g1                                    
40006fe8:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
        _Thread_Unblock( the_thread );                                
      }                                                               
      return;                                                         
    }                                                                 
  }                                                                   
  _ISR_Enable( level );                                               
40006fec:	7f ff ec 32 	call  400020b4 <sparc_enable_interrupts>       
40006ff0:	91 e8 00 08 	restore  %g0, %o0, %o0                         
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(                       
  Watchdog_Control *the_watchdog                                      
)                                                                     
{                                                                     
                                                                      
  the_watchdog->state = WATCHDOG_REMOVE_IT;                           
40006ff4:	c2 26 20 50 	st  %g1, [ %i0 + 0x50 ]                        
      if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {             
        _ISR_Enable( level );                                         
        _Thread_Unblock( the_thread );                                
      } else {                                                        
        _Watchdog_Deactivate( &the_thread->Timer );                   
        _ISR_Enable( level );                                         
40006ff8:	7f ff ec 2f 	call  400020b4 <sparc_enable_interrupts>       
40006ffc:	33 04 01 ff 	sethi  %hi(0x1007fc00), %i1                    
        (void) _Watchdog_Remove( &the_thread->Timer );                
40007000:	40 00 0f 4d 	call  4000ad34 <_Watchdog_Remove>              
40007004:	90 06 20 48 	add  %i0, 0x48, %o0                            
40007008:	b2 16 63 f8 	or  %i1, 0x3f8, %i1                            
4000700c:	40 00 0a c2 	call  40009b14 <_Thread_Clear_state>           
40007010:	81 e8 00 00 	restore                                        
                                                                      

40007014 <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *arg ) {
40007014:	9d e3 bf 98 	save  %sp, -104, %sp                           
  ISR_Level                         level;                            
  Thread_blocking_operation_States *sync_state;                       
                                                                      
  sync_state = arg;                                                   
                                                                      
  the_thread = _Thread_Get( id, &location );                          
40007018:	90 10 00 18 	mov  %i0, %o0                                  
4000701c:	40 00 0b b7 	call  40009ef8 <_Thread_Get>                   
40007020:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
40007024:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40007028:	80 a0 60 00 	cmp  %g1, 0                                    
4000702c:	12 80 00 15 	bne  40007080 <_Event_Timeout+0x6c>            <== NEVER TAKEN
40007030:	ba 10 00 08 	mov  %o0, %i5                                  
       *                                                              
       *  If it is not satisfied, then it is "nothing happened" and   
       *  this is the "timeout" transition.  After a request is satisfied,
       *  a timeout is not allowed to occur.                          
       */                                                             
      _ISR_Disable( level );                                          
40007034:	7f ff ec 1c 	call  400020a4 <sparc_disable_interrupts>      
40007038:	01 00 00 00 	nop                                            
                                                                      
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (                      
  const Thread_Control *the_thread                                    
)                                                                     
{                                                                     
  return ( the_thread == _Thread_Executing );                         
4000703c:	03 10 00 7c 	sethi  %hi(0x4001f000), %g1                    
            return;                                                   
          }                                                           
        #endif                                                        
                                                                      
        the_thread->Wait.count = 0;                                   
        if ( _Thread_Is_executing( the_thread ) ) {                   
40007040:	c2 00 63 e0 	ld  [ %g1 + 0x3e0 ], %g1	! 4001f3e0 <_Per_CPU_Information+0x10>
40007044:	80 a7 40 01 	cmp  %i5, %g1                                  
40007048:	02 80 00 10 	be  40007088 <_Event_Timeout+0x74>             
4000704c:	c0 27 60 24 	clr  [ %i5 + 0x24 ]                            
          if ( *sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
            *sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;          
        }                                                             
                                                                      
        the_thread->Wait.return_code = RTEMS_TIMEOUT;                 
40007050:	82 10 20 06 	mov  6, %g1                                    
40007054:	c2 27 60 34 	st  %g1, [ %i5 + 0x34 ]                        
      _ISR_Enable( level );                                           
40007058:	7f ff ec 17 	call  400020b4 <sparc_enable_interrupts>       
4000705c:	01 00 00 00 	nop                                            
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Unblock (                           
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
  _Thread_Clear_state( the_thread, STATES_BLOCKED );                  
40007060:	90 10 00 1d 	mov  %i5, %o0                                  
40007064:	13 04 01 ff 	sethi  %hi(0x1007fc00), %o1                    
40007068:	40 00 0a ab 	call  40009b14 <_Thread_Clear_state>           
4000706c:	92 12 63 f8 	or  %o1, 0x3f8, %o1	! 1007fff8 <RAM_SIZE+0xfc7fff8>
   *                                                                  
   * This routine decrements the thread dispatch level.               
   */                                                                 
  RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
  {                                                                   
    uint32_t level = _Thread_Dispatch_disable_level;                  
40007070:	03 10 00 7b 	sethi  %hi(0x4001ec00), %g1                    
40007074:	c4 00 62 c0 	ld  [ %g1 + 0x2c0 ], %g2	! 4001eec0 <_Thread_Dispatch_disable_level>
                                                                      
    --level;                                                          
40007078:	84 00 bf ff 	add  %g2, -1, %g2                              
    _Thread_Dispatch_disable_level = level;                           
4000707c:	c4 20 62 c0 	st  %g2, [ %g1 + 0x2c0 ]                       
40007080:	81 c7 e0 08 	ret                                            
40007084:	81 e8 00 00 	restore                                        
          }                                                           
        #endif                                                        
                                                                      
        the_thread->Wait.count = 0;                                   
        if ( _Thread_Is_executing( the_thread ) ) {                   
          if ( *sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
40007088:	c2 06 40 00 	ld  [ %i1 ], %g1                               
4000708c:	80 a0 60 01 	cmp  %g1, 1                                    
40007090:	12 bf ff f1 	bne  40007054 <_Event_Timeout+0x40>            
40007094:	82 10 20 06 	mov  6, %g1                                    
            *sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;          
40007098:	82 10 20 02 	mov  2, %g1                                    
4000709c:	10 bf ff ed 	b  40007050 <_Event_Timeout+0x3c>              
400070a0:	c2 26 40 00 	st  %g1, [ %i1 ]                               
                                                                      

4000d45c <_Heap_Allocate_aligned_with_boundary>: Heap_Control *heap, uintptr_t alloc_size, uintptr_t alignment, uintptr_t boundary ) {
4000d45c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Heap_Statistics *const stats = &heap->stats;                        
  uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE
4000d460:	a2 06 60 04 	add  %i1, 4, %l1                               
  Heap_Control *heap,                                                 
  uintptr_t alloc_size,                                               
  uintptr_t alignment,                                                
  uintptr_t boundary                                                  
)                                                                     
{                                                                     
4000d464:	a0 10 00 18 	mov  %i0, %l0                                  
  Heap_Block *block = NULL;                                           
  uintptr_t alloc_begin = 0;                                          
  uint32_t search_count = 0;                                          
  bool search_again = false;                                          
                                                                      
  if ( block_size_floor < alloc_size ) {                              
4000d468:	80 a6 40 11 	cmp  %i1, %l1                                  
4000d46c:	18 80 00 85 	bgu  4000d680 <_Heap_Allocate_aligned_with_boundary+0x224>
4000d470:	ea 06 20 10 	ld  [ %i0 + 0x10 ], %l5                        
    /* Integer overflow occured */                                    
    return NULL;                                                      
  }                                                                   
                                                                      
  if ( boundary != 0 ) {                                              
4000d474:	80 a6 e0 00 	cmp  %i3, 0                                    
4000d478:	12 80 00 7c 	bne  4000d668 <_Heap_Allocate_aligned_with_boundary+0x20c>
4000d47c:	80 a6 40 1b 	cmp  %i1, %i3                                  
  return &heap->free_list;                                            
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{                                                                     
  return _Heap_Free_list_head(heap)->next;                            
4000d480:	fa 04 20 08 	ld  [ %l0 + 8 ], %i5                           
                                                                      
  do {                                                                
    Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );  
                                                                      
    block = _Heap_Free_list_first( heap );                            
    while ( block != free_list_tail ) {                               
4000d484:	80 a4 00 1d 	cmp  %l0, %i5                                  
4000d488:	02 80 00 18 	be  4000d4e8 <_Heap_Allocate_aligned_with_boundary+0x8c>
4000d48c:	b8 10 20 00 	clr  %i4                                       
                                                                      
  uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
  uintptr_t const alloc_begin_ceiling = block_end - min_block_size    
    + HEAP_BLOCK_HEADER_SIZE + page_size - 1;                         
                                                                      
  uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;                 
4000d490:	ac 10 20 04 	mov  4, %l6                                    
  uintptr_t const block_begin = (uintptr_t) block;                    
  uintptr_t const block_size = _Heap_Block_size( block );             
  uintptr_t const block_end = block_begin + block_size;               
                                                                      
  uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
  uintptr_t const alloc_begin_ceiling = block_end - min_block_size    
4000d494:	ae 05 60 07 	add  %l5, 7, %l7                               
    + HEAP_BLOCK_HEADER_SIZE + page_size - 1;                         
                                                                      
  uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;                 
4000d498:	ac 25 80 19 	sub  %l6, %i1, %l6                             
4000d49c:	10 80 00 0b 	b  4000d4c8 <_Heap_Allocate_aligned_with_boundary+0x6c>
4000d4a0:	ec 27 bf fc 	st  %l6, [ %fp + -4 ]                          
       * The HEAP_PREV_BLOCK_USED flag is always set in the block size_and_flag
       * field.  Thus the value is about one unit larger than the real block
       * size.  The greater than operator takes this into account.    
       */                                                             
      if ( block->size_and_flag > block_size_floor ) {                
        if ( alignment == 0 ) {                                       
4000d4a4:	12 80 00 18 	bne  4000d504 <_Heap_Allocate_aligned_with_boundary+0xa8>
4000d4a8:	b0 07 60 08 	add  %i5, 8, %i0                               
      }                                                               
                                                                      
      /* Statistics */                                                
      ++search_count;                                                 
                                                                      
      if ( alloc_begin != 0 ) {                                       
4000d4ac:	80 a6 20 00 	cmp  %i0, 0                                    
4000d4b0:	12 80 00 4d 	bne  4000d5e4 <_Heap_Allocate_aligned_with_boundary+0x188><== ALWAYS TAKEN
4000d4b4:	b8 07 20 01 	inc  %i4                                       
        break;                                                        
      }                                                               
                                                                      
      block = block->next;                                            
4000d4b8:	fa 07 60 08 	ld  [ %i5 + 8 ], %i5                           
                                                                      
  do {                                                                
    Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );  
                                                                      
    block = _Heap_Free_list_first( heap );                            
    while ( block != free_list_tail ) {                               
4000d4bc:	80 a4 00 1d 	cmp  %l0, %i5                                  
4000d4c0:	22 80 00 0b 	be,a   4000d4ec <_Heap_Allocate_aligned_with_boundary+0x90>
4000d4c4:	c2 04 20 44 	ld  [ %l0 + 0x44 ], %g1                        
      /*                                                              
       * The HEAP_PREV_BLOCK_USED flag is always set in the block size_and_flag
       * field.  Thus the value is about one unit larger than the real block
       * size.  The greater than operator takes this into account.    
       */                                                             
      if ( block->size_and_flag > block_size_floor ) {                
4000d4c8:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
4000d4cc:	80 a4 40 01 	cmp  %l1, %g1                                  
4000d4d0:	0a bf ff f5 	bcs  4000d4a4 <_Heap_Allocate_aligned_with_boundary+0x48>
4000d4d4:	80 a6 a0 00 	cmp  %i2, 0                                    
                                                                      
      if ( alloc_begin != 0 ) {                                       
        break;                                                        
      }                                                               
                                                                      
      block = block->next;                                            
4000d4d8:	fa 07 60 08 	ld  [ %i5 + 8 ], %i5                           
                                                                      
  do {                                                                
    Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );  
                                                                      
    block = _Heap_Free_list_first( heap );                            
    while ( block != free_list_tail ) {                               
4000d4dc:	80 a4 00 1d 	cmp  %l0, %i5                                  
4000d4e0:	12 bf ff fa 	bne  4000d4c8 <_Heap_Allocate_aligned_with_boundary+0x6c>
4000d4e4:	b8 07 20 01 	inc  %i4                                       
      boundary                                                        
    );                                                                
  }                                                                   
                                                                      
  /* Statistics */                                                    
  if ( stats->max_search < search_count ) {                           
4000d4e8:	c2 04 20 44 	ld  [ %l0 + 0x44 ], %g1                        
4000d4ec:	80 a0 40 1c 	cmp  %g1, %i4                                  
4000d4f0:	1a 80 00 03 	bcc  4000d4fc <_Heap_Allocate_aligned_with_boundary+0xa0>
4000d4f4:	b0 10 20 00 	clr  %i0                                       
    stats->max_search = search_count;                                 
4000d4f8:	f8 24 20 44 	st  %i4, [ %l0 + 0x44 ]                        
  }                                                                   
                                                                      
  return (void *) alloc_begin;                                        
4000d4fc:	81 c7 e0 08 	ret                                            
4000d500:	81 e8 00 00 	restore                                        
  uintptr_t alignment,                                                
  uintptr_t boundary                                                  
)                                                                     
{                                                                     
  uintptr_t const page_size = heap->page_size;                        
  uintptr_t const min_block_size = heap->min_block_size;              
4000d504:	e8 04 20 14 	ld  [ %l0 + 0x14 ], %l4                        
    - HEAP_BLOCK_HEADER_SIZE);                                        
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;                
4000d508:	a4 08 7f fe 	and  %g1, -2, %l2                              
  uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
  uintptr_t const alloc_begin_ceiling = block_end - min_block_size    
    + HEAP_BLOCK_HEADER_SIZE + page_size - 1;                         
                                                                      
  uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;                 
  uintptr_t alloc_begin = alloc_end - alloc_size;                     
4000d50c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
  uintptr_t const block_size = _Heap_Block_size( block );             
  uintptr_t const block_end = block_begin + block_size;               
                                                                      
  uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
  uintptr_t const alloc_begin_ceiling = block_end - min_block_size    
    + HEAP_BLOCK_HEADER_SIZE + page_size - 1;                         
4000d510:	84 25 c0 14 	sub  %l7, %l4, %g2                             
  uintptr_t const page_size = heap->page_size;                        
  uintptr_t const min_block_size = heap->min_block_size;              
                                                                      
  uintptr_t const block_begin = (uintptr_t) block;                    
  uintptr_t const block_size = _Heap_Block_size( block );             
  uintptr_t const block_end = block_begin + block_size;               
4000d514:	a4 07 40 12 	add  %i5, %l2, %l2                             
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(                      
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return value - (value % alignment);                                 
4000d518:	92 10 00 1a 	mov  %i2, %o1                                  
  uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
  uintptr_t const alloc_begin_ceiling = block_end - min_block_size    
    + HEAP_BLOCK_HEADER_SIZE + page_size - 1;                         
                                                                      
  uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;                 
  uintptr_t alloc_begin = alloc_end - alloc_size;                     
4000d51c:	b0 00 40 12 	add  %g1, %l2, %i0                             
  uintptr_t const block_begin = (uintptr_t) block;                    
  uintptr_t const block_size = _Heap_Block_size( block );             
  uintptr_t const block_end = block_begin + block_size;               
                                                                      
  uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
  uintptr_t const alloc_begin_ceiling = block_end - min_block_size    
4000d520:	a4 00 80 12 	add  %g2, %l2, %l2                             
4000d524:	40 00 2d 80 	call  40018b24 <.urem>                         
4000d528:	90 10 00 18 	mov  %i0, %o0                                  
4000d52c:	b0 26 00 08 	sub  %i0, %o0, %i0                             
  uintptr_t alloc_begin = alloc_end - alloc_size;                     
                                                                      
  alloc_begin = _Heap_Align_down( alloc_begin, alignment );           
                                                                      
  /* Ensure that the we have a valid new block at the end */          
  if ( alloc_begin > alloc_begin_ceiling ) {                          
4000d530:	80 a4 80 18 	cmp  %l2, %i0                                  
4000d534:	1a 80 00 06 	bcc  4000d54c <_Heap_Allocate_aligned_with_boundary+0xf0>
4000d538:	a6 07 60 08 	add  %i5, 8, %l3                               
4000d53c:	90 10 00 12 	mov  %l2, %o0                                  
4000d540:	40 00 2d 79 	call  40018b24 <.urem>                         
4000d544:	92 10 00 1a 	mov  %i2, %o1                                  
4000d548:	b0 24 80 08 	sub  %l2, %o0, %i0                             
  }                                                                   
                                                                      
  alloc_end = alloc_begin + alloc_size;                               
                                                                      
  /* Ensure boundary constaint */                                     
  if ( boundary != 0 ) {                                              
4000d54c:	80 a6 e0 00 	cmp  %i3, 0                                    
4000d550:	02 80 00 37 	be  4000d62c <_Heap_Allocate_aligned_with_boundary+0x1d0>
4000d554:	80 a4 c0 18 	cmp  %l3, %i0                                  
  /* Ensure that the we have a valid new block at the end */          
  if ( alloc_begin > alloc_begin_ceiling ) {                          
    alloc_begin = _Heap_Align_down( alloc_begin_ceiling, alignment ); 
  }                                                                   
                                                                      
  alloc_end = alloc_begin + alloc_size;                               
4000d558:	86 06 00 19 	add  %i0, %i1, %g3                             
4000d55c:	92 10 00 1b 	mov  %i3, %o1                                  
4000d560:	90 10 00 03 	mov  %g3, %o0                                  
4000d564:	40 00 2d 70 	call  40018b24 <.urem>                         
4000d568:	c6 27 bf f8 	st  %g3, [ %fp + -8 ]                          
4000d56c:	c6 07 bf f8 	ld  [ %fp + -8 ], %g3                          
4000d570:	90 20 c0 08 	sub  %g3, %o0, %o0                             
  /* Ensure boundary constaint */                                     
  if ( boundary != 0 ) {                                              
    uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;  
    uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
                                                                      
    while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
4000d574:	80 a6 00 08 	cmp  %i0, %o0                                  
4000d578:	1a 80 00 2c 	bcc  4000d628 <_Heap_Allocate_aligned_with_boundary+0x1cc>
4000d57c:	a4 04 c0 19 	add  %l3, %i1, %l2                             
4000d580:	80 a2 00 03 	cmp  %o0, %g3                                  
4000d584:	2a 80 00 12 	bcs,a   4000d5cc <_Heap_Allocate_aligned_with_boundary+0x170>
4000d588:	80 a4 80 08 	cmp  %l2, %o0                                  
      boundary_line = _Heap_Align_down( alloc_end, boundary );        
    }                                                                 
  }                                                                   
                                                                      
  /* Ensure that the we have a valid new block at the beginning */    
  if ( alloc_begin >= alloc_begin_floor ) {                           
4000d58c:	10 80 00 28 	b  4000d62c <_Heap_Allocate_aligned_with_boundary+0x1d0>
4000d590:	80 a4 c0 18 	cmp  %l3, %i0                                  
4000d594:	92 10 00 1a 	mov  %i2, %o1                                  
4000d598:	40 00 2d 63 	call  40018b24 <.urem>                         
4000d59c:	90 10 00 18 	mov  %i0, %o0                                  
4000d5a0:	92 10 00 1b 	mov  %i3, %o1                                  
4000d5a4:	b0 26 00 08 	sub  %i0, %o0, %i0                             
      if ( boundary_line < boundary_floor ) {                         
        return 0;                                                     
      }                                                               
      alloc_begin = boundary_line - alloc_size;                       
      alloc_begin = _Heap_Align_down( alloc_begin, alignment );       
      alloc_end = alloc_begin + alloc_size;                           
4000d5a8:	ac 06 00 19 	add  %i0, %i1, %l6                             
4000d5ac:	40 00 2d 5e 	call  40018b24 <.urem>                         
4000d5b0:	90 10 00 16 	mov  %l6, %o0                                  
4000d5b4:	90 25 80 08 	sub  %l6, %o0, %o0                             
  /* Ensure boundary constaint */                                     
  if ( boundary != 0 ) {                                              
    uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;  
    uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
                                                                      
    while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
4000d5b8:	80 a2 00 16 	cmp  %o0, %l6                                  
4000d5bc:	1a 80 00 1b 	bcc  4000d628 <_Heap_Allocate_aligned_with_boundary+0x1cc>
4000d5c0:	80 a6 00 08 	cmp  %i0, %o0                                  
4000d5c4:	1a 80 00 19 	bcc  4000d628 <_Heap_Allocate_aligned_with_boundary+0x1cc>
4000d5c8:	80 a4 80 08 	cmp  %l2, %o0                                  
      if ( boundary_line < boundary_floor ) {                         
4000d5cc:	08 bf ff f2 	bleu  4000d594 <_Heap_Allocate_aligned_with_boundary+0x138>
4000d5d0:	b0 22 00 19 	sub  %o0, %i1, %i0                             
        return 0;                                                     
4000d5d4:	b0 10 20 00 	clr  %i0                                       
      }                                                               
                                                                      
      /* Statistics */                                                
      ++search_count;                                                 
                                                                      
      if ( alloc_begin != 0 ) {                                       
4000d5d8:	80 a6 20 00 	cmp  %i0, 0                                    
4000d5dc:	02 bf ff b7 	be  4000d4b8 <_Heap_Allocate_aligned_with_boundary+0x5c><== ALWAYS TAKEN
4000d5e0:	b8 07 20 01 	inc  %i4                                       
    search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
  } while ( search_again );                                           
                                                                      
  if ( alloc_begin != 0 ) {                                           
    /* Statistics */                                                  
    ++stats->allocs;                                                  
4000d5e4:	c6 04 20 48 	ld  [ %l0 + 0x48 ], %g3                        
    stats->searches += search_count;                                  
4000d5e8:	c4 04 20 4c 	ld  [ %l0 + 0x4c ], %g2                        
    search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
  } while ( search_again );                                           
                                                                      
  if ( alloc_begin != 0 ) {                                           
    /* Statistics */                                                  
    ++stats->allocs;                                                  
4000d5ec:	86 00 e0 01 	inc  %g3                                       
    stats->searches += search_count;                                  
4000d5f0:	84 00 80 1c 	add  %g2, %i4, %g2                             
    search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
  } while ( search_again );                                           
                                                                      
  if ( alloc_begin != 0 ) {                                           
    /* Statistics */                                                  
    ++stats->allocs;                                                  
4000d5f4:	c6 24 20 48 	st  %g3, [ %l0 + 0x48 ]                        
    stats->searches += search_count;                                  
4000d5f8:	c4 24 20 4c 	st  %g2, [ %l0 + 0x4c ]                        
                                                                      
    block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
4000d5fc:	90 10 00 10 	mov  %l0, %o0                                  
4000d600:	92 10 00 1d 	mov  %i5, %o1                                  
4000d604:	94 10 00 18 	mov  %i0, %o2                                  
4000d608:	7f ff ec 75 	call  400087dc <_Heap_Block_allocate>          
4000d60c:	96 10 00 19 	mov  %i1, %o3                                  
      boundary                                                        
    );                                                                
  }                                                                   
                                                                      
  /* Statistics */                                                    
  if ( stats->max_search < search_count ) {                           
4000d610:	c2 04 20 44 	ld  [ %l0 + 0x44 ], %g1                        
4000d614:	80 a0 40 1c 	cmp  %g1, %i4                                  
4000d618:	2a bf ff b9 	bcs,a   4000d4fc <_Heap_Allocate_aligned_with_boundary+0xa0>
4000d61c:	f8 24 20 44 	st  %i4, [ %l0 + 0x44 ]                        
    stats->max_search = search_count;                                 
  }                                                                   
                                                                      
  return (void *) alloc_begin;                                        
}                                                                     
4000d620:	81 c7 e0 08 	ret                                            
4000d624:	81 e8 00 00 	restore                                        
      boundary_line = _Heap_Align_down( alloc_end, boundary );        
    }                                                                 
  }                                                                   
                                                                      
  /* Ensure that the we have a valid new block at the beginning */    
  if ( alloc_begin >= alloc_begin_floor ) {                           
4000d628:	80 a4 c0 18 	cmp  %l3, %i0                                  
4000d62c:	18 bf ff ea 	bgu  4000d5d4 <_Heap_Allocate_aligned_with_boundary+0x178>
4000d630:	82 10 3f f8 	mov  -8, %g1                                   
4000d634:	90 10 00 18 	mov  %i0, %o0                                  
4000d638:	a4 20 40 1d 	sub  %g1, %i5, %l2                             
4000d63c:	92 10 00 15 	mov  %l5, %o1                                  
4000d640:	40 00 2d 39 	call  40018b24 <.urem>                         
4000d644:	a4 04 80 18 	add  %l2, %i0, %l2                             
    uintptr_t const alloc_block_begin =                               
      (uintptr_t) _Heap_Block_of_alloc_area( alloc_begin, page_size );
    uintptr_t const free_size = alloc_block_begin - block_begin;      
                                                                      
    if ( free_size >= min_block_size || free_size == 0 ) {            
4000d648:	90 a4 80 08 	subcc  %l2, %o0, %o0                           
4000d64c:	02 bf ff 99 	be  4000d4b0 <_Heap_Allocate_aligned_with_boundary+0x54>
4000d650:	80 a6 20 00 	cmp  %i0, 0                                    
4000d654:	80 a2 00 14 	cmp  %o0, %l4                                  
4000d658:	1a bf ff 96 	bcc  4000d4b0 <_Heap_Allocate_aligned_with_boundary+0x54>
4000d65c:	80 a6 20 00 	cmp  %i0, 0                                    
    uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;  
    uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
                                                                      
    while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
      if ( boundary_line < boundary_floor ) {                         
        return 0;                                                     
4000d660:	10 bf ff de 	b  4000d5d8 <_Heap_Allocate_aligned_with_boundary+0x17c>
4000d664:	b0 10 20 00 	clr  %i0                                       
    /* Integer overflow occured */                                    
    return NULL;                                                      
  }                                                                   
                                                                      
  if ( boundary != 0 ) {                                              
    if ( boundary < alloc_size ) {                                    
4000d668:	18 80 00 06 	bgu  4000d680 <_Heap_Allocate_aligned_with_boundary+0x224>
4000d66c:	80 a6 a0 00 	cmp  %i2, 0                                    
      return NULL;                                                    
    }                                                                 
                                                                      
    if ( alignment == 0 ) {                                           
4000d670:	22 bf ff 84 	be,a   4000d480 <_Heap_Allocate_aligned_with_boundary+0x24>
4000d674:	b4 10 00 15 	mov  %l5, %i2                                  
  return &heap->free_list;                                            
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{                                                                     
  return _Heap_Free_list_head(heap)->next;                            
4000d678:	10 bf ff 83 	b  4000d484 <_Heap_Allocate_aligned_with_boundary+0x28>
4000d67c:	fa 04 20 08 	ld  [ %l0 + 8 ], %i5                           
  uint32_t search_count = 0;                                          
  bool search_again = false;                                          
                                                                      
  if ( block_size_floor < alloc_size ) {                              
    /* Integer overflow occured */                                    
    return NULL;                                                      
4000d680:	81 c7 e0 08 	ret                                            
4000d684:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

4000d29c <_Heap_Extend>: Heap_Control *heap, void *extend_area_begin_ptr, uintptr_t extend_area_size, uintptr_t unused __attribute__((unused)) ) {
4000d29c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Heap_Block *start_block = first_block;                              
  Heap_Block *merge_below_block = NULL;                               
  Heap_Block *merge_above_block = NULL;                               
  Heap_Block *link_below_block = NULL;                                
  Heap_Block *link_above_block = NULL;                                
  Heap_Block *extend_first_block = NULL;                              
4000d2a0:	c0 27 bf f8 	clr  [ %fp + -8 ]                              
  Heap_Block *extend_last_block = NULL;                               
4000d2a4:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
  Heap_Control *heap,                                                 
  void *extend_area_begin_ptr,                                        
  uintptr_t extend_area_size,                                         
  uintptr_t unused __attribute__((unused))                            
)                                                                     
{                                                                     
4000d2a8:	b8 10 00 18 	mov  %i0, %i4                                  
  Heap_Statistics *const stats = &heap->stats;                        
  Heap_Block *const first_block = heap->first_block;                  
4000d2ac:	e2 06 20 20 	ld  [ %i0 + 0x20 ], %l1                        
  Heap_Block *extend_first_block = NULL;                              
  Heap_Block *extend_last_block = NULL;                               
  uintptr_t const page_size = heap->page_size;                        
  uintptr_t const min_block_size = heap->min_block_size;              
  uintptr_t const extend_area_begin = (uintptr_t) extend_area_begin_ptr;
  uintptr_t const extend_area_end = extend_area_begin + extend_area_size;
4000d2b0:	a0 06 40 1a 	add  %i1, %i2, %l0                             
  Heap_Block *merge_above_block = NULL;                               
  Heap_Block *link_below_block = NULL;                                
  Heap_Block *link_above_block = NULL;                                
  Heap_Block *extend_first_block = NULL;                              
  Heap_Block *extend_last_block = NULL;                               
  uintptr_t const page_size = heap->page_size;                        
4000d2b4:	e4 06 20 10 	ld  [ %i0 + 0x10 ], %l2                        
  uintptr_t const min_block_size = heap->min_block_size;              
4000d2b8:	d6 06 20 14 	ld  [ %i0 + 0x14 ], %o3                        
  uintptr_t const free_size = stats->free_size;                       
  uintptr_t extend_first_block_size = 0;                              
  uintptr_t extended_size = 0;                                        
  bool extend_area_ok = false;                                        
                                                                      
  if ( extend_area_end < extend_area_begin ) {                        
4000d2bc:	80 a6 40 10 	cmp  %i1, %l0                                  
4000d2c0:	08 80 00 04 	bleu  4000d2d0 <_Heap_Extend+0x34>             
4000d2c4:	f0 06 20 30 	ld  [ %i0 + 0x30 ], %i0                        
    return 0;                                                         
4000d2c8:	81 c7 e0 08 	ret                                            
4000d2cc:	91 e8 20 00 	restore  %g0, 0, %o0                           
  }                                                                   
                                                                      
  extend_area_ok = _Heap_Get_first_and_last_block(                    
4000d2d0:	90 10 00 19 	mov  %i1, %o0                                  
4000d2d4:	92 10 00 1a 	mov  %i2, %o1                                  
4000d2d8:	94 10 00 12 	mov  %l2, %o2                                  
4000d2dc:	98 07 bf f8 	add  %fp, -8, %o4                              
4000d2e0:	7f ff ec 06 	call  400082f8 <_Heap_Get_first_and_last_block>
4000d2e4:	9a 07 bf fc 	add  %fp, -4, %o5                              
    page_size,                                                        
    min_block_size,                                                   
    &extend_first_block,                                              
    &extend_last_block                                                
  );                                                                  
  if (!extend_area_ok ) {                                             
4000d2e8:	80 8a 20 ff 	btst  0xff, %o0                                
4000d2ec:	02 bf ff f7 	be  4000d2c8 <_Heap_Extend+0x2c>               
4000d2f0:	ba 10 00 11 	mov  %l1, %i5                                  
4000d2f4:	aa 10 20 00 	clr  %l5                                       
4000d2f8:	ac 10 20 00 	clr  %l6                                       
4000d2fc:	a6 10 20 00 	clr  %l3                                       
4000d300:	10 80 00 10 	b  4000d340 <_Heap_Extend+0xa4>                
4000d304:	a8 10 20 00 	clr  %l4                                       
      return 0;                                                       
    }                                                                 
                                                                      
    if ( extend_area_end == sub_area_begin ) {                        
      merge_below_block = start_block;                                
    } else if ( extend_area_end < sub_area_end ) {                    
4000d308:	2a 80 00 02 	bcs,a   4000d310 <_Heap_Extend+0x74>           
4000d30c:	ac 10 00 1d 	mov  %i5, %l6                                  
      link_below_block = start_block;                                 
    }                                                                 
                                                                      
    if ( sub_area_end == extend_area_begin ) {                        
4000d310:	80 a6 c0 19 	cmp  %i3, %i1                                  
4000d314:	22 80 00 1e 	be,a   4000d38c <_Heap_Extend+0xf0>            
4000d318:	e0 27 40 00 	st  %l0, [ %i5 ]                               
      start_block->prev_size = extend_area_end;                       
                                                                      
      merge_above_block = end_block;                                  
    } else if ( sub_area_end < extend_area_begin ) {                  
4000d31c:	80 a6 40 1b 	cmp  %i1, %i3                                  
4000d320:	38 80 00 02 	bgu,a   4000d328 <_Heap_Extend+0x8c>           
4000d324:	aa 10 00 08 	mov  %o0, %l5                                  
    - HEAP_BLOCK_HEADER_SIZE);                                        
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;                
4000d328:	fa 02 20 04 	ld  [ %o0 + 4 ], %i5                           
4000d32c:	ba 0f 7f fe 	and  %i5, -2, %i5                              
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
4000d330:	ba 02 00 1d 	add  %o0, %i5, %i5                             
      link_above_block = end_block;                                   
    }                                                                 
                                                                      
    start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
  } while ( start_block != first_block );                             
4000d334:	80 a4 40 1d 	cmp  %l1, %i5                                  
4000d338:	22 80 00 1c 	be,a   4000d3a8 <_Heap_Extend+0x10c>           
4000d33c:	c2 07 20 18 	ld  [ %i4 + 0x18 ], %g1                        
    return 0;                                                         
  }                                                                   
                                                                      
  do {                                                                
    uintptr_t const sub_area_begin = (start_block != first_block) ?   
      (uintptr_t) start_block : heap->area_begin;                     
4000d340:	80 a7 40 11 	cmp  %i5, %l1                                  
4000d344:	22 80 00 03 	be,a   4000d350 <_Heap_Extend+0xb4>            
4000d348:	f4 07 20 18 	ld  [ %i4 + 0x18 ], %i2                        
4000d34c:	b4 10 00 1d 	mov  %i5, %i2                                  
    uintptr_t const sub_area_end = start_block->prev_size;            
4000d350:	f6 07 40 00 	ld  [ %i5 ], %i3                               
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(                      
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return value - (value % alignment);                                 
4000d354:	92 10 00 12 	mov  %l2, %o1                                  
4000d358:	40 00 17 1b 	call  40012fc4 <.urem>                         
4000d35c:	90 10 00 1b 	mov  %i3, %o0                                  
4000d360:	82 06 ff f8 	add  %i3, -8, %g1                              
    Heap_Block *const end_block =                                     
      _Heap_Block_of_alloc_area( sub_area_end, page_size );           
                                                                      
    if (                                                              
4000d364:	80 a6 80 10 	cmp  %i2, %l0                                  
4000d368:	0a 80 00 64 	bcs  4000d4f8 <_Heap_Extend+0x25c>             
4000d36c:	90 20 40 08 	sub  %g1, %o0, %o0                             
      sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
    ) {                                                               
      return 0;                                                       
    }                                                                 
                                                                      
    if ( extend_area_end == sub_area_begin ) {                        
4000d370:	80 a6 80 10 	cmp  %i2, %l0                                  
4000d374:	12 bf ff e5 	bne  4000d308 <_Heap_Extend+0x6c>              
4000d378:	80 a4 00 1b 	cmp  %l0, %i3                                  
      merge_below_block = start_block;                                
    } else if ( extend_area_end < sub_area_end ) {                    
      link_below_block = start_block;                                 
    }                                                                 
                                                                      
    if ( sub_area_end == extend_area_begin ) {                        
4000d37c:	80 a6 c0 19 	cmp  %i3, %i1                                  
4000d380:	12 bf ff e7 	bne  4000d31c <_Heap_Extend+0x80>              <== ALWAYS TAKEN
4000d384:	a8 10 00 1d 	mov  %i5, %l4                                  
      start_block->prev_size = extend_area_end;                       
4000d388:	e0 27 40 00 	st  %l0, [ %i5 ]                               <== NOT EXECUTED
    - HEAP_BLOCK_HEADER_SIZE);                                        
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;                
4000d38c:	fa 02 20 04 	ld  [ %o0 + 4 ], %i5                           
4000d390:	ba 0f 7f fe 	and  %i5, -2, %i5                              
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
4000d394:	ba 02 00 1d 	add  %o0, %i5, %i5                             
    } else if ( sub_area_end < extend_area_begin ) {                  
      link_above_block = end_block;                                   
    }                                                                 
                                                                      
    start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
  } while ( start_block != first_block );                             
4000d398:	80 a4 40 1d 	cmp  %l1, %i5                                  
4000d39c:	12 bf ff e9 	bne  4000d340 <_Heap_Extend+0xa4>              <== NEVER TAKEN
4000d3a0:	a6 10 00 08 	mov  %o0, %l3                                  
                                                                      
  if ( extend_area_begin < heap->area_begin ) {                       
4000d3a4:	c2 07 20 18 	ld  [ %i4 + 0x18 ], %g1                        
4000d3a8:	80 a6 40 01 	cmp  %i1, %g1                                  
4000d3ac:	3a 80 00 4e 	bcc,a   4000d4e4 <_Heap_Extend+0x248>          
4000d3b0:	c2 07 20 1c 	ld  [ %i4 + 0x1c ], %g1                        
    heap->area_begin = extend_area_begin;                             
4000d3b4:	f2 27 20 18 	st  %i1, [ %i4 + 0x18 ]                        
  } else if ( heap->area_end < extend_area_end ) {                    
    heap->area_end = extend_area_end;                                 
  }                                                                   
                                                                      
  extend_first_block_size =                                           
    (uintptr_t) extend_last_block - (uintptr_t) extend_first_block;   
4000d3b8:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
4000d3bc:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
                                                                      
  extend_last_block->prev_size = extend_first_block_size;             
  extend_last_block->size_and_flag = 0;                               
  _Heap_Protection_block_initialize( heap, extend_last_block );       
                                                                      
  if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
4000d3c0:	c8 07 20 20 	ld  [ %i4 + 0x20 ], %g4                        
    heap->area_begin = extend_area_begin;                             
  } else if ( heap->area_end < extend_area_end ) {                    
    heap->area_end = extend_area_end;                                 
  }                                                                   
                                                                      
  extend_first_block_size =                                           
4000d3c4:	86 20 80 01 	sub  %g2, %g1, %g3                             
    (uintptr_t) extend_last_block - (uintptr_t) extend_first_block;   
                                                                      
  extend_first_block->prev_size = extend_area_end;                    
4000d3c8:	e0 20 40 00 	st  %l0, [ %g1 ]                               
  extend_first_block->size_and_flag =                                 
    extend_first_block_size | HEAP_PREV_BLOCK_USED;                   
4000d3cc:	ba 10 e0 01 	or  %g3, 1, %i5                                
                                                                      
  extend_first_block_size =                                           
    (uintptr_t) extend_last_block - (uintptr_t) extend_first_block;   
                                                                      
  extend_first_block->prev_size = extend_area_end;                    
  extend_first_block->size_and_flag =                                 
4000d3d0:	fa 20 60 04 	st  %i5, [ %g1 + 4 ]                           
    extend_first_block_size | HEAP_PREV_BLOCK_USED;                   
  _Heap_Protection_block_initialize( heap, extend_first_block );      
                                                                      
  extend_last_block->prev_size = extend_first_block_size;             
4000d3d4:	c6 20 80 00 	st  %g3, [ %g2 ]                               
  extend_last_block->size_and_flag = 0;                               
  _Heap_Protection_block_initialize( heap, extend_last_block );       
                                                                      
  if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
4000d3d8:	80 a1 00 01 	cmp  %g4, %g1                                  
4000d3dc:	08 80 00 3c 	bleu  4000d4cc <_Heap_Extend+0x230>            
4000d3e0:	c0 20 a0 04 	clr  [ %g2 + 4 ]                               
    heap->first_block = extend_first_block;                           
4000d3e4:	c2 27 20 20 	st  %g1, [ %i4 + 0x20 ]                        
  } else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
    heap->last_block = extend_last_block;                             
  }                                                                   
                                                                      
  if ( merge_below_block != NULL ) {                                  
4000d3e8:	80 a5 20 00 	cmp  %l4, 0                                    
4000d3ec:	02 80 00 47 	be  4000d508 <_Heap_Extend+0x26c>              
4000d3f0:	b2 06 60 08 	add  %i1, 8, %i1                               
  Heap_Control *heap,                                                 
  uintptr_t extend_area_begin,                                        
  Heap_Block *first_block                                             
)                                                                     
{                                                                     
  uintptr_t const page_size = heap->page_size;                        
4000d3f4:	fa 07 20 10 	ld  [ %i4 + 0x10 ], %i5                        
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(                        
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  uintptr_t remainder = value % alignment;                            
4000d3f8:	92 10 00 1d 	mov  %i5, %o1                                  
4000d3fc:	40 00 16 f2 	call  40012fc4 <.urem>                         
4000d400:	90 10 00 19 	mov  %i1, %o0                                  
                                                                      
  if ( remainder != 0 ) {                                             
4000d404:	80 a2 20 00 	cmp  %o0, 0                                    
4000d408:	02 80 00 04 	be  4000d418 <_Heap_Extend+0x17c>              
4000d40c:	c4 05 00 00 	ld  [ %l4 ], %g2                               
    return value - remainder + alignment;                             
4000d410:	b2 06 40 1d 	add  %i1, %i5, %i1                             
4000d414:	b2 26 40 08 	sub  %i1, %o0, %i1                             
  uintptr_t const new_first_block_alloc_begin =                       
    _Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
  uintptr_t const new_first_block_begin =                             
4000d418:	82 06 7f f8 	add  %i1, -8, %g1                              
  uintptr_t const first_block_begin = (uintptr_t) first_block;        
  uintptr_t const new_first_block_size =                              
    first_block_begin - new_first_block_begin;                        
  Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
                                                                      
  new_first_block->prev_size = first_block->prev_size;                
4000d41c:	c4 26 7f f8 	st  %g2, [ %i1 + -8 ]                          
  uintptr_t const new_first_block_alloc_begin =                       
    _Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
  uintptr_t const new_first_block_begin =                             
    new_first_block_alloc_begin - HEAP_BLOCK_HEADER_SIZE;             
  uintptr_t const first_block_begin = (uintptr_t) first_block;        
  uintptr_t const new_first_block_size =                              
4000d420:	84 25 00 01 	sub  %l4, %g1, %g2                             
    first_block_begin - new_first_block_begin;                        
  Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
                                                                      
  new_first_block->prev_size = first_block->prev_size;                
  new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED;
4000d424:	84 10 a0 01 	or  %g2, 1, %g2                                
                                                                      
  _Heap_Free_block( heap, new_first_block );                          
4000d428:	90 10 00 1c 	mov  %i4, %o0                                  
4000d42c:	92 10 00 01 	mov  %g1, %o1                                  
4000d430:	7f ff ff 85 	call  4000d244 <_Heap_Free_block>              
4000d434:	c4 26 7f fc 	st  %g2, [ %i1 + -4 ]                          
      link_below_block,                                               
      extend_last_block                                               
    );                                                                
  }                                                                   
                                                                      
  if ( merge_above_block != NULL ) {                                  
4000d438:	80 a4 e0 00 	cmp  %l3, 0                                    
4000d43c:	02 80 00 3a 	be  4000d524 <_Heap_Extend+0x288>              
4000d440:	a0 04 3f f8 	add  %l0, -8, %l0                              
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(                      
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return value - (value % alignment);                                 
4000d444:	d2 07 20 10 	ld  [ %i4 + 0x10 ], %o1                        
  uintptr_t extend_area_end                                           
)                                                                     
{                                                                     
  uintptr_t const page_size = heap->page_size;                        
  uintptr_t const last_block_begin = (uintptr_t) last_block;          
  uintptr_t const last_block_new_size = _Heap_Align_down(             
4000d448:	a0 24 00 13 	sub  %l0, %l3, %l0                             
4000d44c:	40 00 16 de 	call  40012fc4 <.urem>                         
4000d450:	90 10 00 10 	mov  %l0, %o0                                  
  );                                                                  
  Heap_Block *const new_last_block =                                  
    _Heap_Block_at( last_block, last_block_new_size );                
                                                                      
  new_last_block->size_and_flag =                                     
    (last_block->size_and_flag - last_block_new_size)                 
4000d454:	c2 04 e0 04 	ld  [ %l3 + 4 ], %g1                           
4000d458:	a0 24 00 08 	sub  %l0, %o0, %l0                             
4000d45c:	82 20 40 10 	sub  %g1, %l0, %g1                             
      | HEAP_PREV_BLOCK_USED;                                         
4000d460:	82 10 60 01 	or  %g1, 1, %g1                                
    page_size                                                         
  );                                                                  
  Heap_Block *const new_last_block =                                  
    _Heap_Block_at( last_block, last_block_new_size );                
                                                                      
  new_last_block->size_and_flag =                                     
4000d464:	84 04 00 13 	add  %l0, %l3, %g2                             
4000d468:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]                           
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(                       
  Heap_Block *block,                                                  
  uintptr_t size                                                      
)                                                                     
{                                                                     
  uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;       
4000d46c:	c2 04 e0 04 	ld  [ %l3 + 4 ], %g1                           
    (last_block->size_and_flag - last_block_new_size)                 
      | HEAP_PREV_BLOCK_USED;                                         
                                                                      
  _Heap_Block_set_size( last_block, last_block_new_size );            
                                                                      
  _Heap_Free_block( heap, last_block );                               
4000d470:	90 10 00 1c 	mov  %i4, %o0                                  
4000d474:	82 08 60 01 	and  %g1, 1, %g1                               
4000d478:	92 10 00 13 	mov  %l3, %o1                                  
                                                                      
  block->size_and_flag = size | flag;                                 
4000d47c:	a0 14 00 01 	or  %l0, %g1, %l0                              
4000d480:	7f ff ff 71 	call  4000d244 <_Heap_Free_block>              
4000d484:	e0 24 e0 04 	st  %l0, [ %l3 + 4 ]                           
      extend_first_block,                                             
      extend_last_block                                               
    );                                                                
  }                                                                   
                                                                      
  if ( merge_below_block == NULL && merge_above_block == NULL ) {     
4000d488:	80 a4 e0 00 	cmp  %l3, 0                                    
4000d48c:	02 80 00 33 	be  4000d558 <_Heap_Extend+0x2bc>              
4000d490:	80 a5 20 00 	cmp  %l4, 0                                    
 */                                                                   
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{                                                                     
  _Heap_Block_set_size(                                               
    heap->last_block,                                                 
    (uintptr_t) heap->first_block - (uintptr_t) heap->last_block      
4000d494:	c2 07 20 24 	ld  [ %i4 + 0x24 ], %g1                        
 * This feature will be used to terminate the scattered heap area list.  See
 * also _Heap_Extend().                                               
 */                                                                   
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{                                                                     
  _Heap_Block_set_size(                                               
4000d498:	fa 07 20 20 	ld  [ %i4 + 0x20 ], %i5                        
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(                       
  Heap_Block *block,                                                  
  uintptr_t size                                                      
)                                                                     
{                                                                     
  uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;       
4000d49c:	c8 00 60 04 	ld  [ %g1 + 4 ], %g4                           
  _Heap_Set_last_block_size( heap );                                  
                                                                      
  extended_size = stats->free_size - free_size;                       
                                                                      
  /* Statistics */                                                    
  stats->size += extended_size;                                       
4000d4a0:	c4 07 20 2c 	ld  [ %i4 + 0x2c ], %g2                        
    _Heap_Free_block( heap, extend_first_block );                     
  }                                                                   
                                                                      
  _Heap_Set_last_block_size( heap );                                  
                                                                      
  extended_size = stats->free_size - free_size;                       
4000d4a4:	c6 07 20 30 	ld  [ %i4 + 0x30 ], %g3                        
 * This feature will be used to terminate the scattered heap area list.  See
 * also _Heap_Extend().                                               
 */                                                                   
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{                                                                     
  _Heap_Block_set_size(                                               
4000d4a8:	ba 27 40 01 	sub  %i5, %g1, %i5                             
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(                       
  Heap_Block *block,                                                  
  uintptr_t size                                                      
)                                                                     
{                                                                     
  uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;       
4000d4ac:	88 09 20 01 	and  %g4, 1, %g4                               
                                                                      
  block->size_and_flag = size | flag;                                 
4000d4b0:	88 17 40 04 	or  %i5, %g4, %g4                              
4000d4b4:	c8 20 60 04 	st  %g4, [ %g1 + 4 ]                           
4000d4b8:	b0 20 c0 18 	sub  %g3, %i0, %i0                             
                                                                      
  /* Statistics */                                                    
  stats->size += extended_size;                                       
4000d4bc:	82 00 80 18 	add  %g2, %i0, %g1                             
4000d4c0:	c2 27 20 2c 	st  %g1, [ %i4 + 0x2c ]                        
                                                                      
  return extended_size;                                               
}                                                                     
4000d4c4:	81 c7 e0 08 	ret                                            
4000d4c8:	81 e8 00 00 	restore                                        
  extend_last_block->size_and_flag = 0;                               
  _Heap_Protection_block_initialize( heap, extend_last_block );       
                                                                      
  if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
    heap->first_block = extend_first_block;                           
  } else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
4000d4cc:	c2 07 20 24 	ld  [ %i4 + 0x24 ], %g1                        
4000d4d0:	80 a0 40 02 	cmp  %g1, %g2                                  
4000d4d4:	2a bf ff c5 	bcs,a   4000d3e8 <_Heap_Extend+0x14c>          
4000d4d8:	c4 27 20 24 	st  %g2, [ %i4 + 0x24 ]                        
    heap->last_block = extend_last_block;                             
  }                                                                   
                                                                      
  if ( merge_below_block != NULL ) {                                  
4000d4dc:	10 bf ff c4 	b  4000d3ec <_Heap_Extend+0x150>               
4000d4e0:	80 a5 20 00 	cmp  %l4, 0                                    
    start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
  } while ( start_block != first_block );                             
                                                                      
  if ( extend_area_begin < heap->area_begin ) {                       
    heap->area_begin = extend_area_begin;                             
  } else if ( heap->area_end < extend_area_end ) {                    
4000d4e4:	80 a4 00 01 	cmp  %l0, %g1                                  
4000d4e8:	38 bf ff b4 	bgu,a   4000d3b8 <_Heap_Extend+0x11c>          
4000d4ec:	e0 27 20 1c 	st  %l0, [ %i4 + 0x1c ]                        
    heap->area_end = extend_area_end;                                 
  }                                                                   
                                                                      
  extend_first_block_size =                                           
    (uintptr_t) extend_last_block - (uintptr_t) extend_first_block;   
4000d4f0:	10 bf ff b3 	b  4000d3bc <_Heap_Extend+0x120>               
4000d4f4:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
      (uintptr_t) start_block : heap->area_begin;                     
    uintptr_t const sub_area_end = start_block->prev_size;            
    Heap_Block *const end_block =                                     
      _Heap_Block_of_alloc_area( sub_area_end, page_size );           
                                                                      
    if (                                                              
4000d4f8:	80 a6 40 1b 	cmp  %i1, %i3                                  
4000d4fc:	1a bf ff 9e 	bcc  4000d374 <_Heap_Extend+0xd8>              
4000d500:	80 a6 80 10 	cmp  %i2, %l0                                  
4000d504:	30 bf ff 71 	b,a   4000d2c8 <_Heap_Extend+0x2c>             
    heap->last_block = extend_last_block;                             
  }                                                                   
                                                                      
  if ( merge_below_block != NULL ) {                                  
    _Heap_Merge_below( heap, extend_area_begin, merge_below_block );  
  } else if ( link_below_block != NULL ) {                            
4000d508:	80 a5 a0 00 	cmp  %l6, 0                                    
4000d50c:	02 bf ff cc 	be  4000d43c <_Heap_Extend+0x1a0>              
4000d510:	80 a4 e0 00 	cmp  %l3, 0                                    
{                                                                     
  uintptr_t const last_block_begin = (uintptr_t) last_block;          
  uintptr_t const link_begin = (uintptr_t) link;                      
                                                                      
  last_block->size_and_flag =                                         
    (link_begin - last_block_begin) | HEAP_PREV_BLOCK_USED;           
4000d514:	ac 25 80 02 	sub  %l6, %g2, %l6                             
4000d518:	ac 15 a0 01 	or  %l6, 1, %l6                                
)                                                                     
{                                                                     
  uintptr_t const last_block_begin = (uintptr_t) last_block;          
  uintptr_t const link_begin = (uintptr_t) link;                      
                                                                      
  last_block->size_and_flag =                                         
4000d51c:	10 bf ff c8 	b  4000d43c <_Heap_Extend+0x1a0>               
4000d520:	ec 20 a0 04 	st  %l6, [ %g2 + 4 ]                           
    );                                                                
  }                                                                   
                                                                      
  if ( merge_above_block != NULL ) {                                  
    _Heap_Merge_above( heap, merge_above_block, extend_area_end );    
  } else if ( link_above_block != NULL ) {                            
4000d524:	80 a5 60 00 	cmp  %l5, 0                                    
4000d528:	02 bf ff d8 	be  4000d488 <_Heap_Extend+0x1ec>              
4000d52c:	c4 07 bf f8 	ld  [ %fp + -8 ], %g2                          
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(                       
  Heap_Block *block,                                                  
  uintptr_t size                                                      
)                                                                     
{                                                                     
  uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;       
4000d530:	c6 05 60 04 	ld  [ %l5 + 4 ], %g3                           
    _Heap_Link_above(                                                 
4000d534:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4000d538:	86 08 e0 01 	and  %g3, 1, %g3                               
)                                                                     
{                                                                     
  uintptr_t const link_begin = (uintptr_t) link;                      
  uintptr_t const first_block_begin = (uintptr_t) first_block;        
                                                                      
  _Heap_Block_set_size( link, first_block_begin - link_begin );       
4000d53c:	84 20 80 15 	sub  %g2, %l5, %g2                             
                                                                      
  block->size_and_flag = size | flag;                                 
4000d540:	84 10 80 03 	or  %g2, %g3, %g2                              
4000d544:	c4 25 60 04 	st  %g2, [ %l5 + 4 ]                           
                                                                      
  last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;                  
4000d548:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
4000d54c:	84 10 a0 01 	or  %g2, 1, %g2                                
4000d550:	10 bf ff ce 	b  4000d488 <_Heap_Extend+0x1ec>               
4000d554:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
      extend_first_block,                                             
      extend_last_block                                               
    );                                                                
  }                                                                   
                                                                      
  if ( merge_below_block == NULL && merge_above_block == NULL ) {     
4000d558:	32 bf ff d0 	bne,a   4000d498 <_Heap_Extend+0x1fc>          
4000d55c:	c2 07 20 24 	ld  [ %i4 + 0x24 ], %g1                        
    _Heap_Free_block( heap, extend_first_block );                     
4000d560:	d2 07 bf f8 	ld  [ %fp + -8 ], %o1                          
4000d564:	7f ff ff 38 	call  4000d244 <_Heap_Free_block>              
4000d568:	90 10 00 1c 	mov  %i4, %o0                                  
 */                                                                   
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{                                                                     
  _Heap_Block_set_size(                                               
    heap->last_block,                                                 
    (uintptr_t) heap->first_block - (uintptr_t) heap->last_block      
4000d56c:	10 bf ff cb 	b  4000d498 <_Heap_Extend+0x1fc>               
4000d570:	c2 07 20 24 	ld  [ %i4 + 0x24 ], %g1                        
                                                                      

4000d688 <_Heap_Free>: return do_free; } #endif bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr ) {
4000d688:	9d e3 bf a0 	save  %sp, -96, %sp                            
  /*                                                                  
   * If NULL return true so a free on NULL is considered a valid release. This
   * is a special case that could be handled by the in heap check how-ever that
   * would result in false being returned which is wrong.             
   */                                                                 
  if ( alloc_begin_ptr == NULL ) {                                    
4000d68c:	80 a6 60 00 	cmp  %i1, 0                                    
4000d690:	02 80 00 3c 	be  4000d780 <_Heap_Free+0xf8>                 
4000d694:	82 10 20 01 	mov  1, %g1                                    
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(                      
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return value - (value % alignment);                                 
4000d698:	d2 06 20 10 	ld  [ %i0 + 0x10 ], %o1                        
4000d69c:	40 00 2d 22 	call  40018b24 <.urem>                         
4000d6a0:	90 10 00 19 	mov  %i1, %o0                                  
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap(                     
  const Heap_Control *heap,                                           
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block >= (uintptr_t) heap->first_block           
4000d6a4:	c4 06 20 20 	ld  [ %i0 + 0x20 ], %g2                        
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(                      
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return value - (value % alignment);                                 
4000d6a8:	ba 06 7f f8 	add  %i1, -8, %i5                              
  uintptr_t alloc_begin,                                              
  uintptr_t page_size                                                 
)                                                                     
{                                                                     
  return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )   
    - HEAP_BLOCK_HEADER_SIZE);                                        
4000d6ac:	90 27 40 08 	sub  %i5, %o0, %o0                             
  const Heap_Control *heap,                                           
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block >= (uintptr_t) heap->first_block           
    && (uintptr_t) block <= (uintptr_t) heap->last_block;             
4000d6b0:	80 a2 00 02 	cmp  %o0, %g2                                  
4000d6b4:	0a 80 00 30 	bcs  4000d774 <_Heap_Free+0xec>                
4000d6b8:	82 10 20 00 	clr  %g1                                       
4000d6bc:	c8 06 20 24 	ld  [ %i0 + 0x24 ], %g4                        
4000d6c0:	80 a2 00 04 	cmp  %o0, %g4                                  
4000d6c4:	38 80 00 2d 	bgu,a   4000d778 <_Heap_Free+0xf0>             <== NEVER TAKEN
4000d6c8:	b0 08 60 ff 	and  %g1, 0xff, %i0                            <== NOT EXECUTED
    - HEAP_BLOCK_HEADER_SIZE);                                        
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;                
4000d6cc:	f6 02 20 04 	ld  [ %o0 + 4 ], %i3                           
4000d6d0:	ba 0e ff fe 	and  %i3, -2, %i5                              
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
4000d6d4:	86 02 00 1d 	add  %o0, %i5, %g3                             
  const Heap_Control *heap,                                           
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block >= (uintptr_t) heap->first_block           
    && (uintptr_t) block <= (uintptr_t) heap->last_block;             
4000d6d8:	80 a0 80 03 	cmp  %g2, %g3                                  
4000d6dc:	38 80 00 27 	bgu,a   4000d778 <_Heap_Free+0xf0>             <== NEVER TAKEN
4000d6e0:	b0 08 60 ff 	and  %g1, 0xff, %i0                            <== NOT EXECUTED
4000d6e4:	80 a1 00 03 	cmp  %g4, %g3                                  
4000d6e8:	2a 80 00 24 	bcs,a   4000d778 <_Heap_Free+0xf0>             <== NEVER TAKEN
4000d6ec:	b0 08 60 ff 	and  %g1, 0xff, %i0                            <== NOT EXECUTED
  block->size_and_flag = size | flag;                                 
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & HEAP_PREV_BLOCK_USED;                 
4000d6f0:	f8 00 e0 04 	ld  [ %g3 + 4 ], %i4                           
    return false;                                                     
  }                                                                   
                                                                      
  _Heap_Protection_block_check( heap, next_block );                   
                                                                      
  if ( !_Heap_Is_prev_used( next_block ) ) {                          
4000d6f4:	80 8f 20 01 	btst  1, %i4                                   
4000d6f8:	02 80 00 1f 	be  4000d774 <_Heap_Free+0xec>                 <== NEVER TAKEN
4000d6fc:	80 a1 00 03 	cmp  %g4, %g3                                  
    return true;                                                      
  }                                                                   
                                                                      
  next_block_size = _Heap_Block_size( next_block );                   
  next_is_free = next_block != heap->last_block                       
    && !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
4000d700:	02 80 00 23 	be  4000d78c <_Heap_Free+0x104>                
4000d704:	b8 0f 3f fe 	and  %i4, -2, %i4                              
4000d708:	82 00 c0 1c 	add  %g3, %i4, %g1                             
4000d70c:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
4000d710:	80 88 60 01 	btst  1, %g1                                   
4000d714:	12 80 00 1f 	bne  4000d790 <_Heap_Free+0x108>               
4000d718:	80 8e e0 01 	btst  1, %i3                                   
                                                                      
  if ( !_Heap_Is_prev_used( block ) ) {                               
4000d71c:	02 80 00 20 	be  4000d79c <_Heap_Free+0x114>                
4000d720:	b2 10 20 01 	mov  1, %i1                                    
RTEMS_INLINE_ROUTINE void _Heap_Free_list_replace(                    
  Heap_Block *old_block,                                              
  Heap_Block *new_block                                               
)                                                                     
{                                                                     
  Heap_Block *next = old_block->next;                                 
4000d724:	c4 00 e0 08 	ld  [ %g3 + 8 ], %g2                           
  Heap_Block *prev = old_block->prev;                                 
4000d728:	c2 00 e0 0c 	ld  [ %g3 + 0xc ], %g1                         
                                                                      
  new_block->next = next;                                             
4000d72c:	c4 22 20 08 	st  %g2, [ %o0 + 8 ]                           
  new_block->prev = prev;                                             
4000d730:	c2 22 20 0c 	st  %g1, [ %o0 + 0xc ]                         
      prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;        
      next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;             
      next_block->prev_size = size;                                   
    }                                                                 
  } else if ( next_is_free ) {    /* coalesce next */                 
    uintptr_t const size = block_size + next_block_size;              
4000d734:	b8 07 00 1d 	add  %i4, %i5, %i4                             
                                                                      
  next->prev = new_block;                                             
4000d738:	d0 20 a0 0c 	st  %o0, [ %g2 + 0xc ]                         
  prev->next = new_block;                                             
4000d73c:	d0 20 60 08 	st  %o0, [ %g1 + 8 ]                           
    _Heap_Free_list_replace( next_block, block );                     
    block->size_and_flag = size | HEAP_PREV_BLOCK_USED;               
4000d740:	84 17 20 01 	or  %i4, 1, %g2                                
    next_block  = _Heap_Block_at( block, size );                      
    next_block->prev_size = size;                                     
4000d744:	f8 22 00 1c 	st  %i4, [ %o0 + %i4 ]                         
      next_block->prev_size = size;                                   
    }                                                                 
  } else if ( next_is_free ) {    /* coalesce next */                 
    uintptr_t const size = block_size + next_block_size;              
    _Heap_Free_list_replace( next_block, block );                     
    block->size_and_flag = size | HEAP_PREV_BLOCK_USED;               
4000d748:	c4 22 20 04 	st  %g2, [ %o0 + 4 ]                           
    }                                                                 
  }                                                                   
                                                                      
  /* Statistics */                                                    
  --stats->used_blocks;                                               
  ++stats->frees;                                                     
4000d74c:	c2 06 20 50 	ld  [ %i0 + 0x50 ], %g1                        
      stats->max_free_blocks = stats->free_blocks;                    
    }                                                                 
  }                                                                   
                                                                      
  /* Statistics */                                                    
  --stats->used_blocks;                                               
4000d750:	c4 06 20 40 	ld  [ %i0 + 0x40 ], %g2                        
  ++stats->frees;                                                     
  stats->free_size += block_size;                                     
4000d754:	c6 06 20 30 	ld  [ %i0 + 0x30 ], %g3                        
    }                                                                 
  }                                                                   
                                                                      
  /* Statistics */                                                    
  --stats->used_blocks;                                               
  ++stats->frees;                                                     
4000d758:	82 00 60 01 	inc  %g1                                       
      stats->max_free_blocks = stats->free_blocks;                    
    }                                                                 
  }                                                                   
                                                                      
  /* Statistics */                                                    
  --stats->used_blocks;                                               
4000d75c:	84 00 bf ff 	add  %g2, -1, %g2                              
  ++stats->frees;                                                     
  stats->free_size += block_size;                                     
4000d760:	ba 00 c0 1d 	add  %g3, %i5, %i5                             
    }                                                                 
  }                                                                   
                                                                      
  /* Statistics */                                                    
  --stats->used_blocks;                                               
  ++stats->frees;                                                     
4000d764:	c2 26 20 50 	st  %g1, [ %i0 + 0x50 ]                        
      stats->max_free_blocks = stats->free_blocks;                    
    }                                                                 
  }                                                                   
                                                                      
  /* Statistics */                                                    
  --stats->used_blocks;                                               
4000d768:	c4 26 20 40 	st  %g2, [ %i0 + 0x40 ]                        
  ++stats->frees;                                                     
  stats->free_size += block_size;                                     
4000d76c:	fa 26 20 30 	st  %i5, [ %i0 + 0x30 ]                        
                                                                      
  return( true );                                                     
4000d770:	82 10 20 01 	mov  1, %g1                                    
4000d774:	b0 08 60 ff 	and  %g1, 0xff, %i0                            
4000d778:	81 c7 e0 08 	ret                                            
4000d77c:	81 e8 00 00 	restore                                        
4000d780:	b0 08 60 ff 	and  %g1, 0xff, %i0                            
4000d784:	81 c7 e0 08 	ret                                            
4000d788:	81 e8 00 00 	restore                                        
                                                                      
  next_block_size = _Heap_Block_size( next_block );                   
  next_is_free = next_block != heap->last_block                       
    && !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
                                                                      
  if ( !_Heap_Is_prev_used( block ) ) {                               
4000d78c:	80 8e e0 01 	btst  1, %i3                                   
4000d790:	32 80 00 1e 	bne,a   4000d808 <_Heap_Free+0x180>            
4000d794:	c4 06 20 08 	ld  [ %i0 + 8 ], %g2                           
  if ( !_Heap_Protection_determine_block_free( heap, block ) ) {      
    return true;                                                      
  }                                                                   
                                                                      
  next_block_size = _Heap_Block_size( next_block );                   
  next_is_free = next_block != heap->last_block                       
4000d798:	b2 10 20 00 	clr  %i1                                       
    && !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
                                                                      
  if ( !_Heap_Is_prev_used( block ) ) {                               
    uintptr_t const prev_size = block->prev_size;                     
4000d79c:	f4 02 00 00 	ld  [ %o0 ], %i2                               
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
4000d7a0:	b6 22 00 1a 	sub  %o0, %i2, %i3                             
  const Heap_Control *heap,                                           
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block >= (uintptr_t) heap->first_block           
    && (uintptr_t) block <= (uintptr_t) heap->last_block;             
4000d7a4:	80 a0 80 1b 	cmp  %g2, %i3                                  
4000d7a8:	18 bf ff f3 	bgu  4000d774 <_Heap_Free+0xec>                <== NEVER TAKEN
4000d7ac:	82 10 20 00 	clr  %g1                                       
4000d7b0:	80 a1 00 1b 	cmp  %g4, %i3                                  
4000d7b4:	2a bf ff f1 	bcs,a   4000d778 <_Heap_Free+0xf0>             <== NEVER TAKEN
4000d7b8:	b0 08 60 ff 	and  %g1, 0xff, %i0                            <== NOT EXECUTED
  block->size_and_flag = size | flag;                                 
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & HEAP_PREV_BLOCK_USED;                 
4000d7bc:	c4 06 e0 04 	ld  [ %i3 + 4 ], %g2                           
      return( false );                                                
    }                                                                 
                                                                      
    /* As we always coalesce free blocks, the block that preceedes prev_block
       must have been used. */                                        
    if ( !_Heap_Is_prev_used ( prev_block) ) {                        
4000d7c0:	80 88 a0 01 	btst  1, %g2                                   
4000d7c4:	02 bf ff ec 	be  4000d774 <_Heap_Free+0xec>                 <== NEVER TAKEN
4000d7c8:	80 8e 60 ff 	btst  0xff, %i1                                
      _HAssert( false );                                              
      return( false );                                                
    }                                                                 
                                                                      
    if ( next_is_free ) {       /* coalesce both */                   
4000d7cc:	22 80 00 21 	be,a   4000d850 <_Heap_Free+0x1c8>             
4000d7d0:	b4 07 40 1a 	add  %i5, %i2, %i2                             
  return _Heap_Free_list_tail(heap)->prev;                            
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block ) 
{                                                                     
  Heap_Block *next = block->next;                                     
4000d7d4:	c2 00 e0 08 	ld  [ %g3 + 8 ], %g1                           
  Heap_Block *prev = block->prev;                                     
4000d7d8:	c4 00 e0 0c 	ld  [ %g3 + 0xc ], %g2                         
      uintptr_t const size = block_size + prev_size + next_block_size;
      _Heap_Free_list_remove( next_block );                           
      stats->free_blocks -= 1;                                        
4000d7dc:	c6 06 20 38 	ld  [ %i0 + 0x38 ], %g3                        
                                                                      
  prev->next = next;                                                  
4000d7e0:	c2 20 a0 08 	st  %g1, [ %g2 + 8 ]                           
  next->prev = prev;                                                  
4000d7e4:	c4 20 60 0c 	st  %g2, [ %g1 + 0xc ]                         
4000d7e8:	82 00 ff ff 	add  %g3, -1, %g1                              
4000d7ec:	c2 26 20 38 	st  %g1, [ %i0 + 0x38 ]                        
      _HAssert( false );                                              
      return( false );                                                
    }                                                                 
                                                                      
    if ( next_is_free ) {       /* coalesce both */                   
      uintptr_t const size = block_size + prev_size + next_block_size;
4000d7f0:	b8 07 40 1c 	add  %i5, %i4, %i4                             
4000d7f4:	b4 07 00 1a 	add  %i4, %i2, %i2                             
      _Heap_Free_list_remove( next_block );                           
      stats->free_blocks -= 1;                                        
      prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;        
4000d7f8:	82 16 a0 01 	or  %i2, 1, %g1                                
      next_block = _Heap_Block_at( prev_block, size );                
      _HAssert(!_Heap_Is_prev_used( next_block));                     
      next_block->prev_size = size;                                   
4000d7fc:	f4 26 c0 1a 	st  %i2, [ %i3 + %i2 ]                         
                                                                      
    if ( next_is_free ) {       /* coalesce both */                   
      uintptr_t const size = block_size + prev_size + next_block_size;
      _Heap_Free_list_remove( next_block );                           
      stats->free_blocks -= 1;                                        
      prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;        
4000d800:	10 bf ff d3 	b  4000d74c <_Heap_Free+0xc4>                  
4000d804:	c2 26 e0 04 	st  %g1, [ %i3 + 4 ]                           
    next_block->prev_size = size;                                     
  } else {                        /* no coalesce */                   
    /* Add 'block' to the head of the free blocks list as it tends to 
       produce less fragmentation than adding to the tail. */         
    _Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
    block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;         
4000d808:	82 17 60 01 	or  %i5, 1, %g1                                
4000d80c:	c2 22 20 04 	st  %g1, [ %o0 + 4 ]                           
    next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;               
4000d810:	c8 00 e0 04 	ld  [ %g3 + 4 ], %g4                           
)                                                                     
{                                                                     
  Heap_Block *next = block_before->next;                              
                                                                      
  new_block->next = next;                                             
  new_block->prev = block_before;                                     
4000d814:	f0 22 20 0c 	st  %i0, [ %o0 + 0xc ]                         
    next_block->prev_size = block_size;                               
                                                                      
    /* Statistics */                                                  
    ++stats->free_blocks;                                             
4000d818:	c2 06 20 38 	ld  [ %i0 + 0x38 ], %g1                        
  Heap_Block *new_block                                               
)                                                                     
{                                                                     
  Heap_Block *next = block_before->next;                              
                                                                      
  new_block->next = next;                                             
4000d81c:	c4 22 20 08 	st  %g2, [ %o0 + 8 ]                           
  new_block->prev = block_before;                                     
  block_before->next = new_block;                                     
  next->prev = new_block;                                             
4000d820:	d0 20 a0 0c 	st  %o0, [ %g2 + 0xc ]                         
  } else {                        /* no coalesce */                   
    /* Add 'block' to the head of the free blocks list as it tends to 
       produce less fragmentation than adding to the tail. */         
    _Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
    block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;         
    next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;               
4000d824:	84 09 3f fe 	and  %g4, -2, %g2                              
    next_block->prev_size = block_size;                               
4000d828:	fa 22 00 1d 	st  %i5, [ %o0 + %i5 ]                         
  } else {                        /* no coalesce */                   
    /* Add 'block' to the head of the free blocks list as it tends to 
       produce less fragmentation than adding to the tail. */         
    _Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
    block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;         
    next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;               
4000d82c:	c4 20 e0 04 	st  %g2, [ %g3 + 4 ]                           
    next_block->prev_size = block_size;                               
                                                                      
    /* Statistics */                                                  
    ++stats->free_blocks;                                             
    if ( stats->max_free_blocks < stats->free_blocks ) {              
4000d830:	c4 06 20 3c 	ld  [ %i0 + 0x3c ], %g2                        
    block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;         
    next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;               
    next_block->prev_size = block_size;                               
                                                                      
    /* Statistics */                                                  
    ++stats->free_blocks;                                             
4000d834:	82 00 60 01 	inc  %g1                                       
{                                                                     
  Heap_Block *next = block_before->next;                              
                                                                      
  new_block->next = next;                                             
  new_block->prev = block_before;                                     
  block_before->next = new_block;                                     
4000d838:	d0 26 20 08 	st  %o0, [ %i0 + 8 ]                           
    if ( stats->max_free_blocks < stats->free_blocks ) {              
4000d83c:	80 a0 40 02 	cmp  %g1, %g2                                  
4000d840:	08 bf ff c3 	bleu  4000d74c <_Heap_Free+0xc4>               
4000d844:	c2 26 20 38 	st  %g1, [ %i0 + 0x38 ]                        
      stats->max_free_blocks = stats->free_blocks;                    
4000d848:	10 bf ff c1 	b  4000d74c <_Heap_Free+0xc4>                  
4000d84c:	c2 26 20 3c 	st  %g1, [ %i0 + 0x3c ]                        
      next_block = _Heap_Block_at( prev_block, size );                
      _HAssert(!_Heap_Is_prev_used( next_block));                     
      next_block->prev_size = size;                                   
    } else {                      /* coalesce prev */                 
      uintptr_t const size = block_size + prev_size;                  
      prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;        
4000d850:	82 16 a0 01 	or  %i2, 1, %g1                                
4000d854:	c2 26 e0 04 	st  %g1, [ %i3 + 4 ]                           
      next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;             
4000d858:	c2 00 e0 04 	ld  [ %g3 + 4 ], %g1                           
      next_block->prev_size = size;                                   
4000d85c:	f4 22 00 1d 	st  %i2, [ %o0 + %i5 ]                         
      _HAssert(!_Heap_Is_prev_used( next_block));                     
      next_block->prev_size = size;                                   
    } else {                      /* coalesce prev */                 
      uintptr_t const size = block_size + prev_size;                  
      prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;        
      next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;             
4000d860:	82 08 7f fe 	and  %g1, -2, %g1                              
4000d864:	10 bf ff ba 	b  4000d74c <_Heap_Free+0xc4>                  
4000d868:	c2 20 e0 04 	st  %g1, [ %g3 + 4 ]                           
                                                                      

40013354 <_Heap_Get_free_information>: return &heap->free_list; } RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap ) { return _Heap_Free_list_head(heap)->next;
40013354:	c2 02 20 08 	ld  [ %o0 + 8 ], %g1                           
)                                                                     
{                                                                     
  Heap_Block *the_block;                                              
  Heap_Block *const tail = _Heap_Free_list_tail(the_heap);            
                                                                      
  info->number = 0;                                                   
40013358:	c0 22 40 00 	clr  [ %o1 ]                                   
  info->largest = 0;                                                  
4001335c:	c0 22 60 04 	clr  [ %o1 + 4 ]                               
  info->total = 0;                                                    
40013360:	c0 22 60 08 	clr  [ %o1 + 8 ]                               
                                                                      
  for(the_block = _Heap_Free_list_first(the_heap);                    
40013364:	88 10 20 01 	mov  1, %g4                                    
40013368:	9a 10 20 00 	clr  %o5                                       
4001336c:	80 a2 00 01 	cmp  %o0, %g1                                  
40013370:	12 80 00 04 	bne  40013380 <_Heap_Get_free_information+0x2c><== ALWAYS TAKEN
40013374:	86 10 20 00 	clr  %g3                                       
40013378:	30 80 00 10 	b,a   400133b8 <_Heap_Get_free_information+0x64><== NOT EXECUTED
4001337c:	88 10 00 0c 	mov  %o4, %g4                                  
    - HEAP_BLOCK_HEADER_SIZE);                                        
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;                
40013380:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
40013384:	98 01 20 01 	add  %g4, 1, %o4                               
40013388:	84 08 bf fe 	and  %g2, -2, %g2                              
    /* As we always coalesce free blocks, prev block must have been used. */
    _HAssert(_Heap_Is_prev_used(the_block));                          
                                                                      
    info->number++;                                                   
    info->total += the_size;                                          
    if ( info->largest < the_size )                                   
4001338c:	80 a0 80 0d 	cmp  %g2, %o5                                  
40013390:	08 80 00 03 	bleu  4001339c <_Heap_Get_free_information+0x48>
40013394:	86 00 c0 02 	add  %g3, %g2, %g3                             
        info->largest = the_size;                                     
40013398:	c4 22 60 04 	st  %g2, [ %o1 + 4 ]                           
  info->largest = 0;                                                  
  info->total = 0;                                                    
                                                                      
  for(the_block = _Heap_Free_list_first(the_heap);                    
      the_block != tail;                                              
      the_block = the_block->next)                                    
4001339c:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
                                                                      
  info->number = 0;                                                   
  info->largest = 0;                                                  
  info->total = 0;                                                    
                                                                      
  for(the_block = _Heap_Free_list_first(the_heap);                    
400133a0:	80 a2 00 01 	cmp  %o0, %g1                                  
400133a4:	32 bf ff f6 	bne,a   4001337c <_Heap_Get_free_information+0x28>
400133a8:	da 02 60 04 	ld  [ %o1 + 4 ], %o5                           
400133ac:	c8 22 40 00 	st  %g4, [ %o1 ]                               
400133b0:	81 c3 e0 08 	retl                                           
400133b4:	c6 22 60 08 	st  %g3, [ %o1 + 8 ]                           
400133b8:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
                                                                      

4000a3f8 <_Heap_Greedy_allocate>: Heap_Block *_Heap_Greedy_allocate( Heap_Control *heap, const uintptr_t *block_sizes, size_t block_count ) {
4000a3f8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Heap_Block *allocated_blocks = NULL;                                
  Heap_Block *blocks = NULL;                                          
  Heap_Block *current;                                                
  size_t i;                                                           
                                                                      
  for (i = 0; i < block_count; ++i) {                                 
4000a3fc:	80 a6 a0 00 	cmp  %i2, 0                                    
4000a400:	02 80 00 35 	be  4000a4d4 <_Heap_Greedy_allocate+0xdc>      
4000a404:	b8 10 00 18 	mov  %i0, %i4                                  
4000a408:	ba 10 20 00 	clr  %i5                                       
4000a40c:	b6 10 20 00 	clr  %i3                                       
  #include "config.h"                                                 
#endif                                                                
                                                                      
#include <rtems/score/heap.h>                                         
                                                                      
Heap_Block *_Heap_Greedy_allocate(                                    
4000a410:	83 2f 60 02 	sll  %i5, 2, %g1                               
 * @brief See _Heap_Allocate_aligned_with_boundary() with alignment and
 * boundary equals zero.                                              
 */                                                                   
RTEMS_INLINE_ROUTINE void *_Heap_Allocate( Heap_Control *heap, uintptr_t size )
{                                                                     
  return _Heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );    
4000a414:	d2 06 40 01 	ld  [ %i1 + %g1 ], %o1                         
4000a418:	94 10 20 00 	clr  %o2                                       
4000a41c:	96 10 20 00 	clr  %o3                                       
4000a420:	40 00 1f 3e 	call  40012118 <_Heap_Allocate_aligned_with_boundary>
4000a424:	90 10 00 1c 	mov  %i4, %o0                                  
  size_t i;                                                           
                                                                      
  for (i = 0; i < block_count; ++i) {                                 
    void *next = _Heap_Allocate( heap, block_sizes [i] );             
                                                                      
    if ( next != NULL ) {                                             
4000a428:	82 92 20 00 	orcc  %o0, 0, %g1                              
4000a42c:	22 80 00 09 	be,a   4000a450 <_Heap_Greedy_allocate+0x58>   <== NEVER TAKEN
4000a430:	ba 07 60 01 	inc  %i5                                       <== NOT EXECUTED
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(                      
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return value - (value % alignment);                                 
4000a434:	d2 07 20 10 	ld  [ %i4 + 0x10 ], %o1                        
4000a438:	40 00 36 a8 	call  40017ed8 <.urem>                         
4000a43c:	b0 00 7f f8 	add  %g1, -8, %i0                              
  uintptr_t alloc_begin,                                              
  uintptr_t page_size                                                 
)                                                                     
{                                                                     
  return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )   
    - HEAP_BLOCK_HEADER_SIZE);                                        
4000a440:	90 26 00 08 	sub  %i0, %o0, %o0                             
      Heap_Block *next_block = _Heap_Block_of_alloc_area(             
        (uintptr_t) next,                                             
        heap->page_size                                               
      );                                                              
                                                                      
      next_block->next = allocated_blocks;                            
4000a444:	f6 22 20 08 	st  %i3, [ %o0 + 8 ]                           
4000a448:	b6 10 00 08 	mov  %o0, %i3                                  
  Heap_Block *allocated_blocks = NULL;                                
  Heap_Block *blocks = NULL;                                          
  Heap_Block *current;                                                
  size_t i;                                                           
                                                                      
  for (i = 0; i < block_count; ++i) {                                 
4000a44c:	ba 07 60 01 	inc  %i5                                       
4000a450:	80 a7 40 1a 	cmp  %i5, %i2                                  
4000a454:	12 bf ff f0 	bne  4000a414 <_Heap_Greedy_allocate+0x1c>     
4000a458:	83 2f 60 02 	sll  %i5, 2, %g1                               
  return &heap->free_list;                                            
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{                                                                     
  return _Heap_Free_list_head(heap)->next;                            
4000a45c:	fa 07 20 08 	ld  [ %i4 + 8 ], %i5                           
      next_block->next = allocated_blocks;                            
      allocated_blocks = next_block;                                  
    }                                                                 
  }                                                                   
                                                                      
  while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
4000a460:	80 a7 00 1d 	cmp  %i4, %i5                                  
4000a464:	02 80 00 17 	be  4000a4c0 <_Heap_Greedy_allocate+0xc8>      <== NEVER TAKEN
4000a468:	b0 10 20 00 	clr  %i0                                       
4000a46c:	10 80 00 03 	b  4000a478 <_Heap_Greedy_allocate+0x80>       
4000a470:	b4 10 20 00 	clr  %i2                                       
4000a474:	ba 10 00 01 	mov  %g1, %i5                                  
    - HEAP_BLOCK_HEADER_SIZE);                                        
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;                
4000a478:	d6 07 60 04 	ld  [ %i5 + 4 ], %o3                           
    _Heap_Block_allocate(                                             
4000a47c:	92 10 00 1d 	mov  %i5, %o1                                  
4000a480:	96 0a ff fe 	and  %o3, -2, %o3                              
4000a484:	94 07 60 08 	add  %i5, 8, %o2                               
4000a488:	90 10 00 1c 	mov  %i4, %o0                                  
4000a48c:	40 00 00 e0 	call  4000a80c <_Heap_Block_allocate>          
4000a490:	96 02 ff f8 	add  %o3, -8, %o3                              
      current,                                                        
      _Heap_Alloc_area_of_block( current ),                           
      _Heap_Block_size( current ) - HEAP_BLOCK_HEADER_SIZE            
    );                                                                
                                                                      
    current->next = blocks;                                           
4000a494:	f4 27 60 08 	st  %i2, [ %i5 + 8 ]                           
  return &heap->free_list;                                            
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{                                                                     
  return _Heap_Free_list_head(heap)->next;                            
4000a498:	c2 07 20 08 	ld  [ %i4 + 8 ], %g1                           
      next_block->next = allocated_blocks;                            
      allocated_blocks = next_block;                                  
    }                                                                 
  }                                                                   
                                                                      
  while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
4000a49c:	80 a7 00 01 	cmp  %i4, %g1                                  
4000a4a0:	12 bf ff f5 	bne  4000a474 <_Heap_Greedy_allocate+0x7c>     
4000a4a4:	b4 10 00 1d 	mov  %i5, %i2                                  
4000a4a8:	10 80 00 06 	b  4000a4c0 <_Heap_Greedy_allocate+0xc8>       
4000a4ac:	b0 10 00 1d 	mov  %i5, %i0                                  
  }                                                                   
                                                                      
  while ( allocated_blocks != NULL ) {                                
    current = allocated_blocks;                                       
    allocated_blocks = allocated_blocks->next;                        
    _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
4000a4b0:	92 06 e0 08 	add  %i3, 8, %o1                               
4000a4b4:	90 10 00 1c 	mov  %i4, %o0                                  
4000a4b8:	40 00 1f a3 	call  40012344 <_Heap_Free>                    
4000a4bc:	b6 10 00 1a 	mov  %i2, %i3                                  
                                                                      
    current->next = blocks;                                           
    blocks = current;                                                 
  }                                                                   
                                                                      
  while ( allocated_blocks != NULL ) {                                
4000a4c0:	80 a6 e0 00 	cmp  %i3, 0                                    
4000a4c4:	32 bf ff fb 	bne,a   4000a4b0 <_Heap_Greedy_allocate+0xb8>  
4000a4c8:	f4 06 e0 08 	ld  [ %i3 + 8 ], %i2                           
    allocated_blocks = allocated_blocks->next;                        
    _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
  }                                                                   
                                                                      
  return blocks;                                                      
}                                                                     
4000a4cc:	81 c7 e0 08 	ret                                            
4000a4d0:	81 e8 00 00 	restore                                        
  const uintptr_t *block_sizes,                                       
  size_t block_count                                                  
)                                                                     
{                                                                     
  Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );    
  Heap_Block *allocated_blocks = NULL;                                
4000a4d4:	10 bf ff e2 	b  4000a45c <_Heap_Greedy_allocate+0x64>       
4000a4d8:	b6 10 20 00 	clr  %i3                                       
                                                                      

4000a4dc <_Heap_Greedy_free>: void _Heap_Greedy_free( Heap_Control *heap, Heap_Block *blocks ) {
4000a4dc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  while ( blocks != NULL ) {                                          
4000a4e0:	80 a6 60 00 	cmp  %i1, 0                                    
4000a4e4:	02 80 00 09 	be  4000a508 <_Heap_Greedy_free+0x2c>          <== NEVER TAKEN
4000a4e8:	01 00 00 00 	nop                                            
    Heap_Block *current = blocks;                                     
                                                                      
    blocks = blocks->next;                                            
4000a4ec:	fa 06 60 08 	ld  [ %i1 + 8 ], %i5                           
    _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
4000a4f0:	92 06 60 08 	add  %i1, 8, %o1                               
4000a4f4:	40 00 1f 94 	call  40012344 <_Heap_Free>                    
4000a4f8:	90 10 00 18 	mov  %i0, %o0                                  
void _Heap_Greedy_free(                                               
  Heap_Control *heap,                                                 
  Heap_Block *blocks                                                  
)                                                                     
{                                                                     
  while ( blocks != NULL ) {                                          
4000a4fc:	b2 97 60 00 	orcc  %i5, 0, %i1                              
4000a500:	32 bf ff fc 	bne,a   4000a4f0 <_Heap_Greedy_free+0x14>      
4000a504:	fa 06 60 08 	ld  [ %i1 + 8 ], %i5                           
4000a508:	81 c7 e0 08 	ret                                            
4000a50c:	81 e8 00 00 	restore                                        
                                                                      

40013420 <_Heap_Iterate>: void _Heap_Iterate( Heap_Control *heap, Heap_Block_visitor visitor, void *visitor_arg ) {
40013420:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
  Heap_Block *current = heap->first_block;                            
40013424:	c2 06 20 20 	ld  [ %i0 + 0x20 ], %g1                        <== NOT EXECUTED
  Heap_Block *end = heap->last_block;                                 
40013428:	f8 06 20 24 	ld  [ %i0 + 0x24 ], %i4                        <== NOT EXECUTED
  bool stop = false;                                                  
                                                                      
  while ( !stop && current != end ) {                                 
4001342c:	80 a0 40 1c 	cmp  %g1, %i4                                  <== NOT EXECUTED
40013430:	32 80 00 08 	bne,a   40013450 <_Heap_Iterate+0x30>          <== NOT EXECUTED
40013434:	d2 00 60 04 	ld  [ %g1 + 4 ], %o1                           <== NOT EXECUTED
40013438:	30 80 00 10 	b,a   40013478 <_Heap_Iterate+0x58>            <== NOT EXECUTED
4001343c:	90 1a 20 01 	xor  %o0, 1, %o0                               <== NOT EXECUTED
40013440:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40013444:	02 80 00 0d 	be  40013478 <_Heap_Iterate+0x58>              <== NOT EXECUTED
40013448:	01 00 00 00 	nop                                            <== NOT EXECUTED
4001344c:	d2 00 60 04 	ld  [ %g1 + 4 ], %o1                           <== NOT EXECUTED
    uintptr_t size = _Heap_Block_size( current );                     
    Heap_Block *next = _Heap_Block_at( current, size );               
    bool used = _Heap_Is_prev_used( next );                           
                                                                      
    stop = (*visitor)( current, size, used, visitor_arg );            
40013450:	90 10 00 01 	mov  %g1, %o0                                  <== NOT EXECUTED
40013454:	92 0a 7f fe 	and  %o1, -2, %o1                              <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
40013458:	ba 00 40 09 	add  %g1, %o1, %i5                             <== NOT EXECUTED
  block->size_and_flag = size | flag;                                 
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & HEAP_PREV_BLOCK_USED;                 
4001345c:	d4 07 60 04 	ld  [ %i5 + 4 ], %o2                           <== NOT EXECUTED
40013460:	96 10 00 1a 	mov  %i2, %o3                                  <== NOT EXECUTED
40013464:	9f c6 40 00 	call  %i1                                      <== NOT EXECUTED
40013468:	94 0a a0 01 	and  %o2, 1, %o2                               <== NOT EXECUTED
{                                                                     
  Heap_Block *current = heap->first_block;                            
  Heap_Block *end = heap->last_block;                                 
  bool stop = false;                                                  
                                                                      
  while ( !stop && current != end ) {                                 
4001346c:	80 a7 00 1d 	cmp  %i4, %i5                                  <== NOT EXECUTED
40013470:	12 bf ff f3 	bne  4001343c <_Heap_Iterate+0x1c>             <== NOT EXECUTED
40013474:	82 10 00 1d 	mov  %i5, %g1                                  <== NOT EXECUTED
40013478:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001347c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4001c10c <_Heap_Size_of_alloc_area>: bool _Heap_Size_of_alloc_area( Heap_Control *heap, void *alloc_begin_ptr, uintptr_t *alloc_size ) {
4001c10c:	9d e3 bf a0 	save  %sp, -96, %sp                            
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(                      
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return value - (value % alignment);                                 
4001c110:	d2 06 20 10 	ld  [ %i0 + 0x10 ], %o1                        
4001c114:	7f ff f2 84 	call  40018b24 <.urem>                         
4001c118:	90 10 00 19 	mov  %i1, %o0                                  
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap(                     
  const Heap_Control *heap,                                           
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block >= (uintptr_t) heap->first_block           
4001c11c:	c2 06 20 20 	ld  [ %i0 + 0x20 ], %g1                        
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(                      
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return value - (value % alignment);                                 
4001c120:	84 06 7f f8 	add  %i1, -8, %g2                              
  uintptr_t alloc_begin,                                              
  uintptr_t page_size                                                 
)                                                                     
{                                                                     
  return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )   
    - HEAP_BLOCK_HEADER_SIZE);                                        
4001c124:	90 20 80 08 	sub  %g2, %o0, %o0                             
  const Heap_Control *heap,                                           
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block >= (uintptr_t) heap->first_block           
    && (uintptr_t) block <= (uintptr_t) heap->last_block;             
4001c128:	80 a2 00 01 	cmp  %o0, %g1                                  
4001c12c:	0a 80 00 16 	bcs  4001c184 <_Heap_Size_of_alloc_area+0x78>  
4001c130:	84 10 20 00 	clr  %g2                                       
4001c134:	c6 06 20 24 	ld  [ %i0 + 0x24 ], %g3                        
4001c138:	80 a2 00 03 	cmp  %o0, %g3                                  
4001c13c:	18 80 00 13 	bgu  4001c188 <_Heap_Size_of_alloc_area+0x7c>  <== NEVER TAKEN
4001c140:	b0 08 a0 ff 	and  %g2, 0xff, %i0                            
    - HEAP_BLOCK_HEADER_SIZE);                                        
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;                
4001c144:	c8 02 20 04 	ld  [ %o0 + 4 ], %g4                           
4001c148:	88 09 3f fe 	and  %g4, -2, %g4                              
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
4001c14c:	90 02 00 04 	add  %o0, %g4, %o0                             
  const Heap_Control *heap,                                           
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block >= (uintptr_t) heap->first_block           
    && (uintptr_t) block <= (uintptr_t) heap->last_block;             
4001c150:	80 a0 40 08 	cmp  %g1, %o0                                  
4001c154:	18 80 00 0d 	bgu  4001c188 <_Heap_Size_of_alloc_area+0x7c>  <== NEVER TAKEN
4001c158:	01 00 00 00 	nop                                            
4001c15c:	80 a0 c0 08 	cmp  %g3, %o0                                  
4001c160:	0a 80 00 0a 	bcs  4001c188 <_Heap_Size_of_alloc_area+0x7c>  <== NEVER TAKEN
4001c164:	01 00 00 00 	nop                                            
  block->size_and_flag = size | flag;                                 
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & HEAP_PREV_BLOCK_USED;                 
4001c168:	c2 02 20 04 	ld  [ %o0 + 4 ], %g1                           
  block_size = _Heap_Block_size( block );                             
  next_block = _Heap_Block_at( block, block_size );                   
                                                                      
  if (                                                                
    !_Heap_Is_block_in_heap( heap, next_block )                       
      || !_Heap_Is_prev_used( next_block )                            
4001c16c:	80 88 60 01 	btst  1, %g1                                   
4001c170:	02 80 00 06 	be  4001c188 <_Heap_Size_of_alloc_area+0x7c>   <== NEVER TAKEN
4001c174:	90 22 00 19 	sub  %o0, %i1, %o0                             
    return false;                                                     
  }                                                                   
                                                                      
  *alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
                                                                      
  return true;                                                        
4001c178:	84 10 20 01 	mov  1, %g2                                    
      || !_Heap_Is_prev_used( next_block )                            
  ) {                                                                 
    return false;                                                     
  }                                                                   
                                                                      
  *alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
4001c17c:	90 02 20 04 	add  %o0, 4, %o0                               
4001c180:	d0 26 80 00 	st  %o0, [ %i2 ]                               
4001c184:	b0 08 a0 ff 	and  %g2, 0xff, %i0                            
4001c188:	81 c7 e0 08 	ret                                            
4001c18c:	81 e8 00 00 	restore                                        
                                                                      

40009274 <_Heap_Walk>: bool _Heap_Walk( Heap_Control *heap, int source, bool dump ) {
40009274:	9d e3 bf 80 	save  %sp, -128, %sp                           
  uintptr_t const page_size = heap->page_size;                        
40009278:	f6 06 20 10 	ld  [ %i0 + 0x10 ], %i3                        
  uintptr_t const min_block_size = heap->min_block_size;              
4000927c:	e0 06 20 14 	ld  [ %i0 + 0x14 ], %l0                        
  Heap_Block *const first_block = heap->first_block;                  
40009280:	f8 06 20 20 	ld  [ %i0 + 0x20 ], %i4                        
  Heap_Block *const last_block = heap->last_block;                    
  Heap_Block *block = first_block;                                    
  Heap_Walk_printer printer = dump ?                                  
    _Heap_Walk_print : _Heap_Walk_print_nothing;                      
40009284:	80 a6 a0 00 	cmp  %i2, 0                                    
40009288:	02 80 00 0c 	be  400092b8 <_Heap_Walk+0x44>                 
4000928c:	e2 06 20 24 	ld  [ %i0 + 0x24 ], %l1                        
                                                                      
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
40009290:	03 10 00 65 	sethi  %hi(0x40019400), %g1                    
40009294:	c4 00 60 b8 	ld  [ %g1 + 0xb8 ], %g2	! 400194b8 <_System_state_Current>
  uintptr_t const min_block_size = heap->min_block_size;              
  Heap_Block *const first_block = heap->first_block;                  
  Heap_Block *const last_block = heap->last_block;                    
  Heap_Block *block = first_block;                                    
  Heap_Walk_printer printer = dump ?                                  
    _Heap_Walk_print : _Heap_Walk_print_nothing;                      
40009298:	07 10 00 24 	sethi  %hi(0x40009000), %g3                    
                                                                      
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
4000929c:	82 10 20 01 	mov  1, %g1                                    
  Heap_Block *const last_block = heap->last_block;                    
  Heap_Block *block = first_block;                                    
  Heap_Walk_printer printer = dump ?                                  
    _Heap_Walk_print : _Heap_Walk_print_nothing;                      
                                                                      
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
400092a0:	80 a0 a0 03 	cmp  %g2, 3                                    
400092a4:	02 80 00 0c 	be  400092d4 <_Heap_Walk+0x60>                 <== ALWAYS TAKEN
400092a8:	ae 10 e2 10 	or  %g3, 0x210, %l7                            
400092ac:	b0 08 60 ff 	and  %g1, 0xff, %i0                            
400092b0:	81 c7 e0 08 	ret                                            
400092b4:	81 e8 00 00 	restore                                        
400092b8:	03 10 00 65 	sethi  %hi(0x40019400), %g1                    
400092bc:	c4 00 60 b8 	ld  [ %g1 + 0xb8 ], %g2	! 400194b8 <_System_state_Current>
  uintptr_t const min_block_size = heap->min_block_size;              
  Heap_Block *const first_block = heap->first_block;                  
  Heap_Block *const last_block = heap->last_block;                    
  Heap_Block *block = first_block;                                    
  Heap_Walk_printer printer = dump ?                                  
    _Heap_Walk_print : _Heap_Walk_print_nothing;                      
400092c0:	07 10 00 24 	sethi  %hi(0x40009000), %g3                    
                                                                      
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
400092c4:	82 10 20 01 	mov  1, %g1                                    
  Heap_Block *const last_block = heap->last_block;                    
  Heap_Block *block = first_block;                                    
  Heap_Walk_printer printer = dump ?                                  
    _Heap_Walk_print : _Heap_Walk_print_nothing;                      
                                                                      
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
400092c8:	80 a0 a0 03 	cmp  %g2, 3                                    
400092cc:	12 bf ff f8 	bne  400092ac <_Heap_Walk+0x38>                
400092d0:	ae 10 e2 08 	or  %g3, 0x208, %l7                            
  Heap_Block *const first_free_block = _Heap_Free_list_first( heap ); 
  Heap_Block *const last_free_block = _Heap_Free_list_last( heap );   
  Heap_Block *const first_block = heap->first_block;                  
  Heap_Block *const last_block = heap->last_block;                    
                                                                      
  (*printer)(                                                         
400092d4:	da 06 20 18 	ld  [ %i0 + 0x18 ], %o5                        
400092d8:	c8 06 20 1c 	ld  [ %i0 + 0x1c ], %g4                        
400092dc:	c4 06 20 08 	ld  [ %i0 + 8 ], %g2                           
400092e0:	c2 06 20 0c 	ld  [ %i0 + 0xc ], %g1                         
400092e4:	90 10 00 19 	mov  %i1, %o0                                  
400092e8:	c8 23 a0 5c 	st  %g4, [ %sp + 0x5c ]                        
400092ec:	f8 23 a0 60 	st  %i4, [ %sp + 0x60 ]                        
400092f0:	e2 23 a0 64 	st  %l1, [ %sp + 0x64 ]                        
400092f4:	c4 23 a0 68 	st  %g2, [ %sp + 0x68 ]                        
400092f8:	c2 23 a0 6c 	st  %g1, [ %sp + 0x6c ]                        
400092fc:	92 10 20 00 	clr  %o1                                       
40009300:	96 10 00 1b 	mov  %i3, %o3                                  
40009304:	15 10 00 59 	sethi  %hi(0x40016400), %o2                    
40009308:	98 10 00 10 	mov  %l0, %o4                                  
4000930c:	9f c5 c0 00 	call  %l7                                      
40009310:	94 12 a2 78 	or  %o2, 0x278, %o2                            
    heap->area_begin, heap->area_end,                                 
    first_block, last_block,                                          
    first_free_block, last_free_block                                 
  );                                                                  
                                                                      
  if ( page_size == 0 ) {                                             
40009314:	80 a6 e0 00 	cmp  %i3, 0                                    
40009318:	02 80 00 2a 	be  400093c0 <_Heap_Walk+0x14c>                
4000931c:	80 8e e0 07 	btst  7, %i3                                   
    (*printer)( source, true, "page size is zero\n" );                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Addresses_Is_aligned( (void *) page_size ) ) {               
40009320:	12 80 00 2f 	bne  400093dc <_Heap_Walk+0x168>               
40009324:	90 10 00 10 	mov  %l0, %o0                                  
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(                           
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return (value % alignment) == 0;                                    
40009328:	7f ff e2 12 	call  40001b70 <.urem>                         
4000932c:	92 10 00 1b 	mov  %i3, %o1                                  
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {             
40009330:	80 a2 20 00 	cmp  %o0, 0                                    
40009334:	12 80 00 32 	bne  400093fc <_Heap_Walk+0x188>               
40009338:	90 07 20 08 	add  %i4, 8, %o0                               
4000933c:	7f ff e2 0d 	call  40001b70 <.urem>                         
40009340:	92 10 00 1b 	mov  %i3, %o1                                  
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if (                                                                
40009344:	80 a2 20 00 	cmp  %o0, 0                                    
40009348:	32 80 00 35 	bne,a   4000941c <_Heap_Walk+0x1a8>            
4000934c:	90 10 00 19 	mov  %i1, %o0                                  
  block->size_and_flag = size | flag;                                 
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & HEAP_PREV_BLOCK_USED;                 
40009350:	ec 07 20 04 	ld  [ %i4 + 4 ], %l6                           
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Heap_Is_prev_used( first_block ) ) {                         
40009354:	b4 8d a0 01 	andcc  %l6, 1, %i2                             
40009358:	22 80 00 38 	be,a   40009438 <_Heap_Walk+0x1c4>             
4000935c:	90 10 00 19 	mov  %i1, %o0                                  
    - HEAP_BLOCK_HEADER_SIZE);                                        
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;                
40009360:	c2 04 60 04 	ld  [ %l1 + 4 ], %g1                           
40009364:	82 08 7f fe 	and  %g1, -2, %g1                              
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
40009368:	82 04 40 01 	add  %l1, %g1, %g1                             
  block->size_and_flag = size | flag;                                 
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & HEAP_PREV_BLOCK_USED;                 
4000936c:	fa 00 60 04 	ld  [ %g1 + 4 ], %i5                           
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( _Heap_Is_free( last_block ) ) {                                
40009370:	80 8f 60 01 	btst  1, %i5                                   
40009374:	02 80 00 0c 	be  400093a4 <_Heap_Walk+0x130>                
40009378:	80 a7 00 01 	cmp  %i4, %g1                                  
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if (                                                                
4000937c:	02 80 00 35 	be  40009450 <_Heap_Walk+0x1dc>                
40009380:	90 10 00 19 	mov  %i1, %o0                                  
    _Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
  ) {                                                                 
    (*printer)(                                                       
40009384:	92 10 20 01 	mov  1, %o1                                    
40009388:	15 10 00 59 	sethi  %hi(0x40016400), %o2                    
4000938c:	9f c5 c0 00 	call  %l7                                      
40009390:	94 12 a3 f0 	or  %o2, 0x3f0, %o2	! 400167f0 <__log2table+0x2d8>
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
40009394:	82 10 20 00 	clr  %g1                                       
40009398:	b0 08 60 ff 	and  %g1, 0xff, %i0                            
4000939c:	81 c7 e0 08 	ret                                            
400093a0:	81 e8 00 00 	restore                                        
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( _Heap_Is_free( last_block ) ) {                                
    (*printer)(                                                       
400093a4:	90 10 00 19 	mov  %i1, %o0                                  
400093a8:	92 10 20 01 	mov  1, %o1                                    
400093ac:	15 10 00 59 	sethi  %hi(0x40016400), %o2                    
400093b0:	9f c5 c0 00 	call  %l7                                      
400093b4:	94 12 a3 d8 	or  %o2, 0x3d8, %o2	! 400167d8 <__log2table+0x2c0>
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
400093b8:	10 bf ff f8 	b  40009398 <_Heap_Walk+0x124>                 
400093bc:	82 10 20 00 	clr  %g1                                       
    first_block, last_block,                                          
    first_free_block, last_free_block                                 
  );                                                                  
                                                                      
  if ( page_size == 0 ) {                                             
    (*printer)( source, true, "page size is zero\n" );                
400093c0:	90 10 00 19 	mov  %i1, %o0                                  
400093c4:	92 10 20 01 	mov  1, %o1                                    
400093c8:	15 10 00 59 	sethi  %hi(0x40016400), %o2                    
400093cc:	9f c5 c0 00 	call  %l7                                      
400093d0:	94 12 a3 10 	or  %o2, 0x310, %o2	! 40016710 <__log2table+0x1f8>
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
400093d4:	10 bf ff f1 	b  40009398 <_Heap_Walk+0x124>                 
400093d8:	82 10 20 00 	clr  %g1                                       
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Addresses_Is_aligned( (void *) page_size ) ) {               
    (*printer)(                                                       
400093dc:	90 10 00 19 	mov  %i1, %o0                                  
400093e0:	92 10 20 01 	mov  1, %o1                                    
400093e4:	15 10 00 59 	sethi  %hi(0x40016400), %o2                    
400093e8:	96 10 00 1b 	mov  %i3, %o3                                  
400093ec:	9f c5 c0 00 	call  %l7                                      
400093f0:	94 12 a3 28 	or  %o2, 0x328, %o2                            
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
400093f4:	10 bf ff e9 	b  40009398 <_Heap_Walk+0x124>                 
400093f8:	82 10 20 00 	clr  %g1                                       
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {             
    (*printer)(                                                       
400093fc:	90 10 00 19 	mov  %i1, %o0                                  
40009400:	92 10 20 01 	mov  1, %o1                                    
40009404:	15 10 00 59 	sethi  %hi(0x40016400), %o2                    
40009408:	96 10 00 10 	mov  %l0, %o3                                  
4000940c:	9f c5 c0 00 	call  %l7                                      
40009410:	94 12 a3 48 	or  %o2, 0x348, %o2                            
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
40009414:	10 bf ff e1 	b  40009398 <_Heap_Walk+0x124>                 
40009418:	82 10 20 00 	clr  %g1                                       
  }                                                                   
                                                                      
  if (                                                                
    !_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
  ) {                                                                 
    (*printer)(                                                       
4000941c:	92 10 20 01 	mov  1, %o1                                    
40009420:	15 10 00 59 	sethi  %hi(0x40016400), %o2                    
40009424:	96 10 00 1c 	mov  %i4, %o3                                  
40009428:	9f c5 c0 00 	call  %l7                                      
4000942c:	94 12 a3 70 	or  %o2, 0x370, %o2                            
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
40009430:	10 bf ff da 	b  40009398 <_Heap_Walk+0x124>                 
40009434:	82 10 20 00 	clr  %g1                                       
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Heap_Is_prev_used( first_block ) ) {                         
    (*printer)(                                                       
40009438:	92 10 20 01 	mov  1, %o1                                    
4000943c:	15 10 00 59 	sethi  %hi(0x40016400), %o2                    
40009440:	9f c5 c0 00 	call  %l7                                      
40009444:	94 12 a3 a8 	or  %o2, 0x3a8, %o2	! 400167a8 <__log2table+0x290>
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
40009448:	10 bf ff d4 	b  40009398 <_Heap_Walk+0x124>                 
4000944c:	82 10 20 00 	clr  %g1                                       
  return &heap->free_list;                                            
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{                                                                     
  return _Heap_Free_list_head(heap)->next;                            
40009450:	fa 06 20 08 	ld  [ %i0 + 8 ], %i5                           
  int source,                                                         
  Heap_Walk_printer printer,                                          
  Heap_Control *heap                                                  
)                                                                     
{                                                                     
  uintptr_t const page_size = heap->page_size;                        
40009454:	e8 06 20 10 	ld  [ %i0 + 0x10 ], %l4                        
  const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
  const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
  const Heap_Block *prev_block = free_list_tail;                      
  const Heap_Block *free_block = first_free_block;                    
                                                                      
  while ( free_block != free_list_tail ) {                            
40009458:	80 a6 00 1d 	cmp  %i0, %i5                                  
4000945c:	02 80 00 0d 	be  40009490 <_Heap_Walk+0x21c>                
40009460:	da 06 20 20 	ld  [ %i0 + 0x20 ], %o5                        
  const Heap_Control *heap,                                           
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block >= (uintptr_t) heap->first_block           
    && (uintptr_t) block <= (uintptr_t) heap->last_block;             
40009464:	80 a3 40 1d 	cmp  %o5, %i5                                  
40009468:	28 80 00 bf 	bleu,a   40009764 <_Heap_Walk+0x4f0>           <== ALWAYS TAKEN
4000946c:	e6 06 20 24 	ld  [ %i0 + 0x24 ], %l3                        
    if ( !_Heap_Is_block_in_heap( heap, free_block ) ) {              
      (*printer)(                                                     
40009470:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
40009474:	92 10 20 01 	mov  1, %o1                                    
40009478:	15 10 00 5a 	sethi  %hi(0x40016800), %o2                    
4000947c:	96 10 00 1d 	mov  %i5, %o3                                  
40009480:	9f c5 c0 00 	call  %l7                                      
40009484:	94 12 a0 20 	or  %o2, 0x20, %o2                             
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
40009488:	10 bf ff c4 	b  40009398 <_Heap_Walk+0x124>                 
4000948c:	82 10 20 00 	clr  %g1                                       
        "block 0x%08x: size %u\n",                                    
        block,                                                        
        block_size                                                    
      );                                                              
    } else {                                                          
      (*printer)(                                                     
40009490:	27 10 00 5a 	sethi  %hi(0x40016800), %l3                    
    if ( !_Heap_Is_prev_used( next_block ) ) {                        
      if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
        return false;                                                 
      }                                                               
    } else if (prev_used) {                                           
      (*printer)(                                                     
40009494:	25 10 00 5a 	sethi  %hi(0x40016800), %l2                    
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( _Heap_Is_used( free_block ) ) {                              
40009498:	aa 10 00 1c 	mov  %i4, %l5                                  
        "block 0x%08x: size %u\n",                                    
        block,                                                        
        block_size                                                    
      );                                                              
    } else {                                                          
      (*printer)(                                                     
4000949c:	a6 14 e2 50 	or  %l3, 0x250, %l3                            
    if ( !_Heap_Is_prev_used( next_block ) ) {                        
      if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
        return false;                                                 
      }                                                               
    } else if (prev_used) {                                           
      (*printer)(                                                     
400094a0:	a4 14 a2 38 	or  %l2, 0x238, %l2                            
      " (= first free)"                                               
        : (block->prev == free_list_head ? " (= head)" : ""),         
    block->next,                                                      
    block->next == last_free_block ?                                  
      " (= last free)"                                                
        : (block->next == free_list_tail ? " (= tail)" : "")          
400094a4:	29 10 00 5a 	sethi  %hi(0x40016800), %l4                    
    - HEAP_BLOCK_HEADER_SIZE);                                        
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;                
400094a8:	ac 0d bf fe 	and  %l6, -2, %l6                              
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
400094ac:	ba 05 80 15 	add  %l6, %l5, %i5                             
  const Heap_Control *heap,                                           
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block >= (uintptr_t) heap->first_block           
    && (uintptr_t) block <= (uintptr_t) heap->last_block;             
400094b0:	80 a3 40 1d 	cmp  %o5, %i5                                  
400094b4:	28 80 00 0b 	bleu,a   400094e0 <_Heap_Walk+0x26c>           <== ALWAYS TAKEN
400094b8:	de 06 20 24 	ld  [ %i0 + 0x24 ], %o7                        
    Heap_Block *const next_block = _Heap_Block_at( block, block_size );
    uintptr_t const next_block_begin = (uintptr_t) next_block;        
    bool const is_not_last_block = block != last_block;               
                                                                      
    if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {              
      (*printer)(                                                     
400094bc:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
400094c0:	92 10 20 01 	mov  1, %o1                                    
400094c4:	96 10 00 15 	mov  %l5, %o3                                  
400094c8:	15 10 00 5a 	sethi  %hi(0x40016800), %o2                    
400094cc:	98 10 00 1d 	mov  %i5, %o4                                  
400094d0:	9f c5 c0 00 	call  %l7                                      
400094d4:	94 12 a0 c8 	or  %o2, 0xc8, %o2                             
        "block 0x%08x: next block 0x%08x not in heap\n",              
        block,                                                        
        next_block                                                    
      );                                                              
                                                                      
      return false;                                                   
400094d8:	10 bf ff 75 	b  400092ac <_Heap_Walk+0x38>                  
400094dc:	82 10 20 00 	clr  %g1                                       
400094e0:	80 a3 c0 1d 	cmp  %o7, %i5                                  
400094e4:	0a bf ff f7 	bcs  400094c0 <_Heap_Walk+0x24c>               
400094e8:	90 10 00 19 	mov  %i1, %o0                                  
    uintptr_t const block_begin = (uintptr_t) block;                  
    uintptr_t const block_size = _Heap_Block_size( block );           
    bool const prev_used = _Heap_Is_prev_used( block );               
    Heap_Block *const next_block = _Heap_Block_at( block, block_size );
    uintptr_t const next_block_begin = (uintptr_t) next_block;        
    bool const is_not_last_block = block != last_block;               
400094ec:	9e 1d 40 11 	xor  %l5, %l1, %o7                             
400094f0:	80 a0 00 0f 	cmp  %g0, %o7                                  
400094f4:	9a 40 20 00 	addx  %g0, 0, %o5                              
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(                           
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return (value % alignment) == 0;                                    
400094f8:	90 10 00 16 	mov  %l6, %o0                                  
400094fc:	da 27 bf fc 	st  %o5, [ %fp + -4 ]                          
40009500:	7f ff e1 9c 	call  40001b70 <.urem>                         
40009504:	92 10 00 1b 	mov  %i3, %o1                                  
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
40009508:	80 a2 20 00 	cmp  %o0, 0                                    
4000950c:	02 80 00 18 	be  4000956c <_Heap_Walk+0x2f8>                
40009510:	da 07 bf fc 	ld  [ %fp + -4 ], %o5                          
40009514:	80 8b 60 ff 	btst  0xff, %o5                                
40009518:	12 80 00 8b 	bne  40009744 <_Heap_Walk+0x4d0>               
4000951c:	90 10 00 19 	mov  %i1, %o0                                  
  block->size_and_flag = size | flag;                                 
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & HEAP_PREV_BLOCK_USED;                 
40009520:	de 07 60 04 	ld  [ %i5 + 4 ], %o7                           
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( !_Heap_Is_prev_used( next_block ) ) {                        
40009524:	80 8b e0 01 	btst  1, %o7                                   
40009528:	02 80 00 2b 	be  400095d4 <_Heap_Walk+0x360>                
4000952c:	80 a6 a0 00 	cmp  %i2, 0                                    
      if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
        return false;                                                 
      }                                                               
    } else if (prev_used) {                                           
40009530:	22 80 00 21 	be,a   400095b4 <_Heap_Walk+0x340>             
40009534:	da 05 40 00 	ld  [ %l5 ], %o5                               
      (*printer)(                                                     
40009538:	90 10 00 19 	mov  %i1, %o0                                  
4000953c:	92 10 20 00 	clr  %o1                                       
40009540:	94 10 00 12 	mov  %l2, %o2                                  
40009544:	96 10 00 15 	mov  %l5, %o3                                  
40009548:	9f c5 c0 00 	call  %l7                                      
4000954c:	98 10 00 16 	mov  %l6, %o4                                  
        block->prev_size                                              
      );                                                              
    }                                                                 
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
40009550:	80 a7 00 1d 	cmp  %i4, %i5                                  
40009554:	02 80 00 51 	be  40009698 <_Heap_Walk+0x424>                
40009558:	aa 10 00 1d 	mov  %i5, %l5                                  
4000955c:	ec 07 60 04 	ld  [ %i5 + 4 ], %l6                           
40009560:	da 06 20 20 	ld  [ %i0 + 0x20 ], %o5                        
40009564:	10 bf ff d1 	b  400094a8 <_Heap_Walk+0x234>                 
40009568:	b4 0d a0 01 	and  %l6, 1, %i2                               
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( block_size < min_block_size && is_not_last_block ) {         
4000956c:	80 a5 80 10 	cmp  %l6, %l0                                  
40009570:	0a 80 00 69 	bcs  40009714 <_Heap_Walk+0x4a0>               
40009574:	80 8b 60 ff 	btst  0xff, %o5                                
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( next_block_begin <= block_begin && is_not_last_block ) {     
40009578:	80 a5 40 1d 	cmp  %l5, %i5                                  
4000957c:	2a bf ff ea 	bcs,a   40009524 <_Heap_Walk+0x2b0>            
40009580:	de 07 60 04 	ld  [ %i5 + 4 ], %o7                           
40009584:	80 8b 60 ff 	btst  0xff, %o5                                
40009588:	22 bf ff e7 	be,a   40009524 <_Heap_Walk+0x2b0>             
4000958c:	de 07 60 04 	ld  [ %i5 + 4 ], %o7                           
      (*printer)(                                                     
40009590:	90 10 00 19 	mov  %i1, %o0                                  
40009594:	92 10 20 01 	mov  1, %o1                                    
40009598:	96 10 00 15 	mov  %l5, %o3                                  
4000959c:	15 10 00 5a 	sethi  %hi(0x40016800), %o2                    
400095a0:	98 10 00 1d 	mov  %i5, %o4                                  
400095a4:	9f c5 c0 00 	call  %l7                                      
400095a8:	94 12 a1 58 	or  %o2, 0x158, %o2                            
        "block 0x%08x: next block 0x%08x is not a successor\n",       
        block,                                                        
        next_block                                                    
      );                                                              
                                                                      
      return false;                                                   
400095ac:	10 bf ff 40 	b  400092ac <_Heap_Walk+0x38>                  
400095b0:	82 10 20 00 	clr  %g1                                       
        "block 0x%08x: size %u\n",                                    
        block,                                                        
        block_size                                                    
      );                                                              
    } else {                                                          
      (*printer)(                                                     
400095b4:	96 10 00 15 	mov  %l5, %o3                                  
400095b8:	90 10 00 19 	mov  %i1, %o0                                  
400095bc:	92 10 20 00 	clr  %o1                                       
400095c0:	94 10 00 13 	mov  %l3, %o2                                  
400095c4:	9f c5 c0 00 	call  %l7                                      
400095c8:	98 10 00 16 	mov  %l6, %o4                                  
        block->prev_size                                              
      );                                                              
    }                                                                 
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
400095cc:	10 bf ff e2 	b  40009554 <_Heap_Walk+0x2e0>                 
400095d0:	80 a7 00 1d 	cmp  %i4, %i5                                  
    false,                                                            
    "block 0x%08x: size %u, prev 0x%08x%s, next 0x%08x%s\n",          
    block,                                                            
    block_size,                                                       
    block->prev,                                                      
    block->prev == first_free_block ?                                 
400095d4:	da 05 60 0c 	ld  [ %l5 + 0xc ], %o5                         
  Heap_Block *const last_free_block = _Heap_Free_list_last( heap );   
  bool const prev_used = _Heap_Is_prev_used( block );                 
  uintptr_t const block_size = _Heap_Block_size( block );             
  Heap_Block *const next_block = _Heap_Block_at( block, block_size ); 
                                                                      
  (*printer)(                                                         
400095d8:	de 06 20 08 	ld  [ %i0 + 8 ], %o7                           
400095dc:	80 a3 c0 0d 	cmp  %o7, %o5                                  
400095e0:	02 80 00 3d 	be  400096d4 <_Heap_Walk+0x460>                
400095e4:	d8 06 20 0c 	ld  [ %i0 + 0xc ], %o4                         
    block,                                                            
    block_size,                                                       
    block->prev,                                                      
    block->prev == first_free_block ?                                 
      " (= first free)"                                               
        : (block->prev == free_list_head ? " (= head)" : ""),         
400095e8:	80 a6 00 0d 	cmp  %i0, %o5                                  
400095ec:	02 80 00 40 	be  400096ec <_Heap_Walk+0x478>                
400095f0:	96 15 22 00 	or  %l4, 0x200, %o3                            
    block->next,                                                      
    block->next == last_free_block ?                                  
400095f4:	de 05 60 08 	ld  [ %l5 + 8 ], %o7                           
  Heap_Block *const last_free_block = _Heap_Free_list_last( heap );   
  bool const prev_used = _Heap_Is_prev_used( block );                 
  uintptr_t const block_size = _Heap_Block_size( block );             
  Heap_Block *const next_block = _Heap_Block_at( block, block_size ); 
                                                                      
  (*printer)(                                                         
400095f8:	80 a3 00 0f 	cmp  %o4, %o7                                  
400095fc:	02 80 00 33 	be  400096c8 <_Heap_Walk+0x454>                
40009600:	80 a6 00 0f 	cmp  %i0, %o7                                  
      " (= first free)"                                               
        : (block->prev == free_list_head ? " (= head)" : ""),         
    block->next,                                                      
    block->next == last_free_block ?                                  
      " (= last free)"                                                
        : (block->next == free_list_tail ? " (= tail)" : "")          
40009604:	02 80 00 37 	be  400096e0 <_Heap_Walk+0x46c>                
40009608:	98 15 22 00 	or  %l4, 0x200, %o4                            
  Heap_Block *const last_free_block = _Heap_Free_list_last( heap );   
  bool const prev_used = _Heap_Is_prev_used( block );                 
  uintptr_t const block_size = _Heap_Block_size( block );             
  Heap_Block *const next_block = _Heap_Block_at( block, block_size ); 
                                                                      
  (*printer)(                                                         
4000960c:	d6 23 a0 5c 	st  %o3, [ %sp + 0x5c ]                        
40009610:	d8 23 a0 64 	st  %o4, [ %sp + 0x64 ]                        
40009614:	de 23 a0 60 	st  %o7, [ %sp + 0x60 ]                        
40009618:	90 10 00 19 	mov  %i1, %o0                                  
4000961c:	92 10 20 00 	clr  %o1                                       
40009620:	15 10 00 5a 	sethi  %hi(0x40016800), %o2                    
40009624:	96 10 00 15 	mov  %l5, %o3                                  
40009628:	94 12 a1 90 	or  %o2, 0x190, %o2                            
4000962c:	9f c5 c0 00 	call  %l7                                      
40009630:	98 10 00 16 	mov  %l6, %o4                                  
    block->next == last_free_block ?                                  
      " (= last free)"                                                
        : (block->next == free_list_tail ? " (= tail)" : "")          
  );                                                                  
                                                                      
  if ( block_size != next_block->prev_size ) {                        
40009634:	da 07 40 00 	ld  [ %i5 ], %o5                               
40009638:	80 a5 80 0d 	cmp  %l6, %o5                                  
4000963c:	12 80 00 19 	bne  400096a0 <_Heap_Walk+0x42c>               
40009640:	80 a6 a0 00 	cmp  %i2, 0                                    
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !prev_used ) {                                                 
40009644:	02 80 00 2d 	be  400096f8 <_Heap_Walk+0x484>                
40009648:	90 10 00 19 	mov  %i1, %o0                                  
  return &heap->free_list;                                            
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{                                                                     
  return _Heap_Free_list_head(heap)->next;                            
4000964c:	c4 06 20 08 	ld  [ %i0 + 8 ], %g2                           
)                                                                     
{                                                                     
  const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
  const Heap_Block *free_block = _Heap_Free_list_first( heap );       
                                                                      
  while ( free_block != free_list_tail ) {                            
40009650:	80 a6 00 02 	cmp  %i0, %g2                                  
40009654:	02 80 00 0b 	be  40009680 <_Heap_Walk+0x40c>                <== NEVER TAKEN
40009658:	92 10 20 01 	mov  1, %o1                                    
    if ( free_block == block ) {                                      
4000965c:	80 a5 40 02 	cmp  %l5, %g2                                  
40009660:	02 bf ff bd 	be  40009554 <_Heap_Walk+0x2e0>                
40009664:	80 a7 00 1d 	cmp  %i4, %i5                                  
      return true;                                                    
    }                                                                 
    free_block = free_block->next;                                    
40009668:	c4 00 a0 08 	ld  [ %g2 + 8 ], %g2                           
)                                                                     
{                                                                     
  const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
  const Heap_Block *free_block = _Heap_Free_list_first( heap );       
                                                                      
  while ( free_block != free_list_tail ) {                            
4000966c:	80 a6 00 02 	cmp  %i0, %g2                                  
40009670:	12 bf ff fc 	bne  40009660 <_Heap_Walk+0x3ec>               
40009674:	80 a5 40 02 	cmp  %l5, %g2                                  
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {                 
    (*printer)(                                                       
40009678:	90 10 00 19 	mov  %i1, %o0                                  
4000967c:	92 10 20 01 	mov  1, %o1                                    
40009680:	15 10 00 5a 	sethi  %hi(0x40016800), %o2                    
40009684:	96 10 00 15 	mov  %l5, %o3                                  
40009688:	9f c5 c0 00 	call  %l7                                      
4000968c:	94 12 a2 78 	or  %o2, 0x278, %o2                            
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
40009690:	10 bf ff 42 	b  40009398 <_Heap_Walk+0x124>                 
40009694:	82 10 20 00 	clr  %g1                                       
    }                                                                 
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
                                                                      
  return true;                                                        
40009698:	10 bf ff 05 	b  400092ac <_Heap_Walk+0x38>                  
4000969c:	82 10 20 01 	mov  1, %g1                                    
      " (= last free)"                                                
        : (block->next == free_list_tail ? " (= tail)" : "")          
  );                                                                  
                                                                      
  if ( block_size != next_block->prev_size ) {                        
    (*printer)(                                                       
400096a0:	fa 23 a0 5c 	st  %i5, [ %sp + 0x5c ]                        
400096a4:	90 10 00 19 	mov  %i1, %o0                                  
400096a8:	92 10 20 01 	mov  1, %o1                                    
400096ac:	15 10 00 5a 	sethi  %hi(0x40016800), %o2                    
400096b0:	96 10 00 15 	mov  %l5, %o3                                  
400096b4:	94 12 a1 c8 	or  %o2, 0x1c8, %o2                            
400096b8:	9f c5 c0 00 	call  %l7                                      
400096bc:	98 10 00 16 	mov  %l6, %o4                                  
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
400096c0:	10 bf ff 36 	b  40009398 <_Heap_Walk+0x124>                 
400096c4:	82 10 20 00 	clr  %g1                                       
  Heap_Block *const last_free_block = _Heap_Free_list_last( heap );   
  bool const prev_used = _Heap_Is_prev_used( block );                 
  uintptr_t const block_size = _Heap_Block_size( block );             
  Heap_Block *const next_block = _Heap_Block_at( block, block_size ); 
                                                                      
  (*printer)(                                                         
400096c8:	03 10 00 59 	sethi  %hi(0x40016400), %g1                    
400096cc:	10 bf ff d0 	b  4000960c <_Heap_Walk+0x398>                 
400096d0:	98 10 62 58 	or  %g1, 0x258, %o4	! 40016658 <__log2table+0x140>
400096d4:	03 10 00 59 	sethi  %hi(0x40016400), %g1                    
400096d8:	10 bf ff c7 	b  400095f4 <_Heap_Walk+0x380>                 
400096dc:	96 10 62 38 	or  %g1, 0x238, %o3	! 40016638 <__log2table+0x120>
      " (= first free)"                                               
        : (block->prev == free_list_head ? " (= head)" : ""),         
    block->next,                                                      
    block->next == last_free_block ?                                  
      " (= last free)"                                                
        : (block->next == free_list_tail ? " (= tail)" : "")          
400096e0:	03 10 00 59 	sethi  %hi(0x40016400), %g1                    
400096e4:	10 bf ff ca 	b  4000960c <_Heap_Walk+0x398>                 
400096e8:	98 10 62 68 	or  %g1, 0x268, %o4	! 40016668 <__log2table+0x150>
    block,                                                            
    block_size,                                                       
    block->prev,                                                      
    block->prev == first_free_block ?                                 
      " (= first free)"                                               
        : (block->prev == free_list_head ? " (= head)" : ""),         
400096ec:	17 10 00 59 	sethi  %hi(0x40016400), %o3                    
400096f0:	10 bf ff c1 	b  400095f4 <_Heap_Walk+0x380>                 
400096f4:	96 12 e2 48 	or  %o3, 0x248, %o3	! 40016648 <__log2table+0x130>
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !prev_used ) {                                                 
    (*printer)(                                                       
400096f8:	92 10 20 01 	mov  1, %o1                                    
400096fc:	15 10 00 5a 	sethi  %hi(0x40016800), %o2                    
40009700:	96 10 00 15 	mov  %l5, %o3                                  
40009704:	9f c5 c0 00 	call  %l7                                      
40009708:	94 12 a2 08 	or  %o2, 0x208, %o2                            
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
4000970c:	10 bf ff 23 	b  40009398 <_Heap_Walk+0x124>                 
40009710:	82 10 20 00 	clr  %g1                                       
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( block_size < min_block_size && is_not_last_block ) {         
40009714:	02 bf ff 9a 	be  4000957c <_Heap_Walk+0x308>                <== NEVER TAKEN
40009718:	80 a5 40 1d 	cmp  %l5, %i5                                  
      (*printer)(                                                     
4000971c:	90 10 00 19 	mov  %i1, %o0                                  
40009720:	92 10 20 01 	mov  1, %o1                                    
40009724:	96 10 00 15 	mov  %l5, %o3                                  
40009728:	15 10 00 5a 	sethi  %hi(0x40016800), %o2                    
4000972c:	98 10 00 16 	mov  %l6, %o4                                  
40009730:	94 12 a1 28 	or  %o2, 0x128, %o2                            
40009734:	9f c5 c0 00 	call  %l7                                      
40009738:	9a 10 00 10 	mov  %l0, %o5                                  
        block,                                                        
        block_size,                                                   
        min_block_size                                                
      );                                                              
                                                                      
      return false;                                                   
4000973c:	10 bf fe dc 	b  400092ac <_Heap_Walk+0x38>                  
40009740:	82 10 20 00 	clr  %g1                                       
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
      (*printer)(                                                     
40009744:	92 10 20 01 	mov  1, %o1                                    
40009748:	96 10 00 15 	mov  %l5, %o3                                  
4000974c:	15 10 00 5a 	sethi  %hi(0x40016800), %o2                    
40009750:	98 10 00 16 	mov  %l6, %o4                                  
40009754:	9f c5 c0 00 	call  %l7                                      
40009758:	94 12 a0 f8 	or  %o2, 0xf8, %o2                             
        "block 0x%08x: block size %u not page aligned\n",             
        block,                                                        
        block_size                                                    
      );                                                              
                                                                      
      return false;                                                   
4000975c:	10 bf fe d4 	b  400092ac <_Heap_Walk+0x38>                  
40009760:	82 10 20 00 	clr  %g1                                       
  const Heap_Control *heap,                                           
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block >= (uintptr_t) heap->first_block           
    && (uintptr_t) block <= (uintptr_t) heap->last_block;             
40009764:	80 a4 c0 1d 	cmp  %l3, %i5                                  
40009768:	0a bf ff 43 	bcs  40009474 <_Heap_Walk+0x200>               <== NEVER TAKEN
4000976c:	90 10 00 19 	mov  %i1, %o0                                  
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(                           
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return (value % alignment) == 0;                                    
40009770:	da 27 bf fc 	st  %o5, [ %fp + -4 ]                          
40009774:	90 07 60 08 	add  %i5, 8, %o0                               
40009778:	7f ff e0 fe 	call  40001b70 <.urem>                         
4000977c:	92 10 00 14 	mov  %l4, %o1                                  
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if (                                                              
40009780:	80 a2 20 00 	cmp  %o0, 0                                    
40009784:	12 80 00 36 	bne  4000985c <_Heap_Walk+0x5e8>               <== NEVER TAKEN
40009788:	da 07 bf fc 	ld  [ %fp + -4 ], %o5                          
    - HEAP_BLOCK_HEADER_SIZE);                                        
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;                
4000978c:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
40009790:	82 08 7f fe 	and  %g1, -2, %g1                              
  block->size_and_flag = size | flag;                                 
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & HEAP_PREV_BLOCK_USED;                 
40009794:	82 07 40 01 	add  %i5, %g1, %g1                             
40009798:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( _Heap_Is_used( free_block ) ) {                              
4000979c:	80 88 60 01 	btst  1, %g1                                   
400097a0:	12 80 00 27 	bne  4000983c <_Heap_Walk+0x5c8>               <== NEVER TAKEN
400097a4:	a4 10 00 1d 	mov  %i5, %l2                                  
400097a8:	10 80 00 19 	b  4000980c <_Heap_Walk+0x598>                 
400097ac:	82 10 00 18 	mov  %i0, %g1                                  
  const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
  const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
  const Heap_Block *prev_block = free_list_tail;                      
  const Heap_Block *free_block = first_free_block;                    
                                                                      
  while ( free_block != free_list_tail ) {                            
400097b0:	80 a6 00 1d 	cmp  %i0, %i5                                  
400097b4:	02 bf ff 37 	be  40009490 <_Heap_Walk+0x21c>                
400097b8:	80 a7 40 0d 	cmp  %i5, %o5                                  
  const Heap_Control *heap,                                           
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block >= (uintptr_t) heap->first_block           
    && (uintptr_t) block <= (uintptr_t) heap->last_block;             
400097bc:	0a bf ff 2e 	bcs  40009474 <_Heap_Walk+0x200>               
400097c0:	90 10 00 19 	mov  %i1, %o0                                  
400097c4:	80 a7 40 13 	cmp  %i5, %l3                                  
400097c8:	18 bf ff 2c 	bgu  40009478 <_Heap_Walk+0x204>               <== NEVER TAKEN
400097cc:	92 10 20 01 	mov  1, %o1                                    
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(                           
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return (value % alignment) == 0;                                    
400097d0:	da 27 bf fc 	st  %o5, [ %fp + -4 ]                          
400097d4:	90 07 60 08 	add  %i5, 8, %o0                               
400097d8:	7f ff e0 e6 	call  40001b70 <.urem>                         
400097dc:	92 10 00 14 	mov  %l4, %o1                                  
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if (                                                              
400097e0:	80 a2 20 00 	cmp  %o0, 0                                    
400097e4:	12 80 00 1e 	bne  4000985c <_Heap_Walk+0x5e8>               
400097e8:	da 07 bf fc 	ld  [ %fp + -4 ], %o5                          
    - HEAP_BLOCK_HEADER_SIZE);                                        
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;                
400097ec:	de 07 60 04 	ld  [ %i5 + 4 ], %o7                           
400097f0:	82 10 00 12 	mov  %l2, %g1                                  
400097f4:	9e 0b ff fe 	and  %o7, -2, %o7                              
  block->size_and_flag = size | flag;                                 
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & HEAP_PREV_BLOCK_USED;                 
400097f8:	9e 03 c0 1d 	add  %o7, %i5, %o7                             
400097fc:	de 03 e0 04 	ld  [ %o7 + 4 ], %o7                           
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( _Heap_Is_used( free_block ) ) {                              
40009800:	80 8b e0 01 	btst  1, %o7                                   
40009804:	12 80 00 0e 	bne  4000983c <_Heap_Walk+0x5c8>               
40009808:	a4 10 00 1d 	mov  %i5, %l2                                  
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( free_block->prev != prev_block ) {                           
4000980c:	d8 07 60 0c 	ld  [ %i5 + 0xc ], %o4                         
40009810:	80 a3 00 01 	cmp  %o4, %g1                                  
40009814:	22 bf ff e7 	be,a   400097b0 <_Heap_Walk+0x53c>             
40009818:	fa 07 60 08 	ld  [ %i5 + 8 ], %i5                           
      (*printer)(                                                     
4000981c:	90 10 00 19 	mov  %i1, %o0                                  
40009820:	92 10 20 01 	mov  1, %o1                                    
40009824:	15 10 00 5a 	sethi  %hi(0x40016800), %o2                    
40009828:	96 10 00 1d 	mov  %i5, %o3                                  
4000982c:	9f c5 c0 00 	call  %l7                                      
40009830:	94 12 a0 90 	or  %o2, 0x90, %o2                             
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
40009834:	10 bf fe d9 	b  40009398 <_Heap_Walk+0x124>                 
40009838:	82 10 20 00 	clr  %g1                                       
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( _Heap_Is_used( free_block ) ) {                              
      (*printer)(                                                     
4000983c:	90 10 00 19 	mov  %i1, %o0                                  
40009840:	92 10 20 01 	mov  1, %o1                                    
40009844:	15 10 00 5a 	sethi  %hi(0x40016800), %o2                    
40009848:	96 10 00 1d 	mov  %i5, %o3                                  
4000984c:	9f c5 c0 00 	call  %l7                                      
40009850:	94 12 a0 70 	or  %o2, 0x70, %o2                             
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
40009854:	10 bf fe d1 	b  40009398 <_Heap_Walk+0x124>                 
40009858:	82 10 20 00 	clr  %g1                                       
    }                                                                 
                                                                      
    if (                                                              
      !_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
    ) {                                                               
      (*printer)(                                                     
4000985c:	90 10 00 19 	mov  %i1, %o0                                  
40009860:	92 10 20 01 	mov  1, %o1                                    
40009864:	15 10 00 5a 	sethi  %hi(0x40016800), %o2                    
40009868:	96 10 00 1d 	mov  %i5, %o3                                  
4000986c:	9f c5 c0 00 	call  %l7                                      
40009870:	94 12 a0 40 	or  %o2, 0x40, %o2                             
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
40009874:	10 bf fe c9 	b  40009398 <_Heap_Walk+0x124>                 
40009878:	82 10 20 00 	clr  %g1                                       
                                                                      

40007c14 <_IO_Initialize_all_drivers>: _IO_Driver_address_table[index] = driver_table[index]; } void _IO_Initialize_all_drivers( void ) {
40007c14:	9d e3 bf a0 	save  %sp, -96, %sp                            
   rtems_device_major_number major;                                   
                                                                      
   for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )         
40007c18:	39 10 00 7e 	sethi  %hi(0x4001f800), %i4                    
40007c1c:	c2 07 20 18 	ld  [ %i4 + 0x18 ], %g1	! 4001f818 <_IO_Number_of_drivers>
40007c20:	ba 10 20 00 	clr  %i5                                       
40007c24:	80 a0 60 00 	cmp  %g1, 0                                    
40007c28:	02 80 00 0b 	be  40007c54 <_IO_Initialize_all_drivers+0x40> <== NEVER TAKEN
40007c2c:	b8 17 20 18 	or  %i4, 0x18, %i4                             
     (void) rtems_io_initialize( major, 0, NULL );                    
40007c30:	90 10 00 1d 	mov  %i5, %o0                                  
40007c34:	92 10 20 00 	clr  %o1                                       
40007c38:	40 00 15 91 	call  4000d27c <rtems_io_initialize>           
40007c3c:	94 10 20 00 	clr  %o2                                       
                                                                      
void _IO_Initialize_all_drivers( void )                               
{                                                                     
   rtems_device_major_number major;                                   
                                                                      
   for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )         
40007c40:	c2 07 00 00 	ld  [ %i4 ], %g1                               
40007c44:	ba 07 60 01 	inc  %i5                                       
40007c48:	80 a0 40 1d 	cmp  %g1, %i5                                  
40007c4c:	18 bf ff fa 	bgu  40007c34 <_IO_Initialize_all_drivers+0x20>
40007c50:	90 10 00 1d 	mov  %i5, %o0                                  
40007c54:	81 c7 e0 08 	ret                                            
40007c58:	81 e8 00 00 	restore                                        
                                                                      

40007b44 <_IO_Manager_initialization>: #include <rtems/score/wkspace.h> #include <string.h> void _IO_Manager_initialization(void) {
40007b44:	9d e3 bf a0 	save  %sp, -96, %sp                            
  uint32_t                    index;                                  
  rtems_driver_address_table *driver_table;                           
  uint32_t                    drivers_in_table;                       
  uint32_t                    number_of_drivers;                      
                                                                      
  driver_table      = rtems_configuration_get_device_driver_table();  
40007b48:	03 10 00 71 	sethi  %hi(0x4001c400), %g1                    
40007b4c:	82 10 60 18 	or  %g1, 0x18, %g1	! 4001c418 <Configuration>  
  drivers_in_table  = rtems_configuration_get_number_of_device_drivers();
40007b50:	f8 00 60 38 	ld  [ %g1 + 0x38 ], %i4                        
  number_of_drivers = rtems_configuration_get_maximum_drivers();      
40007b54:	f6 00 60 34 	ld  [ %g1 + 0x34 ], %i3                        
                                                                      
  /*                                                                  
   *  If the user claims there are less drivers than are actually in  
   *  the table, then let's just go with the table's count.           
   */                                                                 
  if ( number_of_drivers <= drivers_in_table )                        
40007b58:	80 a7 00 1b 	cmp  %i4, %i3                                  
40007b5c:	0a 80 00 08 	bcs  40007b7c <_IO_Manager_initialization+0x38>
40007b60:	fa 00 60 3c 	ld  [ %g1 + 0x3c ], %i5                        
   *  If the maximum number of driver is the same as the number in the
   *  table, then we do not have to copy the driver table.  They can't
   *  register any dynamically.                                       
   */                                                                 
  if ( number_of_drivers == drivers_in_table ) {                      
    _IO_Driver_address_table = driver_table;                          
40007b64:	03 10 00 7e 	sethi  %hi(0x4001f800), %g1                    
40007b68:	fa 20 60 1c 	st  %i5, [ %g1 + 0x1c ]	! 4001f81c <_IO_Driver_address_table>
    _IO_Number_of_drivers = number_of_drivers;                        
40007b6c:	03 10 00 7e 	sethi  %hi(0x4001f800), %g1                    
40007b70:	f8 20 60 18 	st  %i4, [ %g1 + 0x18 ]	! 4001f818 <_IO_Number_of_drivers>
    return;                                                           
40007b74:	81 c7 e0 08 	ret                                            
40007b78:	81 e8 00 00 	restore                                        
   *  have to allocate a new driver table and copy theirs to it.      
   */                                                                 
                                                                      
  _IO_Driver_address_table = (rtems_driver_address_table *)           
      _Workspace_Allocate_or_fatal_error(                             
        sizeof( rtems_driver_address_table ) * ( number_of_drivers )  
40007b7c:	83 2e e0 03 	sll  %i3, 3, %g1                               
40007b80:	b5 2e e0 05 	sll  %i3, 5, %i2                               
40007b84:	b4 26 80 01 	sub  %i2, %g1, %i2                             
   *  The application requested extra slots in the driver table, so we
   *  have to allocate a new driver table and copy theirs to it.      
   */                                                                 
                                                                      
  _IO_Driver_address_table = (rtems_driver_address_table *)           
      _Workspace_Allocate_or_fatal_error(                             
40007b88:	40 00 0d 2f 	call  4000b044 <_Workspace_Allocate_or_fatal_error>
40007b8c:	90 10 00 1a 	mov  %i2, %o0                                  
        sizeof( rtems_driver_address_table ) * ( number_of_drivers )  
      );                                                              
  _IO_Number_of_drivers = number_of_drivers;                          
40007b90:	03 10 00 7e 	sethi  %hi(0x4001f800), %g1                    
  /*                                                                  
   *  The application requested extra slots in the driver table, so we
   *  have to allocate a new driver table and copy theirs to it.      
   */                                                                 
                                                                      
  _IO_Driver_address_table = (rtems_driver_address_table *)           
40007b94:	33 10 00 7e 	sethi  %hi(0x4001f800), %i1                    
      _Workspace_Allocate_or_fatal_error(                             
        sizeof( rtems_driver_address_table ) * ( number_of_drivers )  
      );                                                              
  _IO_Number_of_drivers = number_of_drivers;                          
40007b98:	f6 20 60 18 	st  %i3, [ %g1 + 0x18 ]                        
  /*                                                                  
   *  The application requested extra slots in the driver table, so we
   *  have to allocate a new driver table and copy theirs to it.      
   */                                                                 
                                                                      
  _IO_Driver_address_table = (rtems_driver_address_table *)           
40007b9c:	d0 26 60 1c 	st  %o0, [ %i1 + 0x1c ]                        
      _Workspace_Allocate_or_fatal_error(                             
        sizeof( rtems_driver_address_table ) * ( number_of_drivers )  
      );                                                              
  _IO_Number_of_drivers = number_of_drivers;                          
                                                                      
  memset(                                                             
40007ba0:	92 10 20 00 	clr  %o1                                       
40007ba4:	40 00 21 75 	call  40010178 <memset>                        
40007ba8:	94 10 00 1a 	mov  %i2, %o2                                  
    _IO_Driver_address_table, 0,                                      
    sizeof( rtems_driver_address_table ) * ( number_of_drivers )      
  );                                                                  
                                                                      
  for ( index = 0 ; index < drivers_in_table ; index++ )              
40007bac:	80 a7 20 00 	cmp  %i4, 0                                    
40007bb0:	02 bf ff f1 	be  40007b74 <_IO_Manager_initialization+0x30> <== NEVER TAKEN
40007bb4:	c8 06 60 1c 	ld  [ %i1 + 0x1c ], %g4                        
#include <rtems/score/thread.h>                                       
#include <rtems/score/wkspace.h>                                      
                                                                      
#include <string.h>                                                   
                                                                      
void _IO_Manager_initialization(void)                                 
40007bb8:	85 2f 20 03 	sll  %i4, 3, %g2                               
40007bbc:	b7 2f 20 05 	sll  %i4, 5, %i3                               
40007bc0:	82 10 20 00 	clr  %g1                                       
40007bc4:	b6 26 c0 02 	sub  %i3, %g2, %i3                             
    _IO_Driver_address_table, 0,                                      
    sizeof( rtems_driver_address_table ) * ( number_of_drivers )      
  );                                                                  
                                                                      
  for ( index = 0 ; index < drivers_in_table ; index++ )              
    _IO_Driver_address_table[index] = driver_table[index];            
40007bc8:	c4 07 40 01 	ld  [ %i5 + %g1 ], %g2                         
40007bcc:	86 07 40 01 	add  %i5, %g1, %g3                             
40007bd0:	c4 21 00 01 	st  %g2, [ %g4 + %g1 ]                         
40007bd4:	f8 00 e0 04 	ld  [ %g3 + 4 ], %i4                           
40007bd8:	84 01 00 01 	add  %g4, %g1, %g2                             
40007bdc:	f8 20 a0 04 	st  %i4, [ %g2 + 4 ]                           
40007be0:	f8 00 e0 08 	ld  [ %g3 + 8 ], %i4                           
40007be4:	82 00 60 18 	add  %g1, 0x18, %g1                            
40007be8:	f8 20 a0 08 	st  %i4, [ %g2 + 8 ]                           
40007bec:	f8 00 e0 0c 	ld  [ %g3 + 0xc ], %i4                         
  memset(                                                             
    _IO_Driver_address_table, 0,                                      
    sizeof( rtems_driver_address_table ) * ( number_of_drivers )      
  );                                                                  
                                                                      
  for ( index = 0 ; index < drivers_in_table ; index++ )              
40007bf0:	80 a0 40 1b 	cmp  %g1, %i3                                  
    _IO_Driver_address_table[index] = driver_table[index];            
40007bf4:	f8 20 a0 0c 	st  %i4, [ %g2 + 0xc ]                         
40007bf8:	f8 00 e0 10 	ld  [ %g3 + 0x10 ], %i4                        
40007bfc:	f8 20 a0 10 	st  %i4, [ %g2 + 0x10 ]                        
40007c00:	c6 00 e0 14 	ld  [ %g3 + 0x14 ], %g3                        
  memset(                                                             
    _IO_Driver_address_table, 0,                                      
    sizeof( rtems_driver_address_table ) * ( number_of_drivers )      
  );                                                                  
                                                                      
  for ( index = 0 ; index < drivers_in_table ; index++ )              
40007c04:	12 bf ff f1 	bne  40007bc8 <_IO_Manager_initialization+0x84>
40007c08:	c6 20 a0 14 	st  %g3, [ %g2 + 0x14 ]                        
40007c0c:	81 c7 e0 08 	ret                                            
40007c10:	81 e8 00 00 	restore                                        
                                                                      

4000890c <_Internal_error_Occurred>: void _Internal_error_Occurred( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) {
4000890c:	9d e3 bf 90 	save  %sp, -112, %sp                           
  Internal_errors_t      error                                        
)                                                                     
{                                                                     
  User_extensions_Fatal_context ctx = { source, is_internal, error }; 
                                                                      
  _User_extensions_Iterate( &ctx, _User_extensions_Fatal_visitor );   
40008910:	13 10 00 2a 	sethi  %hi(0x4000a800), %o1                    
40008914:	90 07 bf f4 	add  %fp, -12, %o0                             
40008918:	92 12 62 7c 	or  %o1, 0x27c, %o1                            
  Internal_errors_Source source,                                      
  bool                   is_internal,                                 
  Internal_errors_t      error                                        
)                                                                     
{                                                                     
  User_extensions_Fatal_context ctx = { source, is_internal, error }; 
4000891c:	f0 27 bf f4 	st  %i0, [ %fp + -12 ]                         
40008920:	f2 2f bf f8 	stb  %i1, [ %fp + -8 ]                         
                                                                      
  _User_extensions_Iterate( &ctx, _User_extensions_Fatal_visitor );   
40008924:	40 00 08 61 	call  4000aaa8 <_User_extensions_Iterate>      
40008928:	f4 27 bf fc 	st  %i2, [ %fp + -4 ]                          
  _User_extensions_Fatal( the_source, is_internal, the_error );       
                                                                      
  _Internal_errors_What_happened.the_source  = the_source;            
4000892c:	05 10 00 7c 	sethi  %hi(0x4001f000), %g2                    <== NOT EXECUTED
40008930:	82 10 a3 bc 	or  %g2, 0x3bc, %g1	! 4001f3bc <_Internal_errors_What_happened><== NOT EXECUTED
40008934:	f0 20 a3 bc 	st  %i0, [ %g2 + 0x3bc ]                       <== NOT EXECUTED
  _Internal_errors_What_happened.is_internal = is_internal;           
40008938:	f2 28 60 04 	stb  %i1, [ %g1 + 4 ]                          <== NOT EXECUTED
  _Internal_errors_What_happened.the_error   = the_error;             
4000893c:	f4 20 60 08 	st  %i2, [ %g1 + 8 ]                           <== NOT EXECUTED
                                                                      
RTEMS_INLINE_ROUTINE void _System_state_Set (                         
  System_state_Codes state                                            
)                                                                     
{                                                                     
  _System_state_Current = state;                                      
40008940:	84 10 20 05 	mov  5, %g2                                    <== NOT EXECUTED
40008944:	03 10 00 7c 	sethi  %hi(0x4001f000), %g1                    <== NOT EXECUTED
                                                                      
  _System_state_Set( SYSTEM_STATE_FAILED );                           
                                                                      
  _CPU_Fatal_halt( the_error );                                       
40008948:	7f ff e5 d7 	call  400020a4 <sparc_disable_interrupts>      <== NOT EXECUTED
4000894c:	c4 20 63 c8 	st  %g2, [ %g1 + 0x3c8 ]	! 4001f3c8 <_System_state_Current><== NOT EXECUTED
40008950:	82 10 00 08 	mov  %o0, %g1                                  <== NOT EXECUTED
40008954:	30 80 00 00 	b,a   40008954 <_Internal_error_Occurred+0x48> <== NOT EXECUTED
                                                                      

400089c4 <_Objects_Allocate>: #endif Objects_Control *_Objects_Allocate( Objects_Information *information ) {
400089c4:	9d e3 bf a0 	save  %sp, -96, %sp                            
   *  If the application is using the optional manager stubs and      
   *  still attempts to create the object, the information block      
   *  should be all zeroed out because it is in the BSS.  So let's    
   *  check that code for this manager is even present.               
   */                                                                 
  if ( information->size == 0 )                                       
400089c8:	c2 06 20 18 	ld  [ %i0 + 0x18 ], %g1                        
400089cc:	80 a0 60 00 	cmp  %g1, 0                                    
400089d0:	02 80 00 26 	be  40008a68 <_Objects_Allocate+0xa4>          <== NEVER TAKEN
400089d4:	ba 10 00 18 	mov  %i0, %i5                                  
                                                                      
  /*                                                                  
   *  OK.  The manager should be initialized and configured to have objects.
   *  With any luck, it is safe to attempt to allocate an object.     
   */                                                                 
  the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
400089d8:	b8 06 20 20 	add  %i0, 0x20, %i4                            
400089dc:	7f ff fd 4c 	call  40007f0c <_Chain_Get>                    
400089e0:	90 10 00 1c 	mov  %i4, %o0                                  
                                                                      
  if ( information->auto_extend ) {                                   
400089e4:	c2 0f 60 12 	ldub  [ %i5 + 0x12 ], %g1                      
400089e8:	80 a0 60 00 	cmp  %g1, 0                                    
400089ec:	02 80 00 16 	be  40008a44 <_Objects_Allocate+0x80>          
400089f0:	b0 10 00 08 	mov  %o0, %i0                                  
    /*                                                                
     *  If the list is empty then we are out of objects and need to   
     *  extend information base.                                      
     */                                                               
                                                                      
    if ( !the_object ) {                                              
400089f4:	80 a2 20 00 	cmp  %o0, 0                                    
400089f8:	02 80 00 15 	be  40008a4c <_Objects_Allocate+0x88>          
400089fc:	01 00 00 00 	nop                                            
    }                                                                 
                                                                      
    if ( the_object ) {                                               
      uint32_t   block;                                               
                                                                      
      block = (uint32_t) _Objects_Get_index( the_object->id ) -       
40008a00:	c4 07 60 08 	ld  [ %i5 + 8 ], %g2                           
40008a04:	d0 06 20 08 	ld  [ %i0 + 8 ], %o0                           
              _Objects_Get_index( information->minimum_id );          
      block /= information->allocation_size;                          
40008a08:	d2 17 60 14 	lduh  [ %i5 + 0x14 ], %o1                      
    }                                                                 
                                                                      
    if ( the_object ) {                                               
      uint32_t   block;                                               
                                                                      
      block = (uint32_t) _Objects_Get_index( the_object->id ) -       
40008a0c:	03 00 00 3f 	sethi  %hi(0xfc00), %g1                        
40008a10:	82 10 63 ff 	or  %g1, 0x3ff, %g1	! ffff <PROM_START+0xffff> 
40008a14:	90 0a 00 01 	and  %o0, %g1, %o0                             
40008a18:	82 08 80 01 	and  %g2, %g1, %g1                             
              _Objects_Get_index( information->minimum_id );          
      block /= information->allocation_size;                          
40008a1c:	40 00 3f 96 	call  40018874 <.udiv>                         
40008a20:	90 22 00 01 	sub  %o0, %g1, %o0                             
                                                                      
      information->inactive_per_block[ block ]--;                     
40008a24:	c2 07 60 30 	ld  [ %i5 + 0x30 ], %g1                        
40008a28:	91 2a 20 02 	sll  %o0, 2, %o0                               
40008a2c:	c6 00 40 08 	ld  [ %g1 + %o0 ], %g3                         
      information->inactive--;                                        
40008a30:	c4 17 60 2c 	lduh  [ %i5 + 0x2c ], %g2                      
                                                                      
      block = (uint32_t) _Objects_Get_index( the_object->id ) -       
              _Objects_Get_index( information->minimum_id );          
      block /= information->allocation_size;                          
                                                                      
      information->inactive_per_block[ block ]--;                     
40008a34:	86 00 ff ff 	add  %g3, -1, %g3                              
40008a38:	c6 20 40 08 	st  %g3, [ %g1 + %o0 ]                         
      information->inactive--;                                        
40008a3c:	82 00 bf ff 	add  %g2, -1, %g1                              
40008a40:	c2 37 60 2c 	sth  %g1, [ %i5 + 0x2c ]                       
    );                                                                
  }                                                                   
#endif                                                                
                                                                      
  return the_object;                                                  
}                                                                     
40008a44:	81 c7 e0 08 	ret                                            
40008a48:	81 e8 00 00 	restore                                        
     *  If the list is empty then we are out of objects and need to   
     *  extend information base.                                      
     */                                                               
                                                                      
    if ( !the_object ) {                                              
      _Objects_Extend_information( information );                     
40008a4c:	40 00 00 10 	call  40008a8c <_Objects_Extend_information>   
40008a50:	90 10 00 1d 	mov  %i5, %o0                                  
      the_object =  (Objects_Control *) _Chain_Get( &information->Inactive );
40008a54:	7f ff fd 2e 	call  40007f0c <_Chain_Get>                    
40008a58:	90 10 00 1c 	mov  %i4, %o0                                  
    }                                                                 
                                                                      
    if ( the_object ) {                                               
40008a5c:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40008a60:	32 bf ff e9 	bne,a   40008a04 <_Objects_Allocate+0x40>      
40008a64:	c4 07 60 08 	ld  [ %i5 + 8 ], %g2                           
   *  still attempts to create the object, the information block      
   *  should be all zeroed out because it is in the BSS.  So let's    
   *  check that code for this manager is even present.               
   */                                                                 
  if ( information->size == 0 )                                       
    return NULL;                                                      
40008a68:	81 c7 e0 08 	ret                                            
40008a6c:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

40008a8c <_Objects_Extend_information>: */ void _Objects_Extend_information( Objects_Information *information ) {
40008a8c:	9d e3 bf 90 	save  %sp, -112, %sp                           
  minimum_index = _Objects_Get_index( information->minimum_id );      
  index_base    = minimum_index;                                      
  block         = 0;                                                  
                                                                      
  /* if ( information->maximum < minimum_index ) */                   
  if ( information->object_blocks == NULL )                           
40008a90:	f2 06 20 34 	ld  [ %i0 + 0x34 ], %i1                        
  /*                                                                  
   *  Search for a free block of indexes. If we do NOT need to allocate or
   *  extend the block table, then we will change do_extend.          
   */                                                                 
  do_extend     = true;                                               
  minimum_index = _Objects_Get_index( information->minimum_id );      
40008a94:	e0 16 20 0a 	lduh  [ %i0 + 0xa ], %l0                       
  index_base    = minimum_index;                                      
  block         = 0;                                                  
                                                                      
  /* if ( information->maximum < minimum_index ) */                   
  if ( information->object_blocks == NULL )                           
40008a98:	80 a6 60 00 	cmp  %i1, 0                                    
40008a9c:	02 80 00 a1 	be  40008d20 <_Objects_Extend_information+0x294>
40008aa0:	e2 16 20 10 	lduh  [ %i0 + 0x10 ], %l1                      
    block_count = 0;                                                  
  else {                                                              
    block_count = information->maximum / information->allocation_size;
40008aa4:	f6 16 20 14 	lduh  [ %i0 + 0x14 ], %i3                      
40008aa8:	a3 2c 60 10 	sll  %l1, 0x10, %l1                            
40008aac:	92 10 00 1b 	mov  %i3, %o1                                  
40008ab0:	40 00 3f 71 	call  40018874 <.udiv>                         
40008ab4:	91 34 60 10 	srl  %l1, 0x10, %o0                            
40008ab8:	91 2a 20 10 	sll  %o0, 0x10, %o0                            
40008abc:	b5 32 20 10 	srl  %o0, 0x10, %i2                            
                                                                      
    for ( ; block < block_count; block++ ) {                          
40008ac0:	80 a6 a0 00 	cmp  %i2, 0                                    
40008ac4:	02 80 00 af 	be  40008d80 <_Objects_Extend_information+0x2f4><== NEVER TAKEN
40008ac8:	90 10 00 1b 	mov  %i3, %o0                                  
      if ( information->object_blocks[ block ] == NULL ) {            
40008acc:	c2 06 40 00 	ld  [ %i1 ], %g1                               
40008ad0:	80 a0 60 00 	cmp  %g1, 0                                    
40008ad4:	02 80 00 b1 	be  40008d98 <_Objects_Extend_information+0x30c><== NEVER TAKEN
40008ad8:	b8 10 00 10 	mov  %l0, %i4                                  
   *  extend the block table, then we will change do_extend.          
   */                                                                 
  do_extend     = true;                                               
  minimum_index = _Objects_Get_index( information->minimum_id );      
  index_base    = minimum_index;                                      
  block         = 0;                                                  
40008adc:	10 80 00 06 	b  40008af4 <_Objects_Extend_information+0x68> 
40008ae0:	ba 10 20 00 	clr  %i5                                       
    block_count = 0;                                                  
  else {                                                              
    block_count = information->maximum / information->allocation_size;
                                                                      
    for ( ; block < block_count; block++ ) {                          
      if ( information->object_blocks[ block ] == NULL ) {            
40008ae4:	c2 06 40 01 	ld  [ %i1 + %g1 ], %g1                         
40008ae8:	80 a0 60 00 	cmp  %g1, 0                                    
40008aec:	22 80 00 08 	be,a   40008b0c <_Objects_Extend_information+0x80>
40008af0:	b6 10 20 00 	clr  %i3                                       
  if ( information->object_blocks == NULL )                           
    block_count = 0;                                                  
  else {                                                              
    block_count = information->maximum / information->allocation_size;
                                                                      
    for ( ; block < block_count; block++ ) {                          
40008af4:	ba 07 60 01 	inc  %i5                                       
      if ( information->object_blocks[ block ] == NULL ) {            
        do_extend = false;                                            
        break;                                                        
      } else                                                          
        index_base += information->allocation_size;                   
40008af8:	b8 07 00 1b 	add  %i4, %i3, %i4                             
  if ( information->object_blocks == NULL )                           
    block_count = 0;                                                  
  else {                                                              
    block_count = information->maximum / information->allocation_size;
                                                                      
    for ( ; block < block_count; block++ ) {                          
40008afc:	80 a6 80 1d 	cmp  %i2, %i5                                  
40008b00:	18 bf ff f9 	bgu  40008ae4 <_Objects_Extend_information+0x58>
40008b04:	83 2f 60 02 	sll  %i5, 2, %g1                               
                                                                      
  /*                                                                  
   *  Search for a free block of indexes. If we do NOT need to allocate or
   *  extend the block table, then we will change do_extend.          
   */                                                                 
  do_extend     = true;                                               
40008b08:	b6 10 20 01 	mov  1, %i3                                    
      } else                                                          
        index_base += information->allocation_size;                   
    }                                                                 
  }                                                                   
                                                                      
  maximum = (uint32_t) information->maximum + information->allocation_size;
40008b0c:	b3 34 60 10 	srl  %l1, 0x10, %i1                            
  /*                                                                  
   *  We need to limit the number of objects to the maximum number    
   *  representable in the index portion of the object Id.  In the    
   *  case of 16-bit Ids, this is only 256 object instances.          
   */                                                                 
  if ( maximum > OBJECTS_ID_FINAL_INDEX ) {                           
40008b10:	03 00 00 3f 	sethi  %hi(0xfc00), %g1                        
      } else                                                          
        index_base += information->allocation_size;                   
    }                                                                 
  }                                                                   
                                                                      
  maximum = (uint32_t) information->maximum + information->allocation_size;
40008b14:	b2 06 40 08 	add  %i1, %o0, %i1                             
  /*                                                                  
   *  We need to limit the number of objects to the maximum number    
   *  representable in the index portion of the object Id.  In the    
   *  case of 16-bit Ids, this is only 256 object instances.          
   */                                                                 
  if ( maximum > OBJECTS_ID_FINAL_INDEX ) {                           
40008b18:	82 10 63 ff 	or  %g1, 0x3ff, %g1                            
40008b1c:	80 a6 40 01 	cmp  %i1, %g1                                  
40008b20:	18 80 00 9c 	bgu  40008d90 <_Objects_Extend_information+0x304>
40008b24:	01 00 00 00 	nop                                            
                                                                      
  /*                                                                  
   * Allocate the name table, and the objects and if it fails either return or
   * generate a fatal error depending on auto-extending being active. 
   */                                                                 
  block_size = information->allocation_size * information->size;      
40008b28:	40 00 3f 19 	call  4001878c <.umul>                         
40008b2c:	d2 06 20 18 	ld  [ %i0 + 0x18 ], %o1                        
  if ( information->auto_extend ) {                                   
40008b30:	c2 0e 20 12 	ldub  [ %i0 + 0x12 ], %g1                      
40008b34:	80 a0 60 00 	cmp  %g1, 0                                    
40008b38:	02 80 00 6d 	be  40008cec <_Objects_Extend_information+0x260>
40008b3c:	01 00 00 00 	nop                                            
    new_object_block = _Workspace_Allocate( block_size );             
40008b40:	40 00 09 33 	call  4000b00c <_Workspace_Allocate>           
40008b44:	01 00 00 00 	nop                                            
    if ( !new_object_block )                                          
40008b48:	a2 92 20 00 	orcc  %o0, 0, %l1                              
40008b4c:	02 80 00 91 	be  40008d90 <_Objects_Extend_information+0x304>
40008b50:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  /*                                                                  
   *  Do we need to grow the tables?                                  
   */                                                                 
  if ( do_extend ) {                                                  
40008b54:	80 8e e0 ff 	btst  0xff, %i3                                
40008b58:	22 80 00 42 	be,a   40008c60 <_Objects_Extend_information+0x1d4>
40008b5c:	c2 06 20 34 	ld  [ %i0 + 0x34 ], %g1                        
     *  Allocate the tables and break it up.                          
     */                                                               
    block_size = block_count *                                        
           (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
          ((maximum + minimum_index) * sizeof(Objects_Control *));    
    if ( information->auto_extend ) {                                 
40008b60:	c2 0e 20 12 	ldub  [ %i0 + 0x12 ], %g1                      
     */                                                               
                                                                      
    /*                                                                
     *  Up the block count and maximum                                
     */                                                               
    block_count++;                                                    
40008b64:	b6 06 a0 01 	add  %i2, 1, %i3                               
     *  Allocate the tables and break it up.                          
     */                                                               
    block_size = block_count *                                        
           (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
          ((maximum + minimum_index) * sizeof(Objects_Control *));    
    if ( information->auto_extend ) {                                 
40008b68:	80 a0 60 00 	cmp  %g1, 0                                    
                                                                      
    /*                                                                
     *  Allocate the tables and break it up.                          
     */                                                               
    block_size = block_count *                                        
           (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
40008b6c:	91 2e e0 01 	sll  %i3, 1, %o0                               
40008b70:	90 02 00 1b 	add  %o0, %i3, %o0                             
          ((maximum + minimum_index) * sizeof(Objects_Control *));    
40008b74:	90 06 40 08 	add  %i1, %o0, %o0                             
                                                                      
    /*                                                                
     *  Allocate the tables and break it up.                          
     */                                                               
    block_size = block_count *                                        
           (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
40008b78:	90 02 00 10 	add  %o0, %l0, %o0                             
          ((maximum + minimum_index) * sizeof(Objects_Control *));    
    if ( information->auto_extend ) {                                 
40008b7c:	12 80 00 60 	bne  40008cfc <_Objects_Extend_information+0x270>
40008b80:	91 2a 20 02 	sll  %o0, 2, %o0                               
      if ( !object_blocks ) {                                         
        _Workspace_Free( new_object_block );                          
        return;                                                       
      }                                                               
    } else {                                                          
      object_blocks = _Workspace_Allocate_or_fatal_error( block_size );
40008b84:	40 00 09 30 	call  4000b044 <_Workspace_Allocate_or_fatal_error>
40008b88:	01 00 00 00 	nop                                            
40008b8c:	a4 10 00 08 	mov  %o0, %l2                                  
     *  Take the block count down. Saves all the (block_count - 1)    
     *  in the copies.                                                
     */                                                               
    block_count--;                                                    
                                                                      
    if ( information->maximum > minimum_index ) {                     
40008b90:	c2 16 20 10 	lduh  [ %i0 + 0x10 ], %g1                      
                                                                      
    /*                                                                
     *  Break the block into the various sections.                    
     */                                                               
    inactive_per_block = (uint32_t *) _Addresses_Add_offset(          
        object_blocks, block_count * sizeof(void*) );                 
40008b94:	b7 2e e0 02 	sll  %i3, 2, %i3                               
     *  Take the block count down. Saves all the (block_count - 1)    
     *  in the copies.                                                
     */                                                               
    block_count--;                                                    
                                                                      
    if ( information->maximum > minimum_index ) {                     
40008b98:	80 a4 00 01 	cmp  %l0, %g1                                  
40008b9c:	a6 04 80 1b 	add  %l2, %i3, %l3                             
40008ba0:	0a 80 00 67 	bcs  40008d3c <_Objects_Extend_information+0x2b0>
40008ba4:	b6 04 c0 1b 	add  %l3, %i3, %i3                             
 *    information     - object information table                      
 *                                                                    
 *  Output parameters:  NONE                                          
 */                                                                   
                                                                      
void _Objects_Extend_information(                                     
40008ba8:	85 2c 20 02 	sll  %l0, 2, %g2                               
    } else {                                                          
                                                                      
      /*                                                              
       *  Deal with the special case of the 0 to minimum_index        
       */                                                             
      for ( index = 0; index < minimum_index; index++ ) {             
40008bac:	80 a4 20 00 	cmp  %l0, 0                                    
40008bb0:	02 80 00 07 	be  40008bcc <_Objects_Extend_information+0x140><== NEVER TAKEN
40008bb4:	82 10 20 00 	clr  %g1                                       
        local_table[ index ] = NULL;                                  
40008bb8:	c0 20 40 1b 	clr  [ %g1 + %i3 ]                             
40008bbc:	82 00 60 04 	add  %g1, 4, %g1                               
    } else {                                                          
                                                                      
      /*                                                              
       *  Deal with the special case of the 0 to minimum_index        
       */                                                             
      for ( index = 0; index < minimum_index; index++ ) {             
40008bc0:	80 a0 40 02 	cmp  %g1, %g2                                  
40008bc4:	32 bf ff fe 	bne,a   40008bbc <_Objects_Extend_information+0x130><== NEVER TAKEN
40008bc8:	c0 20 40 1b 	clr  [ %g1 + %i3 ]                             <== NOT EXECUTED
40008bcc:	b5 2e a0 02 	sll  %i2, 2, %i2                               
     */                                                               
    object_blocks[block_count] = NULL;                                
    inactive_per_block[block_count] = 0;                              
                                                                      
    for ( index=index_base ;                                          
          index < ( information->allocation_size + index_base );      
40008bd0:	c6 16 20 14 	lduh  [ %i0 + 0x14 ], %g3                      
    }                                                                 
                                                                      
    /*                                                                
     *  Initialise the new entries in the table.                      
     */                                                               
    object_blocks[block_count] = NULL;                                
40008bd4:	c0 24 80 1a 	clr  [ %l2 + %i2 ]                             
    inactive_per_block[block_count] = 0;                              
                                                                      
    for ( index=index_base ;                                          
          index < ( information->allocation_size + index_base );      
40008bd8:	82 07 00 03 	add  %i4, %g3, %g1                             
     *  Initialise the new entries in the table.                      
     */                                                               
    object_blocks[block_count] = NULL;                                
    inactive_per_block[block_count] = 0;                              
                                                                      
    for ( index=index_base ;                                          
40008bdc:	80 a7 00 01 	cmp  %i4, %g1                                  
40008be0:	1a 80 00 0b 	bcc  40008c0c <_Objects_Extend_information+0x180><== NEVER TAKEN
40008be4:	c0 24 c0 1a 	clr  [ %l3 + %i2 ]                             
 *    information     - object information table                      
 *                                                                    
 *  Output parameters:  NONE                                          
 */                                                                   
                                                                      
void _Objects_Extend_information(                                     
40008be8:	85 2f 20 02 	sll  %i4, 2, %g2                               
40008bec:	87 28 e0 02 	sll  %g3, 2, %g3                               
40008bf0:	84 06 c0 02 	add  %i3, %g2, %g2                             
40008bf4:	82 10 20 00 	clr  %g1                                       
    inactive_per_block[block_count] = 0;                              
                                                                      
    for ( index=index_base ;                                          
          index < ( information->allocation_size + index_base );      
          index++ ) {                                                 
      local_table[ index ] = NULL;                                    
40008bf8:	c0 20 80 01 	clr  [ %g2 + %g1 ]                             
40008bfc:	82 00 60 04 	add  %g1, 4, %g1                               
     *  Initialise the new entries in the table.                      
     */                                                               
    object_blocks[block_count] = NULL;                                
    inactive_per_block[block_count] = 0;                              
                                                                      
    for ( index=index_base ;                                          
40008c00:	80 a0 40 03 	cmp  %g1, %g3                                  
40008c04:	32 bf ff fe 	bne,a   40008bfc <_Objects_Extend_information+0x170>
40008c08:	c0 20 80 01 	clr  [ %g2 + %g1 ]                             
          index < ( information->allocation_size + index_base );      
          index++ ) {                                                 
      local_table[ index ] = NULL;                                    
    }                                                                 
                                                                      
    _ISR_Disable( level );                                            
40008c0c:	7f ff e5 26 	call  400020a4 <sparc_disable_interrupts>      
40008c10:	01 00 00 00 	nop                                            
  uint32_t         the_class,                                         
  uint32_t         node,                                              
  uint32_t         index                                              
)                                                                     
{                                                                     
  return (( (Objects_Id) the_api )   << OBJECTS_API_START_BIT)   |    
40008c14:	c6 06 00 00 	ld  [ %i0 ], %g3                               
                                                                      
    information->object_blocks = object_blocks;                       
    information->inactive_per_block = inactive_per_block;             
    information->local_table = local_table;                           
    information->maximum = (Objects_Maximum) maximum;                 
    information->maximum_id = _Objects_Build_id(                      
40008c18:	c4 16 20 04 	lduh  [ %i0 + 4 ], %g2                         
      local_table[ index ] = NULL;                                    
    }                                                                 
                                                                      
    _ISR_Disable( level );                                            
                                                                      
    old_tables = information->object_blocks;                          
40008c1c:	f4 06 20 34 	ld  [ %i0 + 0x34 ], %i2                        
                                                                      
    information->object_blocks = object_blocks;                       
    information->inactive_per_block = inactive_per_block;             
    information->local_table = local_table;                           
    information->maximum = (Objects_Maximum) maximum;                 
40008c20:	f2 36 20 10 	sth  %i1, [ %i0 + 0x10 ]                       
40008c24:	87 28 e0 18 	sll  %g3, 0x18, %g3                            
         (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |    
40008c28:	85 28 a0 1b 	sll  %g2, 0x1b, %g2                            
                                                                      
    _ISR_Disable( level );                                            
                                                                      
    old_tables = information->object_blocks;                          
                                                                      
    information->object_blocks = object_blocks;                       
40008c2c:	e4 26 20 34 	st  %l2, [ %i0 + 0x34 ]                        
    information->inactive_per_block = inactive_per_block;             
40008c30:	e6 26 20 30 	st  %l3, [ %i0 + 0x30 ]                        
    information->local_table = local_table;                           
40008c34:	f6 26 20 1c 	st  %i3, [ %i0 + 0x1c ]                        
  uint32_t         the_class,                                         
  uint32_t         node,                                              
  uint32_t         index                                              
)                                                                     
{                                                                     
  return (( (Objects_Id) the_api )   << OBJECTS_API_START_BIT)   |    
40008c38:	03 00 00 40 	sethi  %hi(0x10000), %g1                       
40008c3c:	82 10 c0 01 	or  %g3, %g1, %g1                              
         (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |    
40008c40:	82 10 40 02 	or  %g1, %g2, %g1                              
  uint32_t         the_class,                                         
  uint32_t         node,                                              
  uint32_t         index                                              
)                                                                     
{                                                                     
  return (( (Objects_Id) the_api )   << OBJECTS_API_START_BIT)   |    
40008c44:	b2 10 40 19 	or  %g1, %i1, %i1                              
    information->maximum = (Objects_Maximum) maximum;                 
    information->maximum_id = _Objects_Build_id(                      
40008c48:	f2 26 20 0c 	st  %i1, [ %i0 + 0xc ]                         
        information->the_class,                                       
        _Objects_Local_node,                                          
        information->maximum                                          
      );                                                              
                                                                      
    _ISR_Enable( level );                                             
40008c4c:	7f ff e5 1a 	call  400020b4 <sparc_enable_interrupts>       
40008c50:	01 00 00 00 	nop                                            
                                                                      
    _Workspace_Free( old_tables );                                    
40008c54:	40 00 08 f6 	call  4000b02c <_Workspace_Free>               
40008c58:	90 10 00 1a 	mov  %i2, %o0                                  
  }                                                                   
                                                                      
  /*                                                                  
   *  Assign the new object block to the object block table.          
   */                                                                 
  information->object_blocks[ block ] = new_object_block;             
40008c5c:	c2 06 20 34 	ld  [ %i0 + 0x34 ], %g1                        
40008c60:	bb 2f 60 02 	sll  %i5, 2, %i5                               
40008c64:	e2 20 40 1d 	st  %l1, [ %g1 + %i5 ]                         
                                                                      
  /*                                                                  
   *  Initialize objects .. add to a local chain first.               
   */                                                                 
  _Chain_Initialize(                                                  
40008c68:	c2 06 20 34 	ld  [ %i0 + 0x34 ], %g1                        
40008c6c:	d4 16 20 14 	lduh  [ %i0 + 0x14 ], %o2                      
40008c70:	d2 00 40 1d 	ld  [ %g1 + %i5 ], %o1                         
40008c74:	d6 06 20 18 	ld  [ %i0 + 0x18 ], %o3                        
40008c78:	90 07 bf f4 	add  %fp, -12, %o0                             
40008c7c:	7f ff fc b4 	call  40007f4c <_Chain_Initialize>             
40008c80:	35 00 00 40 	sethi  %hi(0x10000), %i2                       
  /*                                                                  
   *  Move from the local chain, initialise, then append to the inactive chain
   */                                                                 
  index = index_base;                                                 
                                                                      
  while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
40008c84:	10 80 00 0d 	b  40008cb8 <_Objects_Extend_information+0x22c>
40008c88:	b6 06 20 20 	add  %i0, 0x20, %i3                            
                                                                      
    the_object->id = _Objects_Build_id(                               
40008c8c:	c6 16 20 04 	lduh  [ %i0 + 4 ], %g3                         
40008c90:	85 28 a0 18 	sll  %g2, 0x18, %g2                            
         (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |    
40008c94:	87 28 e0 1b 	sll  %g3, 0x1b, %g3                            
  uint32_t         the_class,                                         
  uint32_t         node,                                              
  uint32_t         index                                              
)                                                                     
{                                                                     
  return (( (Objects_Id) the_api )   << OBJECTS_API_START_BIT)   |    
40008c98:	84 10 80 1a 	or  %g2, %i2, %g2                              
         (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |    
40008c9c:	84 10 80 03 	or  %g2, %g3, %g2                              
  uint32_t         the_class,                                         
  uint32_t         node,                                              
  uint32_t         index                                              
)                                                                     
{                                                                     
  return (( (Objects_Id) the_api )   << OBJECTS_API_START_BIT)   |    
40008ca0:	84 10 80 1c 	or  %g2, %i4, %g2                              
        information->the_class,                                       
        _Objects_Local_node,                                          
        index                                                         
      );                                                              
                                                                      
    _Chain_Append( &information->Inactive, &the_object->Node );       
40008ca4:	90 10 00 1b 	mov  %i3, %o0                                  
40008ca8:	92 10 00 01 	mov  %g1, %o1                                  
                                                                      
    index++;                                                          
40008cac:	b8 07 20 01 	inc  %i4                                       
        information->the_class,                                       
        _Objects_Local_node,                                          
        index                                                         
      );                                                              
                                                                      
    _Chain_Append( &information->Inactive, &the_object->Node );       
40008cb0:	7f ff fc 8c 	call  40007ee0 <_Chain_Append>                 
40008cb4:	c4 20 60 08 	st  %g2, [ %g1 + 8 ]                           
  /*                                                                  
   *  Move from the local chain, initialise, then append to the inactive chain
   */                                                                 
  index = index_base;                                                 
                                                                      
  while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
40008cb8:	7f ff fc 95 	call  40007f0c <_Chain_Get>                    
40008cbc:	90 07 bf f4 	add  %fp, -12, %o0                             
40008cc0:	82 92 20 00 	orcc  %o0, 0, %g1                              
40008cc4:	32 bf ff f2 	bne,a   40008c8c <_Objects_Extend_information+0x200>
40008cc8:	c4 06 00 00 	ld  [ %i0 ], %g2                               
    _Chain_Append( &information->Inactive, &the_object->Node );       
                                                                      
    index++;                                                          
  }                                                                   
                                                                      
  information->inactive_per_block[ block ] = information->allocation_size;
40008ccc:	c8 16 20 14 	lduh  [ %i0 + 0x14 ], %g4                      
40008cd0:	c6 06 20 30 	ld  [ %i0 + 0x30 ], %g3                        
  information->inactive =                                             
    (Objects_Maximum)(information->inactive + information->allocation_size);
40008cd4:	c4 16 20 2c 	lduh  [ %i0 + 0x2c ], %g2                      
    _Chain_Append( &information->Inactive, &the_object->Node );       
                                                                      
    index++;                                                          
  }                                                                   
                                                                      
  information->inactive_per_block[ block ] = information->allocation_size;
40008cd8:	c8 20 c0 1d 	st  %g4, [ %g3 + %i5 ]                         
  information->inactive =                                             
    (Objects_Maximum)(information->inactive + information->allocation_size);
40008cdc:	82 00 80 04 	add  %g2, %g4, %g1                             
                                                                      
    index++;                                                          
  }                                                                   
                                                                      
  information->inactive_per_block[ block ] = information->allocation_size;
  information->inactive =                                             
40008ce0:	c2 36 20 2c 	sth  %g1, [ %i0 + 0x2c ]                       
40008ce4:	81 c7 e0 08 	ret                                            
40008ce8:	81 e8 00 00 	restore                                        
  if ( information->auto_extend ) {                                   
    new_object_block = _Workspace_Allocate( block_size );             
    if ( !new_object_block )                                          
      return;                                                         
  } else {                                                            
    new_object_block = _Workspace_Allocate_or_fatal_error( block_size );
40008cec:	40 00 08 d6 	call  4000b044 <_Workspace_Allocate_or_fatal_error>
40008cf0:	01 00 00 00 	nop                                            
40008cf4:	10 bf ff 98 	b  40008b54 <_Objects_Extend_information+0xc8> 
40008cf8:	a2 10 00 08 	mov  %o0, %l1                                  
     */                                                               
    block_size = block_count *                                        
           (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
          ((maximum + minimum_index) * sizeof(Objects_Control *));    
    if ( information->auto_extend ) {                                 
      object_blocks = _Workspace_Allocate( block_size );              
40008cfc:	40 00 08 c4 	call  4000b00c <_Workspace_Allocate>           
40008d00:	01 00 00 00 	nop                                            
      if ( !object_blocks ) {                                         
40008d04:	a4 92 20 00 	orcc  %o0, 0, %l2                              
40008d08:	32 bf ff a3 	bne,a   40008b94 <_Objects_Extend_information+0x108>
40008d0c:	c2 16 20 10 	lduh  [ %i0 + 0x10 ], %g1                      
        _Workspace_Free( new_object_block );                          
40008d10:	40 00 08 c7 	call  4000b02c <_Workspace_Free>               
40008d14:	90 10 00 11 	mov  %l1, %o0                                  
40008d18:	81 c7 e0 08 	ret                                            
40008d1c:	81 e8 00 00 	restore                                        
40008d20:	d0 16 20 14 	lduh  [ %i0 + 0x14 ], %o0                      
  /*                                                                  
   *  Search for a free block of indexes. If we do NOT need to allocate or
   *  extend the block table, then we will change do_extend.          
   */                                                                 
  do_extend     = true;                                               
  minimum_index = _Objects_Get_index( information->minimum_id );      
40008d24:	b8 10 00 10 	mov  %l0, %i4                                  
                                                                      
  /*                                                                  
   *  Search for a free block of indexes. If we do NOT need to allocate or
   *  extend the block table, then we will change do_extend.          
   */                                                                 
  do_extend     = true;                                               
40008d28:	b6 10 20 01 	mov  1, %i3                                    
  minimum_index = _Objects_Get_index( information->minimum_id );      
  index_base    = minimum_index;                                      
  block         = 0;                                                  
40008d2c:	ba 10 20 00 	clr  %i5                                       
                                                                      
  /* if ( information->maximum < minimum_index ) */                   
  if ( information->object_blocks == NULL )                           
    block_count = 0;                                                  
40008d30:	b4 10 20 00 	clr  %i2                                       
40008d34:	10 bf ff 76 	b  40008b0c <_Objects_Extend_information+0x80> 
40008d38:	a3 2c 60 10 	sll  %l1, 0x10, %l1                            
      /*                                                              
       *  Copy each section of the table over. This has to be performed as
       *  separate parts as size of each block has changed.           
       */                                                             
                                                                      
      memcpy( object_blocks,                                          
40008d3c:	d2 06 20 34 	ld  [ %i0 + 0x34 ], %o1                        
              information->object_blocks,                             
              block_count * sizeof(void*) );                          
40008d40:	b5 2e a0 02 	sll  %i2, 2, %i2                               
      /*                                                              
       *  Copy each section of the table over. This has to be performed as
       *  separate parts as size of each block has changed.           
       */                                                             
                                                                      
      memcpy( object_blocks,                                          
40008d44:	90 10 00 12 	mov  %l2, %o0                                  
40008d48:	40 00 1c cf 	call  40010084 <memcpy>                        
40008d4c:	94 10 00 1a 	mov  %i2, %o2                                  
              information->object_blocks,                             
              block_count * sizeof(void*) );                          
      memcpy( inactive_per_block,                                     
40008d50:	d2 06 20 30 	ld  [ %i0 + 0x30 ], %o1                        
40008d54:	94 10 00 1a 	mov  %i2, %o2                                  
40008d58:	40 00 1c cb 	call  40010084 <memcpy>                        
40008d5c:	90 10 00 13 	mov  %l3, %o0                                  
              information->inactive_per_block,                        
              block_count * sizeof(uint32_t) );                       
      memcpy( local_table,                                            
              information->local_table,                               
              (information->maximum + minimum_index) * sizeof(Objects_Control *) );
40008d60:	d4 16 20 10 	lduh  [ %i0 + 0x10 ], %o2                      
              information->object_blocks,                             
              block_count * sizeof(void*) );                          
      memcpy( inactive_per_block,                                     
              information->inactive_per_block,                        
              block_count * sizeof(uint32_t) );                       
      memcpy( local_table,                                            
40008d64:	d2 06 20 1c 	ld  [ %i0 + 0x1c ], %o1                        
              information->local_table,                               
              (information->maximum + minimum_index) * sizeof(Objects_Control *) );
40008d68:	94 02 80 10 	add  %o2, %l0, %o2                             
              information->object_blocks,                             
              block_count * sizeof(void*) );                          
      memcpy( inactive_per_block,                                     
              information->inactive_per_block,                        
              block_count * sizeof(uint32_t) );                       
      memcpy( local_table,                                            
40008d6c:	90 10 00 1b 	mov  %i3, %o0                                  
40008d70:	40 00 1c c5 	call  40010084 <memcpy>                        
40008d74:	95 2a a0 02 	sll  %o2, 2, %o2                               
     */                                                               
    object_blocks[block_count] = NULL;                                
    inactive_per_block[block_count] = 0;                              
                                                                      
    for ( index=index_base ;                                          
          index < ( information->allocation_size + index_base );      
40008d78:	10 bf ff 97 	b  40008bd4 <_Objects_Extend_information+0x148>
40008d7c:	c6 16 20 14 	lduh  [ %i0 + 0x14 ], %g3                      
  /*                                                                  
   *  Search for a free block of indexes. If we do NOT need to allocate or
   *  extend the block table, then we will change do_extend.          
   */                                                                 
  do_extend     = true;                                               
  minimum_index = _Objects_Get_index( information->minimum_id );      
40008d80:	b8 10 00 10 	mov  %l0, %i4                                  <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Search for a free block of indexes. If we do NOT need to allocate or
   *  extend the block table, then we will change do_extend.          
   */                                                                 
  do_extend     = true;                                               
40008d84:	b6 10 20 01 	mov  1, %i3                                    <== NOT EXECUTED
  minimum_index = _Objects_Get_index( information->minimum_id );      
  index_base    = minimum_index;                                      
  block         = 0;                                                  
40008d88:	10 bf ff 61 	b  40008b0c <_Objects_Extend_information+0x80> <== NOT EXECUTED
40008d8c:	ba 10 20 00 	clr  %i5                                       <== NOT EXECUTED
40008d90:	81 c7 e0 08 	ret                                            
40008d94:	81 e8 00 00 	restore                                        
  else {                                                              
    block_count = information->maximum / information->allocation_size;
                                                                      
    for ( ; block < block_count; block++ ) {                          
      if ( information->object_blocks[ block ] == NULL ) {            
        do_extend = false;                                            
40008d98:	b6 10 20 00 	clr  %i3                                       <== NOT EXECUTED
   *  extend the block table, then we will change do_extend.          
   */                                                                 
  do_extend     = true;                                               
  minimum_index = _Objects_Get_index( information->minimum_id );      
  index_base    = minimum_index;                                      
  block         = 0;                                                  
40008d9c:	10 bf ff 5c 	b  40008b0c <_Objects_Extend_information+0x80> <== NOT EXECUTED
40008da0:	ba 10 20 00 	clr  %i5                                       <== NOT EXECUTED
                                                                      

40008e54 <_Objects_Get_information>: Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint16_t the_class ) {
40008e54:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Objects_Information *info;                                          
  int the_class_api_maximum;                                          
                                                                      
  if ( !the_class )                                                   
40008e58:	80 a6 60 00 	cmp  %i1, 0                                    
40008e5c:	02 80 00 19 	be  40008ec0 <_Objects_Get_information+0x6c>   
40008e60:	01 00 00 00 	nop                                            
                                                                      
  /*                                                                  
   *  This call implicitly validates the_api so we do not call        
   *  _Objects_Is_api_valid above here.                               
   */                                                                 
  the_class_api_maximum = _Objects_API_maximum_class( the_api );      
40008e64:	40 00 12 82 	call  4000d86c <_Objects_API_maximum_class>    
40008e68:	90 10 00 18 	mov  %i0, %o0                                  
  if ( the_class_api_maximum == 0 )                                   
40008e6c:	80 a2 20 00 	cmp  %o0, 0                                    
40008e70:	02 80 00 14 	be  40008ec0 <_Objects_Get_information+0x6c>   
40008e74:	80 a2 00 19 	cmp  %o0, %i1                                  
    return NULL;                                                      
                                                                      
  if ( the_class > (uint32_t) the_class_api_maximum )                 
40008e78:	0a 80 00 12 	bcs  40008ec0 <_Objects_Get_information+0x6c>  
40008e7c:	03 10 00 7b 	sethi  %hi(0x4001ec00), %g1                    
    return NULL;                                                      
                                                                      
  if ( !_Objects_Information_table[ the_api ] )                       
40008e80:	b1 2e 20 02 	sll  %i0, 2, %i0                               
40008e84:	82 10 62 24 	or  %g1, 0x224, %g1                            
40008e88:	c2 00 40 18 	ld  [ %g1 + %i0 ], %g1                         
40008e8c:	80 a0 60 00 	cmp  %g1, 0                                    
40008e90:	02 80 00 0c 	be  40008ec0 <_Objects_Get_information+0x6c>   <== NEVER TAKEN
40008e94:	b3 2e 60 02 	sll  %i1, 2, %i1                               
    return NULL;                                                      
                                                                      
  info = _Objects_Information_table[ the_api ][ the_class ];          
40008e98:	f0 00 40 19 	ld  [ %g1 + %i1 ], %i0                         
  if ( !info )                                                        
40008e9c:	80 a6 20 00 	cmp  %i0, 0                                    
40008ea0:	02 80 00 08 	be  40008ec0 <_Objects_Get_information+0x6c>   <== NEVER TAKEN
40008ea4:	01 00 00 00 	nop                                            
   *  In a multprocessing configuration, we may access remote objects.
   *  Thus we may have 0 local instances and still have a valid object
   *  pointer.                                                        
   */                                                                 
  #if !defined(RTEMS_MULTIPROCESSING)                                 
    if ( info->maximum == 0 )                                         
40008ea8:	c2 16 20 10 	lduh  [ %i0 + 0x10 ], %g1                      
40008eac:	80 a0 60 00 	cmp  %g1, 0                                    
40008eb0:	02 80 00 04 	be  40008ec0 <_Objects_Get_information+0x6c>   
40008eb4:	01 00 00 00 	nop                                            
      return NULL;                                                    
  #endif                                                              
                                                                      
  return info;                                                        
}                                                                     
40008eb8:	81 c7 e0 08 	ret                                            
40008ebc:	81 e8 00 00 	restore                                        
{                                                                     
  Objects_Information *info;                                          
  int the_class_api_maximum;                                          
                                                                      
  if ( !the_class )                                                   
    return NULL;                                                      
40008ec0:	81 c7 e0 08 	ret                                            
40008ec4:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

40017328 <_Objects_Get_name_as_string>: char *_Objects_Get_name_as_string( Objects_Id id, size_t length, char *name ) {
40017328:	9d e3 bf 90 	save  %sp, -112, %sp                           
  char                   lname[5];                                    
  Objects_Control       *the_object;                                  
  Objects_Locations      location;                                    
  Objects_Id             tmpId;                                       
                                                                      
  if ( length == 0 )                                                  
4001732c:	80 a6 60 00 	cmp  %i1, 0                                    
40017330:	02 80 00 11 	be  40017374 <_Objects_Get_name_as_string+0x4c>
40017334:	80 a6 a0 00 	cmp  %i2, 0                                    
    return NULL;                                                      
                                                                      
  if ( name == NULL )                                                 
40017338:	02 80 00 0f 	be  40017374 <_Objects_Get_name_as_string+0x4c>
4001733c:	ba 96 20 00 	orcc  %i0, 0, %i5                              
    return NULL;                                                      
                                                                      
  tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
40017340:	02 80 00 3d 	be  40017434 <_Objects_Get_name_as_string+0x10c>
40017344:	03 10 00 ca 	sethi  %hi(0x40032800), %g1                    
                                                                      
  information = _Objects_Get_information_id( tmpId );                 
40017348:	7f ff e0 8e 	call  4000f580 <_Objects_Get_information_id>   
4001734c:	90 10 00 1d 	mov  %i5, %o0                                  
  if ( !information )                                                 
40017350:	b8 92 20 00 	orcc  %o0, 0, %i4                              
40017354:	02 80 00 08 	be  40017374 <_Objects_Get_name_as_string+0x4c>
40017358:	92 10 00 1d 	mov  %i5, %o1                                  
    return NULL;                                                      
                                                                      
  the_object = _Objects_Get( information, tmpId, &location );         
4001735c:	7f ff e0 c9 	call  4000f680 <_Objects_Get>                  
40017360:	94 07 bf f4 	add  %fp, -12, %o2                             
  switch ( location ) {                                               
40017364:	c2 07 bf f4 	ld  [ %fp + -12 ], %g1                         
40017368:	80 a0 60 00 	cmp  %g1, 0                                    
4001736c:	22 80 00 05 	be,a   40017380 <_Objects_Get_name_as_string+0x58>
40017370:	c2 0f 20 38 	ldub  [ %i4 + 0x38 ], %g1                      
#if defined(RTEMS_MULTIPROCESSING)                                    
    case OBJECTS_REMOTE:                                              
      /* not supported */                                             
#endif                                                                
    case OBJECTS_ERROR:                                               
      return NULL;                                                    
40017374:	b4 10 20 00 	clr  %i2                                       
                                                                      
      _Thread_Enable_dispatch();                                      
      return name;                                                    
  }                                                                   
  return NULL;                  /* unreachable path */                
}                                                                     
40017378:	81 c7 e0 08 	ret                                            
4001737c:	91 e8 00 1a 	restore  %g0, %i2, %o0                         
      return NULL;                                                    
                                                                      
    case OBJECTS_LOCAL:                                               
                                                                      
      #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)             
        if ( information->is_string ) {                               
40017380:	80 a0 60 00 	cmp  %g1, 0                                    
40017384:	12 80 00 2f 	bne  40017440 <_Objects_Get_name_as_string+0x118>
40017388:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
        } else                                                        
      #endif                                                          
      {                                                               
        uint32_t  u32_name = (uint32_t) the_object->name.name_u32;    
                                                                      
        lname[ 0 ] = (u32_name >> 24) & 0xff;                         
4001738c:	89 30 60 18 	srl  %g1, 0x18, %g4                            
        lname[ 1 ] = (u32_name >> 16) & 0xff;                         
40017390:	87 30 60 10 	srl  %g1, 0x10, %g3                            
        lname[ 2 ] = (u32_name >>  8) & 0xff;                         
40017394:	85 30 60 08 	srl  %g1, 8, %g2                               
        lname[ 3 ] = (u32_name >>  0) & 0xff;                         
40017398:	c2 2f bf fb 	stb  %g1, [ %fp + -5 ]                         
        lname[ 4 ] = '\0';                                            
4001739c:	c0 2f bf fc 	clrb  [ %fp + -4 ]                             
        } else                                                        
      #endif                                                          
      {                                                               
        uint32_t  u32_name = (uint32_t) the_object->name.name_u32;    
                                                                      
        lname[ 0 ] = (u32_name >> 24) & 0xff;                         
400173a0:	c8 2f bf f8 	stb  %g4, [ %fp + -8 ]                         
        lname[ 1 ] = (u32_name >> 16) & 0xff;                         
400173a4:	c6 2f bf f9 	stb  %g3, [ %fp + -7 ]                         
        lname[ 2 ] = (u32_name >>  8) & 0xff;                         
400173a8:	c4 2f bf fa 	stb  %g2, [ %fp + -6 ]                         
        lname[ 3 ] = (u32_name >>  0) & 0xff;                         
        lname[ 4 ] = '\0';                                            
        s = lname;                                                    
400173ac:	82 07 bf f8 	add  %fp, -8, %g1                              
      }                                                               
                                                                      
      d = name;                                                       
      if ( s ) {                                                      
        for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {            
400173b0:	80 a6 60 01 	cmp  %i1, 1                                    
400173b4:	02 80 00 27 	be  40017450 <_Objects_Get_name_as_string+0x128><== NEVER TAKEN
400173b8:	86 10 00 1a 	mov  %i2, %g3                                  
400173bc:	c6 48 40 00 	ldsb  [ %g1 ], %g3                             
400173c0:	80 a0 e0 00 	cmp  %g3, 0                                    
400173c4:	02 80 00 22 	be  4001744c <_Objects_Get_name_as_string+0x124>
400173c8:	c4 08 40 00 	ldub  [ %g1 ], %g2                             
 *  This method objects the name of an object and returns its name    
 *  in the form of a C string.  It attempts to be careful about       
 *  overflowing the user's string and about returning unprintable characters.
 */                                                                   
                                                                      
char *_Objects_Get_name_as_string(                                    
400173cc:	b6 06 7f ff 	add  %i1, -1, %i3                              
400173d0:	39 10 00 c4 	sethi  %hi(0x40031000), %i4                    
400173d4:	b6 00 40 1b 	add  %g1, %i3, %i3                             
400173d8:	86 10 00 1a 	mov  %i2, %g3                                  
400173dc:	10 80 00 06 	b  400173f4 <_Objects_Get_name_as_string+0xcc> 
400173e0:	b8 17 22 58 	or  %i4, 0x258, %i4                            
        s = lname;                                                    
      }                                                               
                                                                      
      d = name;                                                       
      if ( s ) {                                                      
        for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {            
400173e4:	c8 48 40 00 	ldsb  [ %g1 ], %g4                             
400173e8:	80 a1 20 00 	cmp  %g4, 0                                    
400173ec:	02 80 00 0e 	be  40017424 <_Objects_Get_name_as_string+0xfc>
400173f0:	c4 08 40 00 	ldub  [ %g1 ], %g2                             
          *d = (isprint((unsigned char)*s)) ? *s : '*';               
400173f4:	fa 07 00 00 	ld  [ %i4 ], %i5                               
400173f8:	88 08 a0 ff 	and  %g2, 0xff, %g4                            
400173fc:	88 07 40 04 	add  %i5, %g4, %g4                             
40017400:	c8 49 20 01 	ldsb  [ %g4 + 1 ], %g4                         
40017404:	80 89 20 97 	btst  0x97, %g4                                
40017408:	12 80 00 03 	bne  40017414 <_Objects_Get_name_as_string+0xec>
4001740c:	82 00 60 01 	inc  %g1                                       
40017410:	84 10 20 2a 	mov  0x2a, %g2                                 
40017414:	c4 28 c0 00 	stb  %g2, [ %g3 ]                              
        s = lname;                                                    
      }                                                               
                                                                      
      d = name;                                                       
      if ( s ) {                                                      
        for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {            
40017418:	80 a0 40 1b 	cmp  %g1, %i3                                  
4001741c:	12 bf ff f2 	bne  400173e4 <_Objects_Get_name_as_string+0xbc>
40017420:	86 00 e0 01 	inc  %g3                                       
          *d = (isprint((unsigned char)*s)) ? *s : '*';               
        }                                                             
      }                                                               
      *d = '\0';                                                      
                                                                      
      _Thread_Enable_dispatch();                                      
40017424:	7f ff e4 a3 	call  400106b0 <_Thread_Enable_dispatch>       
40017428:	c0 28 c0 00 	clrb  [ %g3 ]                                  
      return name;                                                    
  }                                                                   
  return NULL;                  /* unreachable path */                
}                                                                     
4001742c:	81 c7 e0 08 	ret                                            
40017430:	91 e8 00 1a 	restore  %g0, %i2, %o0                         
    return NULL;                                                      
                                                                      
  if ( name == NULL )                                                 
    return NULL;                                                      
                                                                      
  tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
40017434:	c2 00 60 20 	ld  [ %g1 + 0x20 ], %g1                        
40017438:	10 bf ff c4 	b  40017348 <_Objects_Get_name_as_string+0x20> 
4001743c:	fa 00 60 08 	ld  [ %g1 + 8 ], %i5                           
        lname[ 4 ] = '\0';                                            
        s = lname;                                                    
      }                                                               
                                                                      
      d = name;                                                       
      if ( s ) {                                                      
40017440:	80 a0 60 00 	cmp  %g1, 0                                    
40017444:	12 bf ff dc 	bne  400173b4 <_Objects_Get_name_as_string+0x8c>
40017448:	80 a6 60 01 	cmp  %i1, 1                                    
        for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {            
          *d = (isprint((unsigned char)*s)) ? *s : '*';               
4001744c:	86 10 00 1a 	mov  %i2, %g3                                  
        }                                                             
      }                                                               
      *d = '\0';                                                      
                                                                      
      _Thread_Enable_dispatch();                                      
40017450:	7f ff e4 98 	call  400106b0 <_Thread_Enable_dispatch>       
40017454:	c0 28 c0 00 	clrb  [ %g3 ]                                  
40017458:	30 bf ff f5 	b,a   4001742c <_Objects_Get_name_as_string+0x104>
                                                                      

4001a1f8 <_Objects_Get_next>: Objects_Information *information, Objects_Id id, Objects_Locations *location_p, Objects_Id *next_id_p ) {
4001a1f8:	9d e3 bf a0 	save  %sp, -96, %sp                            
    Objects_Control *object;                                          
    Objects_Id       next_id;                                         
                                                                      
    if ( !information )                                               
4001a1fc:	80 a6 20 00 	cmp  %i0, 0                                    
4001a200:	02 80 00 29 	be  4001a2a4 <_Objects_Get_next+0xac>          
4001a204:	80 a6 a0 00 	cmp  %i2, 0                                    
      return NULL;                                                    
                                                                      
    if ( !location_p )                                                
4001a208:	02 80 00 27 	be  4001a2a4 <_Objects_Get_next+0xac>          
4001a20c:	80 a6 e0 00 	cmp  %i3, 0                                    
      return NULL;                                                    
                                                                      
    if ( !next_id_p )                                                 
4001a210:	02 80 00 25 	be  4001a2a4 <_Objects_Get_next+0xac>          
4001a214:	83 2e 60 10 	sll  %i1, 0x10, %g1                            
      return NULL;                                                    
                                                                      
    if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX)           
4001a218:	80 a0 60 00 	cmp  %g1, 0                                    
4001a21c:	22 80 00 13 	be,a   4001a268 <_Objects_Get_next+0x70>       
4001a220:	f2 06 20 08 	ld  [ %i0 + 8 ], %i1                           
    else                                                              
        next_id = id;                                                 
                                                                      
    do {                                                              
        /* walked off end of list? */                                 
        if (_Objects_Get_index(next_id) > information->maximum)       
4001a224:	c4 16 20 10 	lduh  [ %i0 + 0x10 ], %g2                      
4001a228:	83 2e 60 10 	sll  %i1, 0x10, %g1                            
            *location_p = OBJECTS_ERROR;                              
            goto final;                                               
        }                                                             
                                                                      
        /* try to grab one */                                         
        object = _Objects_Get(information, next_id, location_p);      
4001a22c:	92 10 00 19 	mov  %i1, %o1                                  
    else                                                              
        next_id = id;                                                 
                                                                      
    do {                                                              
        /* walked off end of list? */                                 
        if (_Objects_Get_index(next_id) > information->maximum)       
4001a230:	83 30 60 10 	srl  %g1, 0x10, %g1                            
            *location_p = OBJECTS_ERROR;                              
            goto final;                                               
        }                                                             
                                                                      
        /* try to grab one */                                         
        object = _Objects_Get(information, next_id, location_p);      
4001a234:	90 10 00 18 	mov  %i0, %o0                                  
    else                                                              
        next_id = id;                                                 
                                                                      
    do {                                                              
        /* walked off end of list? */                                 
        if (_Objects_Get_index(next_id) > information->maximum)       
4001a238:	80 a0 80 01 	cmp  %g2, %g1                                  
4001a23c:	0a 80 00 13 	bcs  4001a288 <_Objects_Get_next+0x90>         
4001a240:	94 10 00 1a 	mov  %i2, %o2                                  
            *location_p = OBJECTS_ERROR;                              
            goto final;                                               
        }                                                             
                                                                      
        /* try to grab one */                                         
        object = _Objects_Get(information, next_id, location_p);      
4001a244:	7f ff d5 0f 	call  4000f680 <_Objects_Get>                  
4001a248:	b2 06 60 01 	inc  %i1                                       
                                                                      
        next_id++;                                                    
                                                                      
    } while (*location_p != OBJECTS_LOCAL);                           
4001a24c:	c2 06 80 00 	ld  [ %i2 ], %g1                               
4001a250:	80 a0 60 00 	cmp  %g1, 0                                    
4001a254:	32 bf ff f5 	bne,a   4001a228 <_Objects_Get_next+0x30>      
4001a258:	c4 16 20 10 	lduh  [ %i0 + 0x10 ], %g2                      
                                                                      
    *next_id_p = next_id;                                             
4001a25c:	f2 26 c0 00 	st  %i1, [ %i3 ]                               
    return object;                                                    
                                                                      
final:                                                                
    *next_id_p = OBJECTS_ID_FINAL;                                    
    return 0;                                                         
}                                                                     
4001a260:	81 c7 e0 08 	ret                                            
4001a264:	91 e8 00 08 	restore  %g0, %o0, %o0                         
    else                                                              
        next_id = id;                                                 
                                                                      
    do {                                                              
        /* walked off end of list? */                                 
        if (_Objects_Get_index(next_id) > information->maximum)       
4001a268:	c4 16 20 10 	lduh  [ %i0 + 0x10 ], %g2                      
4001a26c:	83 2e 60 10 	sll  %i1, 0x10, %g1                            
            *location_p = OBJECTS_ERROR;                              
            goto final;                                               
        }                                                             
                                                                      
        /* try to grab one */                                         
        object = _Objects_Get(information, next_id, location_p);      
4001a270:	92 10 00 19 	mov  %i1, %o1                                  
    else                                                              
        next_id = id;                                                 
                                                                      
    do {                                                              
        /* walked off end of list? */                                 
        if (_Objects_Get_index(next_id) > information->maximum)       
4001a274:	83 30 60 10 	srl  %g1, 0x10, %g1                            
            *location_p = OBJECTS_ERROR;                              
            goto final;                                               
        }                                                             
                                                                      
        /* try to grab one */                                         
        object = _Objects_Get(information, next_id, location_p);      
4001a278:	90 10 00 18 	mov  %i0, %o0                                  
    else                                                              
        next_id = id;                                                 
                                                                      
    do {                                                              
        /* walked off end of list? */                                 
        if (_Objects_Get_index(next_id) > information->maximum)       
4001a27c:	80 a0 80 01 	cmp  %g2, %g1                                  
4001a280:	1a bf ff f1 	bcc  4001a244 <_Objects_Get_next+0x4c>         <== ALWAYS TAKEN
4001a284:	94 10 00 1a 	mov  %i2, %o2                                  
        {                                                             
            *location_p = OBJECTS_ERROR;                              
4001a288:	82 10 20 01 	mov  1, %g1                                    
4001a28c:	c2 26 80 00 	st  %g1, [ %i2 ]                               
    *next_id_p = next_id;                                             
    return object;                                                    
                                                                      
final:                                                                
    *next_id_p = OBJECTS_ID_FINAL;                                    
    return 0;                                                         
4001a290:	90 10 20 00 	clr  %o0                                       
                                                                      
    *next_id_p = next_id;                                             
    return object;                                                    
                                                                      
final:                                                                
    *next_id_p = OBJECTS_ID_FINAL;                                    
4001a294:	82 10 3f ff 	mov  -1, %g1                                   
4001a298:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
    return 0;                                                         
}                                                                     
4001a29c:	81 c7 e0 08 	ret                                            
4001a2a0:	91 e8 00 08 	restore  %g0, %o0, %o0                         
{                                                                     
    Objects_Control *object;                                          
    Objects_Id       next_id;                                         
                                                                      
    if ( !information )                                               
      return NULL;                                                    
4001a2a4:	10 bf ff ef 	b  4001a260 <_Objects_Get_next+0x68>           
4001a2a8:	90 10 20 00 	clr  %o0                                       
                                                                      

4001a43c <_Objects_Get_no_protection>: /* * You can't just extract the index portion or you can get tricked * by a value between 1 and maximum. */ index = id - information->minimum_id + 1;
4001a43c:	c4 02 20 08 	ld  [ %o0 + 8 ], %g2                           
                                                                      
  if ( information->maximum >= index ) {                              
4001a440:	c2 12 20 10 	lduh  [ %o0 + 0x10 ], %g1                      
                                                                      
  /*                                                                  
   * You can't just extract the index portion or you can get tricked  
   * by a value between 1 and maximum.                                
   */                                                                 
  index = id - information->minimum_id + 1;                           
4001a444:	92 22 40 02 	sub  %o1, %g2, %o1                             
4001a448:	92 02 60 01 	inc  %o1                                       
                                                                      
  if ( information->maximum >= index ) {                              
4001a44c:	80 a2 40 01 	cmp  %o1, %g1                                  
4001a450:	18 80 00 09 	bgu  4001a474 <_Objects_Get_no_protection+0x38>
4001a454:	93 2a 60 02 	sll  %o1, 2, %o1                               
    if ( (the_object = information->local_table[ index ]) != NULL ) { 
4001a458:	c2 02 20 1c 	ld  [ %o0 + 0x1c ], %g1                        
4001a45c:	d0 00 40 09 	ld  [ %g1 + %o1 ], %o0                         
4001a460:	80 a2 20 00 	cmp  %o0, 0                                    
4001a464:	02 80 00 05 	be  4001a478 <_Objects_Get_no_protection+0x3c> <== NEVER TAKEN
4001a468:	82 10 20 01 	mov  1, %g1                                    
      *location = OBJECTS_LOCAL;                                      
      return the_object;                                              
4001a46c:	81 c3 e0 08 	retl                                           
4001a470:	c0 22 80 00 	clr  [ %o2 ]                                   
                                                                      
  /*                                                                  
   *  This isn't supported or required yet for Global objects so      
   *  if it isn't local, we don't find it.                            
   */                                                                 
  *location = OBJECTS_ERROR;                                          
4001a474:	82 10 20 01 	mov  1, %g1                                    
  return NULL;                                                        
4001a478:	90 10 20 00 	clr  %o0                                       
}                                                                     
4001a47c:	81 c3 e0 08 	retl                                           
4001a480:	c2 22 80 00 	st  %g1, [ %o2 ]                               
                                                                      

4000f6f4 <_Objects_Id_to_name>: Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) {
4000f6f4:	9d e3 bf 98 	save  %sp, -104, %sp                           
                                                                      
  /*                                                                  
   *  Caller is trusted for name != NULL.                             
   */                                                                 
                                                                      
  tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
4000f6f8:	80 a6 20 00 	cmp  %i0, 0                                    
4000f6fc:	12 80 00 06 	bne  4000f714 <_Objects_Id_to_name+0x20>       
4000f700:	83 36 20 18 	srl  %i0, 0x18, %g1                            
4000f704:	03 10 00 ca 	sethi  %hi(0x40032800), %g1                    
4000f708:	c2 00 60 20 	ld  [ %g1 + 0x20 ], %g1	! 40032820 <_Per_CPU_Information+0x10>
4000f70c:	f0 00 60 08 	ld  [ %g1 + 8 ], %i0                           
4000f710:	83 36 20 18 	srl  %i0, 0x18, %g1                            
4000f714:	82 08 60 07 	and  %g1, 7, %g1                               
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(                      
  uint32_t   the_api                                                  
)                                                                     
{                                                                     
  if ( !the_api || the_api > OBJECTS_APIS_LAST )                      
4000f718:	84 00 7f ff 	add  %g1, -1, %g2                              
4000f71c:	80 a0 a0 02 	cmp  %g2, 2                                    
4000f720:	18 80 00 11 	bgu  4000f764 <_Objects_Id_to_name+0x70>       
4000f724:	83 28 60 02 	sll  %g1, 2, %g1                               
                                                                      
  the_api = _Objects_Get_API( tmpId );                                
  if ( !_Objects_Is_api_valid( the_api ) )                            
    return OBJECTS_INVALID_ID;                                        
                                                                      
  if ( !_Objects_Information_table[ the_api ] )                       
4000f728:	05 10 00 c8 	sethi  %hi(0x40032000), %g2                    
4000f72c:	84 10 a2 24 	or  %g2, 0x224, %g2	! 40032224 <_Objects_Information_table>
4000f730:	c2 00 80 01 	ld  [ %g2 + %g1 ], %g1                         
4000f734:	80 a0 60 00 	cmp  %g1, 0                                    
4000f738:	02 80 00 0b 	be  4000f764 <_Objects_Id_to_name+0x70>        
4000f73c:	85 36 20 1b 	srl  %i0, 0x1b, %g2                            
    return OBJECTS_INVALID_ID;                                        
                                                                      
  the_class = _Objects_Get_class( tmpId );                            
                                                                      
  information = _Objects_Information_table[ the_api ][ the_class ];   
4000f740:	85 28 a0 02 	sll  %g2, 2, %g2                               
4000f744:	d0 00 40 02 	ld  [ %g1 + %g2 ], %o0                         
  if ( !information )                                                 
4000f748:	80 a2 20 00 	cmp  %o0, 0                                    
4000f74c:	02 80 00 06 	be  4000f764 <_Objects_Id_to_name+0x70>        <== NEVER TAKEN
4000f750:	01 00 00 00 	nop                                            
    return OBJECTS_INVALID_ID;                                        
                                                                      
  #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)                 
    if ( information->is_string )                                     
4000f754:	c2 0a 20 38 	ldub  [ %o0 + 0x38 ], %g1                      
4000f758:	80 a0 60 00 	cmp  %g1, 0                                    
4000f75c:	02 80 00 04 	be  4000f76c <_Objects_Id_to_name+0x78>        <== ALWAYS TAKEN
4000f760:	92 10 00 18 	mov  %i0, %o1                                  
                                                                      
  tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
                                                                      
  the_api = _Objects_Get_API( tmpId );                                
  if ( !_Objects_Is_api_valid( the_api ) )                            
    return OBJECTS_INVALID_ID;                                        
4000f764:	81 c7 e0 08 	ret                                            
4000f768:	91 e8 20 03 	restore  %g0, 3, %o0                           
  #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)                 
    if ( information->is_string )                                     
      return OBJECTS_INVALID_ID;                                      
  #endif                                                              
                                                                      
  the_object = _Objects_Get( information, tmpId, &ignored_location ); 
4000f76c:	7f ff ff c5 	call  4000f680 <_Objects_Get>                  
4000f770:	94 07 bf fc 	add  %fp, -4, %o2                              
  if ( !the_object )                                                  
4000f774:	80 a2 20 00 	cmp  %o0, 0                                    
4000f778:	02 bf ff fb 	be  4000f764 <_Objects_Id_to_name+0x70>        
4000f77c:	01 00 00 00 	nop                                            
    return OBJECTS_INVALID_ID;                                        
                                                                      
  *name = the_object->name;                                           
4000f780:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
  _Thread_Enable_dispatch();                                          
  return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;                        
4000f784:	b0 10 20 00 	clr  %i0                                       
  the_object = _Objects_Get( information, tmpId, &ignored_location ); 
  if ( !the_object )                                                  
    return OBJECTS_INVALID_ID;                                        
                                                                      
  *name = the_object->name;                                           
  _Thread_Enable_dispatch();                                          
4000f788:	40 00 03 ca 	call  400106b0 <_Thread_Enable_dispatch>       
4000f78c:	c2 26 40 00 	st  %g1, [ %i1 ]                               
4000f790:	81 c7 e0 08 	ret                                            
4000f794:	81 e8 00 00 	restore                                        
                                                                      

40009164 <_Objects_Shrink_information>: #include <rtems/score/isr.h> void _Objects_Shrink_information( Objects_Information *information ) {
40009164:	9d e3 bf a0 	save  %sp, -96, %sp                            
                                                                      
  /*                                                                  
   * Search the list to find block or chunk with all objects inactive.
   */                                                                 
                                                                      
  index_base = _Objects_Get_index( information->minimum_id );         
40009168:	f8 16 20 0a 	lduh  [ %i0 + 0xa ], %i4                       
  block_count = (information->maximum - index_base) /                 
4000916c:	f6 16 20 14 	lduh  [ %i0 + 0x14 ], %i3                      
40009170:	d0 16 20 10 	lduh  [ %i0 + 0x10 ], %o0                      
40009174:	92 10 00 1b 	mov  %i3, %o1                                  
40009178:	40 00 3d bf 	call  40018874 <.udiv>                         
4000917c:	90 22 00 1c 	sub  %o0, %i4, %o0                             
                 information->allocation_size;                        
                                                                      
  for ( block = 0; block < block_count; block++ ) {                   
40009180:	80 a2 20 00 	cmp  %o0, 0                                    
40009184:	02 80 00 36 	be  4000925c <_Objects_Shrink_information+0xf8><== NEVER TAKEN
40009188:	01 00 00 00 	nop                                            
    if ( information->inactive_per_block[ block ] ==                  
4000918c:	c8 06 20 30 	ld  [ %i0 + 0x30 ], %g4                        
40009190:	c2 01 00 00 	ld  [ %g4 ], %g1                               
40009194:	80 a6 c0 01 	cmp  %i3, %g1                                  
40009198:	02 80 00 0f 	be  400091d4 <_Objects_Shrink_information+0x70><== NEVER TAKEN
4000919c:	82 10 20 00 	clr  %g1                                       
400091a0:	10 80 00 07 	b  400091bc <_Objects_Shrink_information+0x58> 
400091a4:	ba 10 20 04 	mov  4, %i5                                    
400091a8:	c4 01 00 1d 	ld  [ %g4 + %i5 ], %g2                         
400091ac:	80 a6 c0 02 	cmp  %i3, %g2                                  
400091b0:	02 80 00 0a 	be  400091d8 <_Objects_Shrink_information+0x74>
400091b4:	86 07 60 04 	add  %i5, 4, %g3                               
400091b8:	ba 10 00 03 	mov  %g3, %i5                                  
                                                                      
  index_base = _Objects_Get_index( information->minimum_id );         
  block_count = (information->maximum - index_base) /                 
                 information->allocation_size;                        
                                                                      
  for ( block = 0; block < block_count; block++ ) {                   
400091bc:	82 00 60 01 	inc  %g1                                       
400091c0:	80 a0 40 08 	cmp  %g1, %o0                                  
400091c4:	12 bf ff f9 	bne  400091a8 <_Objects_Shrink_information+0x44>
400091c8:	b8 07 00 1b 	add  %i4, %i3, %i4                             
400091cc:	81 c7 e0 08 	ret                                            
400091d0:	81 e8 00 00 	restore                                        
    if ( information->inactive_per_block[ block ] ==                  
400091d4:	ba 10 20 00 	clr  %i5                                       <== NOT EXECUTED
       *  Assume the Inactive chain is never empty at this point      
       */                                                             
      the_object = (Objects_Control *) _Chain_First( &information->Inactive );
                                                                      
      do {                                                            
         index = _Objects_Get_index( the_object->id );                
400091d8:	35 00 00 3f 	sethi  %hi(0xfc00), %i2                        
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return _Chain_Head( the_chain )->next;                              
400091dc:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        
400091e0:	10 80 00 05 	b  400091f4 <_Objects_Shrink_information+0x90> 
400091e4:	b4 16 a3 ff 	or  %i2, 0x3ff, %i2                            
         if ((index >= index_base) &&                                 
             (index < (index_base + information->allocation_size))) { 
           _Chain_Extract( &extract_me->Node );                       
         }                                                            
       }                                                              
       while ( the_object );                                          
400091e8:	90 96 e0 00 	orcc  %i3, 0, %o0                              
400091ec:	22 80 00 12 	be,a   40009234 <_Objects_Shrink_information+0xd0>
400091f0:	c2 06 20 34 	ld  [ %i0 + 0x34 ], %g1                        
       *  Assume the Inactive chain is never empty at this point      
       */                                                             
      the_object = (Objects_Control *) _Chain_First( &information->Inactive );
                                                                      
      do {                                                            
         index = _Objects_Get_index( the_object->id );                
400091f4:	c2 02 20 08 	ld  [ %o0 + 8 ], %g1                           
400091f8:	82 08 40 1a 	and  %g1, %i2, %g1                             
         /*                                                           
          *  Get the next node before the node is extracted           
          */                                                          
         extract_me = the_object;                                     
         the_object = (Objects_Control *) the_object->Node.next;      
         if ((index >= index_base) &&                                 
400091fc:	80 a0 40 1c 	cmp  %g1, %i4                                  
40009200:	0a bf ff fa 	bcs  400091e8 <_Objects_Shrink_information+0x84>
40009204:	f6 02 00 00 	ld  [ %o0 ], %i3                               
             (index < (index_base + information->allocation_size))) { 
40009208:	c4 16 20 14 	lduh  [ %i0 + 0x14 ], %g2                      
4000920c:	84 07 00 02 	add  %i4, %g2, %g2                             
         /*                                                           
          *  Get the next node before the node is extracted           
          */                                                          
         extract_me = the_object;                                     
         the_object = (Objects_Control *) the_object->Node.next;      
         if ((index >= index_base) &&                                 
40009210:	80 a0 40 02 	cmp  %g1, %g2                                  
40009214:	3a bf ff f6 	bcc,a   400091ec <_Objects_Shrink_information+0x88>
40009218:	90 96 e0 00 	orcc  %i3, 0, %o0                              
             (index < (index_base + information->allocation_size))) { 
           _Chain_Extract( &extract_me->Node );                       
4000921c:	40 00 10 2f 	call  4000d2d8 <_Chain_Extract>                
40009220:	01 00 00 00 	nop                                            
         }                                                            
       }                                                              
       while ( the_object );                                          
40009224:	90 96 e0 00 	orcc  %i3, 0, %o0                              
40009228:	32 bf ff f4 	bne,a   400091f8 <_Objects_Shrink_information+0x94><== ALWAYS TAKEN
4000922c:	c2 02 20 08 	ld  [ %o0 + 8 ], %g1                           
      /*                                                              
       *  Free the memory and reset the structures in the object' information
       */                                                             
                                                                      
      _Workspace_Free( information->object_blocks[ block ] );         
40009230:	c2 06 20 34 	ld  [ %i0 + 0x34 ], %g1                        <== NOT EXECUTED
40009234:	40 00 07 7e 	call  4000b02c <_Workspace_Free>               
40009238:	d0 00 40 1d 	ld  [ %g1 + %i5 ], %o0                         
      information->object_blocks[ block ] = NULL;                     
4000923c:	c2 06 20 34 	ld  [ %i0 + 0x34 ], %g1                        
      information->inactive_per_block[ block ] = 0;                   
                                                                      
      information->inactive -= information->allocation_size;          
40009240:	c4 16 20 2c 	lduh  [ %i0 + 0x2c ], %g2                      
      /*                                                              
       *  Free the memory and reset the structures in the object' information
       */                                                             
                                                                      
      _Workspace_Free( information->object_blocks[ block ] );         
      information->object_blocks[ block ] = NULL;                     
40009244:	c0 20 40 1d 	clr  [ %g1 + %i5 ]                             
      information->inactive_per_block[ block ] = 0;                   
40009248:	c6 06 20 30 	ld  [ %i0 + 0x30 ], %g3                        
                                                                      
      information->inactive -= information->allocation_size;          
4000924c:	c2 16 20 14 	lduh  [ %i0 + 0x14 ], %g1                      
       *  Free the memory and reset the structures in the object' information
       */                                                             
                                                                      
      _Workspace_Free( information->object_blocks[ block ] );         
      information->object_blocks[ block ] = NULL;                     
      information->inactive_per_block[ block ] = 0;                   
40009250:	c0 20 c0 1d 	clr  [ %g3 + %i5 ]                             
                                                                      
      information->inactive -= information->allocation_size;          
40009254:	82 20 80 01 	sub  %g2, %g1, %g1                             
40009258:	c2 36 20 2c 	sth  %g1, [ %i0 + 0x2c ]                       
                                                                      
      return;                                                         
4000925c:	81 c7 e0 08 	ret                                            
40009260:	81 e8 00 00 	restore                                        
                                                                      

4000ef14 <_POSIX_Keys_Run_destructors>: */ void _POSIX_Keys_Run_destructors( Thread_Control *thread ) {
4000ef14:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Objects_Maximum thread_index = _Objects_Get_index( thread->Object.id );
4000ef18:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
    for ( index = 1 ; index <= max ; ++index ) {                      
      POSIX_Keys_Control *key = (POSIX_Keys_Control *)                
        _POSIX_Keys_Information.local_table [ index ];                
                                                                      
      if ( key != NULL && key->destructor != NULL ) {                 
        void *value = key->Values [ thread_api ][ thread_index ];     
4000ef1c:	35 00 00 3f 	sethi  %hi(0xfc00), %i2                        
4000ef20:	b3 30 60 18 	srl  %g1, 0x18, %i1                            
4000ef24:	b4 16 a3 ff 	or  %i2, 0x3ff, %i2                            
4000ef28:	b2 0e 60 07 	and  %i1, 7, %i1                               
4000ef2c:	b4 08 40 1a 	and  %g1, %i2, %i2                             
4000ef30:	b2 06 60 04 	add  %i1, 4, %i1                               
4000ef34:	3b 10 00 7c 	sethi  %hi(0x4001f000), %i5                    
4000ef38:	b5 2e a0 02 	sll  %i2, 2, %i2                               
4000ef3c:	ba 17 62 9c 	or  %i5, 0x29c, %i5                            
4000ef40:	b3 2e 60 02 	sll  %i1, 2, %i1                               
    Objects_Maximum index = 0;                                        
    Objects_Maximum max = _POSIX_Keys_Information.maximum;            
                                                                      
    done = true;                                                      
                                                                      
    for ( index = 1 ; index <= max ; ++index ) {                      
4000ef44:	c2 17 60 10 	lduh  [ %i5 + 0x10 ], %g1                      
4000ef48:	80 a0 60 00 	cmp  %g1, 0                                    
4000ef4c:	02 80 00 21 	be  4000efd0 <_POSIX_Keys_Run_destructors+0xbc>
4000ef50:	b8 10 20 01 	mov  1, %i4                                    
4000ef54:	86 10 20 01 	mov  1, %g3                                    
4000ef58:	b6 10 00 01 	mov  %g1, %i3                                  
      POSIX_Keys_Control *key = (POSIX_Keys_Control *)                
4000ef5c:	c8 07 60 1c 	ld  [ %i5 + 0x1c ], %g4                        
        _POSIX_Keys_Information.local_table [ index ];                
4000ef60:	85 2f 20 10 	sll  %i4, 0x10, %g2                            
    Objects_Maximum max = _POSIX_Keys_Information.maximum;            
                                                                      
    done = true;                                                      
                                                                      
    for ( index = 1 ; index <= max ; ++index ) {                      
      POSIX_Keys_Control *key = (POSIX_Keys_Control *)                
4000ef64:	85 30 a0 0e 	srl  %g2, 0xe, %g2                             
4000ef68:	c4 01 00 02 	ld  [ %g4 + %g2 ], %g2                         
        _POSIX_Keys_Information.local_table [ index ];                
                                                                      
      if ( key != NULL && key->destructor != NULL ) {                 
4000ef6c:	80 a0 a0 00 	cmp  %g2, 0                                    
4000ef70:	02 80 00 10 	be  4000efb0 <_POSIX_Keys_Run_destructors+0x9c>
4000ef74:	82 00 80 19 	add  %g2, %i1, %g1                             
4000ef78:	c8 00 a0 10 	ld  [ %g2 + 0x10 ], %g4                        
4000ef7c:	80 a1 20 00 	cmp  %g4, 0                                    
4000ef80:	22 80 00 0d 	be,a   4000efb4 <_POSIX_Keys_Run_destructors+0xa0>
4000ef84:	b8 07 20 01 	inc  %i4                                       
        void *value = key->Values [ thread_api ][ thread_index ];     
4000ef88:	c8 00 60 04 	ld  [ %g1 + 4 ], %g4                           
4000ef8c:	d0 01 00 1a 	ld  [ %g4 + %i2 ], %o0                         
                                                                      
        if ( value != NULL ) {                                        
4000ef90:	80 a2 20 00 	cmp  %o0, 0                                    
4000ef94:	22 80 00 08 	be,a   4000efb4 <_POSIX_Keys_Run_destructors+0xa0><== ALWAYS TAKEN
4000ef98:	b8 07 20 01 	inc  %i4                                       
          key->Values [ thread_api ][ thread_index ] = NULL;          
4000ef9c:	c0 21 00 1a 	clr  [ %g4 + %i2 ]                             <== NOT EXECUTED
          (*key->destructor)( value );                                
4000efa0:	c2 00 a0 10 	ld  [ %g2 + 0x10 ], %g1                        <== NOT EXECUTED
4000efa4:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
4000efa8:	01 00 00 00 	nop                                            <== NOT EXECUTED
          done = false;                                               
4000efac:	86 10 20 00 	clr  %g3	! 0 <PROM_START>                      <== NOT EXECUTED
    Objects_Maximum index = 0;                                        
    Objects_Maximum max = _POSIX_Keys_Information.maximum;            
                                                                      
    done = true;                                                      
                                                                      
    for ( index = 1 ; index <= max ; ++index ) {                      
4000efb0:	b8 07 20 01 	inc  %i4                                       
4000efb4:	85 2f 20 10 	sll  %i4, 0x10, %g2                            
4000efb8:	85 30 a0 10 	srl  %g2, 0x10, %g2                            
4000efbc:	80 a6 c0 02 	cmp  %i3, %g2                                  
4000efc0:	1a bf ff e7 	bcc  4000ef5c <_POSIX_Keys_Run_destructors+0x48>
4000efc4:	80 88 e0 ff 	btst  0xff, %g3                                
   *  number of iterations.  An infinite loop may happen if destructors set
   *  thread specific data.  This can be considered dubious.          
   *                                                                  
   *  Reference: 17.1.1.2 P1003.1c/Draft 10, p. 163, line 99.         
   */                                                                 
  while ( !done ) {                                                   
4000efc8:	22 bf ff e0 	be,a   4000ef48 <_POSIX_Keys_Run_destructors+0x34><== NEVER TAKEN
4000efcc:	c2 17 60 10 	lduh  [ %i5 + 0x10 ], %g1                      <== NOT EXECUTED
4000efd0:	81 c7 e0 08 	ret                                            
4000efd4:	81 e8 00 00 	restore                                        
                                                                      

4000c228 <_POSIX_Message_queue_Receive_support>: size_t msg_len, unsigned int *msg_prio, bool wait, Watchdog_Interval timeout ) {
4000c228:	9d e3 bf 98 	save  %sp, -104, %sp                           
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *_POSIX_Message_queue_Get_fd (
  mqd_t              id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (POSIX_Message_queue_Control_fd *) _Objects_Get(             
4000c22c:	11 10 00 a3 	sethi  %hi(0x40028c00), %o0                    
4000c230:	92 10 00 18 	mov  %i0, %o1                                  
4000c234:	90 12 23 a0 	or  %o0, 0x3a0, %o0                            
4000c238:	40 00 0d 8d 	call  4000f86c <_Objects_Get>                  
4000c23c:	94 07 bf f8 	add  %fp, -8, %o2                              
  Objects_Locations                location;                          
  size_t                           length_out;                        
  bool                             do_wait;                           
                                                                      
  the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );        
  switch ( location ) {                                               
4000c240:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
4000c244:	80 a0 60 00 	cmp  %g1, 0                                    
4000c248:	22 80 00 08 	be,a   4000c268 <_POSIX_Message_queue_Receive_support+0x40>
4000c24c:	c2 02 20 14 	ld  [ %o0 + 0x14 ], %g1                        
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  rtems_set_errno_and_return_minus_one( EBADF );                      
4000c250:	40 00 29 59 	call  400167b4 <__errno>                       
4000c254:	b0 10 3f ff 	mov  -1, %i0                                   
4000c258:	82 10 20 09 	mov  9, %g1                                    
4000c25c:	c2 22 00 00 	st  %g1, [ %o0 ]                               
}                                                                     
4000c260:	81 c7 e0 08 	ret                                            
4000c264:	81 e8 00 00 	restore                                        
                                                                      
  the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );        
  switch ( location ) {                                               
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {             
4000c268:	84 08 60 03 	and  %g1, 3, %g2                               
4000c26c:	80 a0 a0 01 	cmp  %g2, 1                                    
4000c270:	02 80 00 39 	be  4000c354 <_POSIX_Message_queue_Receive_support+0x12c>
4000c274:	01 00 00 00 	nop                                            
        _Thread_Enable_dispatch();                                    
        rtems_set_errno_and_return_minus_one( EBADF );                
      }                                                               
                                                                      
      the_mq = the_mq_fd->Queue;                                      
4000c278:	d0 02 20 10 	ld  [ %o0 + 0x10 ], %o0                        
                                                                      
      if ( msg_len < the_mq->Message_queue.maximum_message_size ) {   
4000c27c:	c4 02 20 68 	ld  [ %o0 + 0x68 ], %g2                        
4000c280:	80 a0 80 1a 	cmp  %g2, %i2                                  
4000c284:	18 80 00 23 	bgu  4000c310 <_POSIX_Message_queue_Receive_support+0xe8>
4000c288:	84 10 3f ff 	mov  -1, %g2                                   
      /*                                                              
       *  Now if something goes wrong, we return a "length" of -1     
       *  to indicate an error.                                       
       */                                                             
                                                                      
      length_out = -1;                                                
4000c28c:	c4 27 bf fc 	st  %g2, [ %fp + -4 ]                          
                                                                      
      /*                                                              
       *  A timed receive with a bad time will do a poll regardless.  
       */                                                             
      if ( wait )                                                     
4000c290:	80 a7 20 00 	cmp  %i4, 0                                    
4000c294:	12 80 00 1b 	bne  4000c300 <_POSIX_Message_queue_Receive_support+0xd8>
4000c298:	98 10 20 00 	clr  %o4                                       
        do_wait = wait;                                               
                                                                      
      /*                                                              
       *  Now perform the actual message receive                      
       */                                                             
      _CORE_message_queue_Seize(                                      
4000c29c:	9a 10 00 1d 	mov  %i5, %o5                                  
4000c2a0:	90 02 20 1c 	add  %o0, 0x1c, %o0                            
4000c2a4:	92 10 00 18 	mov  %i0, %o1                                  
4000c2a8:	94 10 00 19 	mov  %i1, %o2                                  
4000c2ac:	96 07 bf fc 	add  %fp, -4, %o3                              
4000c2b0:	40 00 08 f2 	call  4000e678 <_CORE_message_queue_Seize>     
4000c2b4:	98 0b 20 01 	and  %o4, 1, %o4                               
        &length_out,                                                  
        do_wait,                                                      
        timeout                                                       
      );                                                              
                                                                      
      _Thread_Enable_dispatch();                                      
4000c2b8:	40 00 11 48 	call  400107d8 <_Thread_Enable_dispatch>       
4000c2bc:	3b 10 00 a4 	sethi  %hi(0x40029000), %i5                    
      if (msg_prio) {                                                 
4000c2c0:	80 a6 e0 00 	cmp  %i3, 0                                    
        *msg_prio = _POSIX_Message_queue_Priority_from_core(          
             _Thread_Executing->Wait.count                            
4000c2c4:	ba 17 60 20 	or  %i5, 0x20, %i5                             
        do_wait,                                                      
        timeout                                                       
      );                                                              
                                                                      
      _Thread_Enable_dispatch();                                      
      if (msg_prio) {                                                 
4000c2c8:	02 80 00 07 	be  4000c2e4 <_POSIX_Message_queue_Receive_support+0xbc><== NEVER TAKEN
4000c2cc:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
RTEMS_INLINE_ROUTINE unsigned int _POSIX_Message_queue_Priority_from_core(
  CORE_message_queue_Submit_types priority                            
)                                                                     
{                                                                     
  /* absolute value without a library dependency */                   
  return (unsigned int) ((priority >= 0) ? priority : -priority);     
4000c2d0:	c6 00 60 24 	ld  [ %g1 + 0x24 ], %g3                        
4000c2d4:	85 38 e0 1f 	sra  %g3, 0x1f, %g2                            
4000c2d8:	86 18 80 03 	xor  %g2, %g3, %g3                             
4000c2dc:	84 20 c0 02 	sub  %g3, %g2, %g2                             
        *msg_prio = _POSIX_Message_queue_Priority_from_core(          
4000c2e0:	c4 26 c0 00 	st  %g2, [ %i3 ]                               
             _Thread_Executing->Wait.count                            
          );                                                          
      }                                                               
                                                                      
      if ( !_Thread_Executing->Wait.return_code )                     
4000c2e4:	c2 00 60 34 	ld  [ %g1 + 0x34 ], %g1                        
4000c2e8:	80 a0 60 00 	cmp  %g1, 0                                    
4000c2ec:	12 80 00 11 	bne  4000c330 <_POSIX_Message_queue_Receive_support+0x108>
4000c2f0:	01 00 00 00 	nop                                            
        return length_out;                                            
4000c2f4:	f0 07 bf fc 	ld  [ %fp + -4 ], %i0                          
4000c2f8:	81 c7 e0 08 	ret                                            
4000c2fc:	81 e8 00 00 	restore                                        
                                                                      
      /*                                                              
       *  A timed receive with a bad time will do a poll regardless.  
       */                                                             
      if ( wait )                                                     
        do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true;     
4000c300:	99 30 60 0e 	srl  %g1, 0xe, %o4                             
4000c304:	98 1b 20 01 	xor  %o4, 1, %o4                               
4000c308:	10 bf ff e5 	b  4000c29c <_POSIX_Message_queue_Receive_support+0x74>
4000c30c:	98 0b 20 01 	and  %o4, 1, %o4                               
      }                                                               
                                                                      
      the_mq = the_mq_fd->Queue;                                      
                                                                      
      if ( msg_len < the_mq->Message_queue.maximum_message_size ) {   
        _Thread_Enable_dispatch();                                    
4000c310:	40 00 11 32 	call  400107d8 <_Thread_Enable_dispatch>       
4000c314:	b0 10 3f ff 	mov  -1, %i0                                   
        rtems_set_errno_and_return_minus_one( EMSGSIZE );             
4000c318:	40 00 29 27 	call  400167b4 <__errno>                       
4000c31c:	01 00 00 00 	nop                                            
4000c320:	82 10 20 7a 	mov  0x7a, %g1	! 7a <PROM_START+0x7a>          
4000c324:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4000c328:	81 c7 e0 08 	ret                                            
4000c32c:	81 e8 00 00 	restore                                        
      }                                                               
                                                                      
      if ( !_Thread_Executing->Wait.return_code )                     
        return length_out;                                            
                                                                      
      rtems_set_errno_and_return_minus_one(                           
4000c330:	40 00 29 21 	call  400167b4 <__errno>                       
4000c334:	b0 10 3f ff 	mov  -1, %i0                                   
4000c338:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
4000c33c:	b8 10 00 08 	mov  %o0, %i4                                  
4000c340:	40 00 00 a2 	call  4000c5c8 <_POSIX_Message_queue_Translate_core_message_queue_return_code>
4000c344:	d0 00 60 34 	ld  [ %g1 + 0x34 ], %o0                        
4000c348:	d0 27 00 00 	st  %o0, [ %i4 ]                               
4000c34c:	81 c7 e0 08 	ret                                            
4000c350:	81 e8 00 00 	restore                                        
  the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );        
  switch ( location ) {                                               
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {             
        _Thread_Enable_dispatch();                                    
4000c354:	40 00 11 21 	call  400107d8 <_Thread_Enable_dispatch>       
4000c358:	b0 10 3f ff 	mov  -1, %i0                                   
        rtems_set_errno_and_return_minus_one( EBADF );                
4000c35c:	40 00 29 16 	call  400167b4 <__errno>                       
4000c360:	01 00 00 00 	nop                                            
4000c364:	82 10 20 09 	mov  9, %g1	! 9 <PROM_START+0x9>               
4000c368:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4000c36c:	81 c7 e0 08 	ret                                            
4000c370:	81 e8 00 00 	restore                                        
                                                                      

4000ecf0 <_POSIX_Semaphore_Create_support>: size_t name_len, int pshared, unsigned int value, POSIX_Semaphore_Control **the_sem ) {
4000ecf0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  POSIX_Semaphore_Control   *the_semaphore;                           
  CORE_semaphore_Attributes *the_sem_attr;                            
  char                      *name;                                    
                                                                      
  /* Sharing semaphores among processes is not currently supported */ 
  if (pshared != 0)                                                   
4000ecf4:	80 a6 a0 00 	cmp  %i2, 0                                    
4000ecf8:	12 80 00 2f 	bne  4000edb4 <_POSIX_Semaphore_Create_support+0xc4>
4000ecfc:	03 10 00 8e 	sethi  %hi(0x40023800), %g1                    
   *                                                                  
   * This rountine increments the thread dispatch level               
   */                                                                 
  RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
  {                                                                   
    uint32_t level = _Thread_Dispatch_disable_level;                  
4000ed00:	c4 00 60 c0 	ld  [ %g1 + 0xc0 ], %g2	! 400238c0 <_Thread_Dispatch_disable_level>
                                                                      
    ++level;                                                          
4000ed04:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
4000ed08:	c4 20 60 c0 	st  %g2, [ %g1 + 0xc0 ]                        
 *  _POSIX_Semaphore_Allocate                                         
 */                                                                   
                                                                      
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Allocate( void )
{                                                                     
  return (POSIX_Semaphore_Control *)                                  
4000ed0c:	35 10 00 8e 	sethi  %hi(0x40023800), %i2                    
4000ed10:	7f ff ee 48 	call  4000a630 <_Objects_Allocate>             
4000ed14:	90 16 a3 84 	or  %i2, 0x384, %o0	! 40023b84 <_POSIX_Semaphore_Information>
    rtems_set_errno_and_return_minus_one( ENOSYS );                   
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  the_semaphore = _POSIX_Semaphore_Allocate();                        
  if ( !the_semaphore ) {                                             
4000ed18:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4000ed1c:	02 80 00 2c 	be  4000edcc <_POSIX_Semaphore_Create_support+0xdc>
4000ed20:	80 a6 20 00 	cmp  %i0, 0                                    
                                                                      
  /*                                                                  
   * Make a copy of the user's string for name just in case it was    
   * dynamically constructed.                                         
   */                                                                 
  if ( name_arg != NULL ) {                                           
4000ed24:	02 80 00 1e 	be  4000ed9c <_POSIX_Semaphore_Create_support+0xac>
4000ed28:	92 10 00 19 	mov  %i1, %o1                                  
    name = _Workspace_String_duplicate( name_arg, name_len );         
4000ed2c:	40 00 04 10 	call  4000fd6c <_Workspace_String_duplicate>   
4000ed30:	90 10 00 18 	mov  %i0, %o0                                  
    if ( !name ) {                                                    
4000ed34:	b2 92 20 00 	orcc  %o0, 0, %i1                              
4000ed38:	02 80 00 2d 	be  4000edec <_POSIX_Semaphore_Create_support+0xfc><== NEVER TAKEN
4000ed3c:	82 10 20 01 	mov  1, %g1                                    
  }                                                                   
                                                                      
  the_semaphore->process_shared  = pshared;                           
                                                                      
  if ( name ) {                                                       
    the_semaphore->named = true;                                      
4000ed40:	84 10 20 01 	mov  1, %g2                                    
    }                                                                 
  } else {                                                            
    name = NULL;                                                      
  }                                                                   
                                                                      
  the_semaphore->process_shared  = pshared;                           
4000ed44:	c0 27 60 10 	clr  [ %i5 + 0x10 ]                            
                                                                      
  if ( name ) {                                                       
    the_semaphore->named = true;                                      
4000ed48:	c4 2f 60 14 	stb  %g2, [ %i5 + 0x14 ]                       
    the_semaphore->open_count = 1;                                    
4000ed4c:	c2 27 60 18 	st  %g1, [ %i5 + 0x18 ]                        
    the_semaphore->linked = true;                                     
4000ed50:	c2 2f 60 15 	stb  %g1, [ %i5 + 0x15 ]                       
  the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;         
                                                                      
  /*                                                                  
   *  This effectively disables limit checking.                       
   */                                                                 
  the_sem_attr->maximum_count = 0xFFFFFFFF;                           
4000ed54:	82 10 3f ff 	mov  -1, %g1                                   
                                                                      
  _CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
4000ed58:	90 07 60 1c 	add  %i5, 0x1c, %o0                            
4000ed5c:	92 07 60 5c 	add  %i5, 0x5c, %o1                            
4000ed60:	94 10 00 1b 	mov  %i3, %o2                                  
  the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;         
                                                                      
  /*                                                                  
   *  This effectively disables limit checking.                       
   */                                                                 
  the_sem_attr->maximum_count = 0xFFFFFFFF;                           
4000ed64:	c2 27 60 5c 	st  %g1, [ %i5 + 0x5c ]                        
                                                                      
  _CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
4000ed68:	7f ff ec 8f 	call  40009fa4 <_CORE_semaphore_Initialize>    
4000ed6c:	c0 27 60 60 	clr  [ %i5 + 0x60 ]                            
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  const char          *name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
4000ed70:	c2 17 60 0a 	lduh  [ %i5 + 0xa ], %g1                       
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
4000ed74:	b4 16 a3 84 	or  %i2, 0x384, %i2                            
4000ed78:	c4 06 a0 1c 	ld  [ %i2 + 0x1c ], %g2                        
4000ed7c:	83 28 60 02 	sll  %g1, 2, %g1                               
4000ed80:	fa 20 80 01 	st  %i5, [ %g2 + %g1 ]                         
    the_object                                                        
  );                                                                  
                                                                      
  #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)                 
    /* ASSERT: information->is_string */                              
    the_object->name.name_p = name;                                   
4000ed84:	f2 27 60 0c 	st  %i1, [ %i5 + 0xc ]                         
    &_POSIX_Semaphore_Information,                                    
    &the_semaphore->Object,                                           
    name                                                              
  );                                                                  
                                                                      
  *the_sem = the_semaphore;                                           
4000ed88:	fa 27 00 00 	st  %i5, [ %i4 ]                               
                                                                      
  _Thread_Enable_dispatch();                                          
4000ed8c:	7f ff f3 75 	call  4000bb60 <_Thread_Enable_dispatch>       
4000ed90:	b0 10 20 00 	clr  %i0                                       
  return 0;                                                           
4000ed94:	81 c7 e0 08 	ret                                            
4000ed98:	81 e8 00 00 	restore                                        
    }                                                                 
  } else {                                                            
    name = NULL;                                                      
  }                                                                   
                                                                      
  the_semaphore->process_shared  = pshared;                           
4000ed9c:	c0 27 60 10 	clr  [ %i5 + 0x10 ]                            
  if ( name ) {                                                       
    the_semaphore->named = true;                                      
    the_semaphore->open_count = 1;                                    
    the_semaphore->linked = true;                                     
  } else {                                                            
    the_semaphore->named = false;                                     
4000eda0:	c0 2f 60 14 	clrb  [ %i5 + 0x14 ]                           
    the_semaphore->open_count = 0;                                    
4000eda4:	c0 27 60 18 	clr  [ %i5 + 0x18 ]                            
    the_semaphore->linked = false;                                    
4000eda8:	c0 2f 60 15 	clrb  [ %i5 + 0x15 ]                           
      _POSIX_Semaphore_Free( the_semaphore );                         
      _Thread_Enable_dispatch();                                      
      rtems_set_errno_and_return_minus_one( ENOMEM );                 
    }                                                                 
  } else {                                                            
    name = NULL;                                                      
4000edac:	10 bf ff ea 	b  4000ed54 <_POSIX_Semaphore_Create_support+0x64>
4000edb0:	b2 10 20 00 	clr  %i1                                       
  CORE_semaphore_Attributes *the_sem_attr;                            
  char                      *name;                                    
                                                                      
  /* Sharing semaphores among processes is not currently supported */ 
  if (pshared != 0)                                                   
    rtems_set_errno_and_return_minus_one( ENOSYS );                   
4000edb4:	40 00 0a 2a 	call  4001165c <__errno>                       
4000edb8:	b0 10 3f ff 	mov  -1, %i0                                   
4000edbc:	82 10 20 58 	mov  0x58, %g1                                 
4000edc0:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4000edc4:	81 c7 e0 08 	ret                                            
4000edc8:	81 e8 00 00 	restore                                        
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  the_semaphore = _POSIX_Semaphore_Allocate();                        
  if ( !the_semaphore ) {                                             
    _Thread_Enable_dispatch();                                        
4000edcc:	7f ff f3 65 	call  4000bb60 <_Thread_Enable_dispatch>       
4000edd0:	b0 10 3f ff 	mov  -1, %i0                                   
    rtems_set_errno_and_return_minus_one( ENOSPC );                   
4000edd4:	40 00 0a 22 	call  4001165c <__errno>                       
4000edd8:	01 00 00 00 	nop                                            
4000eddc:	82 10 20 1c 	mov  0x1c, %g1	! 1c <PROM_START+0x1c>          
4000ede0:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4000ede4:	81 c7 e0 08 	ret                                            
4000ede8:	81 e8 00 00 	restore                                        
                                                                      
RTEMS_INLINE_ROUTINE void _POSIX_Semaphore_Free (                     
  POSIX_Semaphore_Control *the_semaphore                              
)                                                                     
{                                                                     
  _Objects_Free( &_POSIX_Semaphore_Information, &the_semaphore->Object );
4000edec:	90 16 a3 84 	or  %i2, 0x384, %o0                            <== NOT EXECUTED
4000edf0:	7f ff ef 08 	call  4000aa10 <_Objects_Free>                 <== NOT EXECUTED
4000edf4:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
   */                                                                 
  if ( name_arg != NULL ) {                                           
    name = _Workspace_String_duplicate( name_arg, name_len );         
    if ( !name ) {                                                    
      _POSIX_Semaphore_Free( the_semaphore );                         
      _Thread_Enable_dispatch();                                      
4000edf8:	7f ff f3 5a 	call  4000bb60 <_Thread_Enable_dispatch>       <== NOT EXECUTED
4000edfc:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
      rtems_set_errno_and_return_minus_one( ENOMEM );                 
4000ee00:	40 00 0a 17 	call  4001165c <__errno>                       <== NOT EXECUTED
4000ee04:	01 00 00 00 	nop                                            <== NOT EXECUTED
4000ee08:	82 10 20 0c 	mov  0xc, %g1	! c <PROM_START+0xc>             <== NOT EXECUTED
4000ee0c:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4000ee10:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000ee14:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4000c3a4 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>: Thread_Control *the_thread ) { POSIX_API_Control *thread_support; thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
4000c3a4:	c2 02 21 50 	ld  [ %o0 + 0x150 ], %g1                       
                                                                      
  if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
4000c3a8:	c4 00 60 d8 	ld  [ %g1 + 0xd8 ], %g2                        
4000c3ac:	80 a0 a0 00 	cmp  %g2, 0                                    
4000c3b0:	12 80 00 06 	bne  4000c3c8 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x24><== NEVER TAKEN
4000c3b4:	01 00 00 00 	nop                                            
4000c3b8:	c4 00 60 dc 	ld  [ %g1 + 0xdc ], %g2                        
4000c3bc:	80 a0 a0 01 	cmp  %g2, 1                                    
4000c3c0:	22 80 00 05 	be,a   4000c3d4 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x30>
4000c3c4:	c2 00 60 e0 	ld  [ %g1 + 0xe0 ], %g1                        
       thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
       thread_support->cancelation_requested ) {                      
    _Thread_Unnest_dispatch();                                        
    _POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );               
  } else                                                              
    _Thread_Enable_dispatch();                                        
4000c3c8:	82 13 c0 00 	mov  %o7, %g1                                  
4000c3cc:	7f ff f6 3c 	call  40009cbc <_Thread_Enable_dispatch>       
4000c3d0:	9e 10 40 00 	mov  %g1, %o7                                  
  POSIX_API_Control *thread_support;                                  
                                                                      
  thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];    
                                                                      
  if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
       thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
4000c3d4:	80 a0 60 00 	cmp  %g1, 0                                    
4000c3d8:	02 bf ff fc 	be  4000c3c8 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x24>
4000c3dc:	01 00 00 00 	nop                                            
   *                                                                  
   * This routine decrements the thread dispatch level.               
   */                                                                 
  RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
  {                                                                   
    uint32_t level = _Thread_Dispatch_disable_level;                  
4000c3e0:	03 10 00 5f 	sethi  %hi(0x40017c00), %g1                    
4000c3e4:	c4 00 60 f0 	ld  [ %g1 + 0xf0 ], %g2	! 40017cf0 <_Thread_Dispatch_disable_level>
       thread_support->cancelation_requested ) {                      
    _Thread_Unnest_dispatch();                                        
    _POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );               
4000c3e8:	92 10 3f ff 	mov  -1, %o1                                   
                                                                      
    --level;                                                          
4000c3ec:	84 00 bf ff 	add  %g2, -1, %g2                              
    _Thread_Dispatch_disable_level = level;                           
4000c3f0:	c4 20 60 f0 	st  %g2, [ %g1 + 0xf0 ]                        
4000c3f4:	82 13 c0 00 	mov  %o7, %g1                                  
4000c3f8:	40 00 01 d9 	call  4000cb5c <_POSIX_Thread_Exit>            
4000c3fc:	9e 10 40 00 	mov  %g1, %o7                                  
                                                                      

4000d8a0 <_POSIX_Thread_Translate_sched_param>: int policy, struct sched_param *param, Thread_CPU_budget_algorithms *budget_algorithm, Thread_CPU_budget_algorithm_callout *budget_callout ) {
4000d8a0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )           
4000d8a4:	7f ff ff f2 	call  4000d86c <_POSIX_Priority_Is_valid>      
4000d8a8:	d0 06 40 00 	ld  [ %i1 ], %o0                               
4000d8ac:	80 8a 20 ff 	btst  0xff, %o0                                
4000d8b0:	32 80 00 04 	bne,a   4000d8c0 <_POSIX_Thread_Translate_sched_param+0x20><== ALWAYS TAKEN
4000d8b4:	c0 26 80 00 	clr  [ %i2 ]                                   
    return EINVAL;                                                    
4000d8b8:	81 c7 e0 08 	ret                                            
4000d8bc:	91 e8 20 16 	restore  %g0, 0x16, %o0                        
                                                                      
  *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;               
  *budget_callout = NULL;                                             
                                                                      
  if ( policy == SCHED_OTHER ) {                                      
4000d8c0:	80 a6 20 00 	cmp  %i0, 0                                    
4000d8c4:	02 80 00 2c 	be  4000d974 <_POSIX_Thread_Translate_sched_param+0xd4>
4000d8c8:	c0 26 c0 00 	clr  [ %i3 ]                                   
    *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;  
    return 0;                                                         
  }                                                                   
                                                                      
  if ( policy == SCHED_FIFO ) {                                       
4000d8cc:	80 a6 20 01 	cmp  %i0, 1                                    
4000d8d0:	02 80 00 2d 	be  4000d984 <_POSIX_Thread_Translate_sched_param+0xe4>
4000d8d4:	80 a6 20 02 	cmp  %i0, 2                                    
    *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;             
    return 0;                                                         
  }                                                                   
                                                                      
  if ( policy == SCHED_RR ) {                                         
4000d8d8:	02 80 00 2d 	be  4000d98c <_POSIX_Thread_Translate_sched_param+0xec>
4000d8dc:	80 a6 20 04 	cmp  %i0, 4                                    
    *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
    return 0;                                                         
  }                                                                   
                                                                      
  if ( policy == SCHED_SPORADIC ) {                                   
4000d8e0:	12 bf ff f6 	bne  4000d8b8 <_POSIX_Thread_Translate_sched_param+0x18>
4000d8e4:	01 00 00 00 	nop                                            
    if ( (param->sched_ss_repl_period.tv_sec == 0) &&                 
4000d8e8:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
4000d8ec:	80 a0 60 00 	cmp  %g1, 0                                    
4000d8f0:	32 80 00 07 	bne,a   4000d90c <_POSIX_Thread_Translate_sched_param+0x6c>
4000d8f4:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1                        
4000d8f8:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
4000d8fc:	80 a0 60 00 	cmp  %g1, 0                                    
4000d900:	02 bf ff ee 	be  4000d8b8 <_POSIX_Thread_Translate_sched_param+0x18>
4000d904:	01 00 00 00 	nop                                            
         (param->sched_ss_repl_period.tv_nsec == 0) )                 
      return EINVAL;                                                  
                                                                      
    if ( (param->sched_ss_init_budget.tv_sec == 0) &&                 
4000d908:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1                        
4000d90c:	80 a0 60 00 	cmp  %g1, 0                                    
4000d910:	12 80 00 06 	bne  4000d928 <_POSIX_Thread_Translate_sched_param+0x88>
4000d914:	01 00 00 00 	nop                                            
4000d918:	c2 06 60 14 	ld  [ %i1 + 0x14 ], %g1                        
4000d91c:	80 a0 60 00 	cmp  %g1, 0                                    
4000d920:	02 bf ff e6 	be  4000d8b8 <_POSIX_Thread_Translate_sched_param+0x18>
4000d924:	01 00 00 00 	nop                                            
         (param->sched_ss_init_budget.tv_nsec == 0) )                 
      return EINVAL;                                                  
                                                                      
    if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <         
4000d928:	7f ff f7 45 	call  4000b63c <_Timespec_To_ticks>            
4000d92c:	90 06 60 08 	add  %i1, 8, %o0                               
4000d930:	ba 10 00 08 	mov  %o0, %i5                                  
	 _Timespec_To_ticks( ¶m->sched_ss_init_budget ) )                
4000d934:	7f ff f7 42 	call  4000b63c <_Timespec_To_ticks>            
4000d938:	90 06 60 10 	add  %i1, 0x10, %o0                            
                                                                      
    if ( (param->sched_ss_init_budget.tv_sec == 0) &&                 
         (param->sched_ss_init_budget.tv_nsec == 0) )                 
      return EINVAL;                                                  
                                                                      
    if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <         
4000d93c:	80 a7 40 08 	cmp  %i5, %o0                                  
4000d940:	0a bf ff de 	bcs  4000d8b8 <_POSIX_Thread_Translate_sched_param+0x18>
4000d944:	01 00 00 00 	nop                                            
	 _Timespec_To_ticks( ¶m->sched_ss_init_budget ) )                
      return EINVAL;                                                  
                                                                      
    if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) )  
4000d948:	7f ff ff c9 	call  4000d86c <_POSIX_Priority_Is_valid>      
4000d94c:	d0 06 60 04 	ld  [ %i1 + 4 ], %o0                           
4000d950:	80 8a 20 ff 	btst  0xff, %o0                                
4000d954:	02 bf ff d9 	be  4000d8b8 <_POSIX_Thread_Translate_sched_param+0x18>
4000d958:	82 10 20 03 	mov  3, %g1                                    
      return EINVAL;                                                  
                                                                      
    *budget_algorithm  = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;         
4000d95c:	c2 26 80 00 	st  %g1, [ %i2 ]                               
    *budget_callout = _POSIX_Threads_Sporadic_budget_callout;         
4000d960:	03 10 00 1d 	sethi  %hi(0x40007400), %g1                    
4000d964:	82 10 62 ac 	or  %g1, 0x2ac, %g1	! 400076ac <_POSIX_Threads_Sporadic_budget_callout>
4000d968:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
    return 0;                                                         
4000d96c:	81 c7 e0 08 	ret                                            
4000d970:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      
  *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;               
  *budget_callout = NULL;                                             
                                                                      
  if ( policy == SCHED_OTHER ) {                                      
    *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;  
4000d974:	82 10 20 01 	mov  1, %g1                                    
4000d978:	c2 26 80 00 	st  %g1, [ %i2 ]                               
    return 0;                                                         
4000d97c:	81 c7 e0 08 	ret                                            
4000d980:	81 e8 00 00 	restore                                        
    *budget_callout = _POSIX_Threads_Sporadic_budget_callout;         
    return 0;                                                         
  }                                                                   
                                                                      
  return EINVAL;                                                      
}                                                                     
4000d984:	81 c7 e0 08 	ret                                            
4000d988:	91 e8 20 00 	restore  %g0, 0, %o0                           
    *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;             
    return 0;                                                         
  }                                                                   
                                                                      
  if ( policy == SCHED_RR ) {                                         
    *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
4000d98c:	f0 26 80 00 	st  %i0, [ %i2 ]                               
    return 0;                                                         
4000d990:	81 c7 e0 08 	ret                                            
4000d994:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

4000cadc <_POSIX_Threads_Delete_extension>: */ static void _POSIX_Threads_Delete_extension( Thread_Control *executing __attribute__((unused)), Thread_Control *deleted ) {
4000cadc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Thread_Control     *the_thread;                                     
  POSIX_API_Control  *api;                                            
  void              **value_ptr;                                      
                                                                      
  api = deleted->API_Extensions[ THREAD_API_POSIX ];                  
4000cae0:	f0 06 61 50 	ld  [ %i1 + 0x150 ], %i0                       
                                                                      
  /*                                                                  
   *  Run the POSIX cancellation handlers                             
   */                                                                 
  _POSIX_Threads_cancel_run( deleted );                               
4000cae4:	40 00 08 f0 	call  4000eea4 <_POSIX_Threads_cancel_run>     
4000cae8:	90 10 00 19 	mov  %i1, %o0                                  
                                                                      
  /*                                                                  
   *  Run all the key destructors                                     
   */                                                                 
  _POSIX_Keys_Run_destructors( deleted );                             
4000caec:	90 10 00 19 	mov  %i1, %o0                                  
4000caf0:	40 00 09 09 	call  4000ef14 <_POSIX_Keys_Run_destructors>   
4000caf4:	ba 06 20 44 	add  %i0, 0x44, %i5                            
  /*                                                                  
   *  Wakeup all the tasks which joined with this one                 
   */                                                                 
  value_ptr = (void **) deleted->Wait.return_argument;                
                                                                      
  while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) )   
4000caf8:	10 80 00 03 	b  4000cb04 <_POSIX_Threads_Delete_extension+0x28>
4000cafc:	f8 06 60 28 	ld  [ %i1 + 0x28 ], %i4                        
      *(void **)the_thread->Wait.return_argument = value_ptr;         
4000cb00:	f8 20 40 00 	st  %i4, [ %g1 ]                               <== NOT EXECUTED
  /*                                                                  
   *  Wakeup all the tasks which joined with this one                 
   */                                                                 
  value_ptr = (void **) deleted->Wait.return_argument;                
                                                                      
  while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) )   
4000cb04:	7f ff f5 ca 	call  4000a22c <_Thread_queue_Dequeue>         
4000cb08:	90 10 00 1d 	mov  %i5, %o0                                  
4000cb0c:	80 a2 20 00 	cmp  %o0, 0                                    
4000cb10:	32 bf ff fc 	bne,a   4000cb00 <_POSIX_Threads_Delete_extension+0x24><== NEVER TAKEN
4000cb14:	c2 02 20 28 	ld  [ %o0 + 0x28 ], %g1                        <== NOT EXECUTED
      *(void **)the_thread->Wait.return_argument = value_ptr;         
                                                                      
  if ( api->schedpolicy == SCHED_SPORADIC )                           
4000cb18:	c2 06 20 84 	ld  [ %i0 + 0x84 ], %g1                        
4000cb1c:	80 a0 60 04 	cmp  %g1, 4                                    
4000cb20:	02 80 00 05 	be  4000cb34 <_POSIX_Threads_Delete_extension+0x58>
4000cb24:	01 00 00 00 	nop                                            
    (void) _Watchdog_Remove( &api->Sporadic_timer );                  
                                                                      
  deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;                 
4000cb28:	c0 26 61 50 	clr  [ %i1 + 0x150 ]                           
                                                                      
  _Workspace_Free( api );                                             
4000cb2c:	7f ff f9 40 	call  4000b02c <_Workspace_Free>               
4000cb30:	81 e8 00 00 	restore                                        
                                                                      
  while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) )   
      *(void **)the_thread->Wait.return_argument = value_ptr;         
                                                                      
  if ( api->schedpolicy == SCHED_SPORADIC )                           
    (void) _Watchdog_Remove( &api->Sporadic_timer );                  
4000cb34:	7f ff f8 80 	call  4000ad34 <_Watchdog_Remove>              
4000cb38:	90 06 20 a8 	add  %i0, 0xa8, %o0                            
                                                                      
  deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;                 
4000cb3c:	c0 26 61 50 	clr  [ %i1 + 0x150 ]                           
                                                                      
  _Workspace_Free( api );                                             
4000cb40:	7f ff f9 3b 	call  4000b02c <_Workspace_Free>               
4000cb44:	81 e8 00 00 	restore                                        
                                                                      

400073c0 <_POSIX_Threads_Initialize_user_threads_body>: #include <rtems/posix/config.h> #include <rtems/posix/key.h> #include <rtems/posix/time.h> void _POSIX_Threads_Initialize_user_threads_body(void) {
400073c0:	9d e3 bf 58 	save  %sp, -168, %sp                           
  uint32_t                            maximum;                        
  posix_initialization_threads_table *user_threads;                   
  pthread_t                           thread_id;                      
  pthread_attr_t                      attr;                           
                                                                      
  user_threads = Configuration_POSIX_API.User_initialization_threads_table;
400073c4:	03 10 00 7b 	sethi  %hi(0x4001ec00), %g1                    
400073c8:	82 10 62 04 	or  %g1, 0x204, %g1	! 4001ee04 <Configuration_POSIX_API>
  maximum      = Configuration_POSIX_API.number_of_initialization_threads;
400073cc:	f6 00 60 30 	ld  [ %g1 + 0x30 ], %i3                        
                                                                      
  if ( !user_threads || maximum == 0 )                                
400073d0:	80 a6 e0 00 	cmp  %i3, 0                                    
400073d4:	02 80 00 18 	be  40007434 <_POSIX_Threads_Initialize_user_threads_body+0x74><== NEVER TAKEN
400073d8:	fa 00 60 34 	ld  [ %g1 + 0x34 ], %i5                        
400073dc:	80 a7 60 00 	cmp  %i5, 0                                    
400073e0:	02 80 00 15 	be  40007434 <_POSIX_Threads_Initialize_user_threads_body+0x74><== NEVER TAKEN
400073e4:	b8 10 20 00 	clr  %i4                                       
                                                                      
  for ( index=0 ; index < maximum ; index++ ) {                       
    /*                                                                
     * There is no way for these calls to fail in this situation.     
     */                                                               
    (void) pthread_attr_init( &attr );                                
400073e8:	40 00 19 6c 	call  4000d998 <pthread_attr_init>             
400073ec:	90 07 bf c0 	add  %fp, -64, %o0                             
    (void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
400073f0:	92 10 20 02 	mov  2, %o1                                    
400073f4:	40 00 19 75 	call  4000d9c8 <pthread_attr_setinheritsched>  
400073f8:	90 07 bf c0 	add  %fp, -64, %o0                             
    (void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
400073fc:	d2 07 60 04 	ld  [ %i5 + 4 ], %o1                           
40007400:	40 00 19 82 	call  4000da08 <pthread_attr_setstacksize>     
40007404:	90 07 bf c0 	add  %fp, -64, %o0                             
                                                                      
    status = pthread_create(                                          
40007408:	d4 07 40 00 	ld  [ %i5 ], %o2                               
4000740c:	90 07 bf bc 	add  %fp, -68, %o0                             
40007410:	92 07 bf c0 	add  %fp, -64, %o1                             
40007414:	7f ff ff 00 	call  40007014 <pthread_create>                
40007418:	96 10 20 00 	clr  %o3                                       
      &thread_id,                                                     
      &attr,                                                          
      user_threads[ index ].thread_entry,                             
      NULL                                                            
    );                                                                
    if ( status )                                                     
4000741c:	94 92 20 00 	orcc  %o0, 0, %o2                              
40007420:	12 80 00 07 	bne  4000743c <_POSIX_Threads_Initialize_user_threads_body+0x7c>
40007424:	b8 07 20 01 	inc  %i4                                       
   *                                                                  
   *  Setting the attributes explicitly is critical, since we don't want
   *  to inherit the idle tasks attributes.                           
   */                                                                 
                                                                      
  for ( index=0 ; index < maximum ; index++ ) {                       
40007428:	80 a7 00 1b 	cmp  %i4, %i3                                  
4000742c:	12 bf ff ef 	bne  400073e8 <_POSIX_Threads_Initialize_user_threads_body+0x28><== NEVER TAKEN
40007430:	ba 07 60 08 	add  %i5, 8, %i5                               
40007434:	81 c7 e0 08 	ret                                            
40007438:	81 e8 00 00 	restore                                        
      &attr,                                                          
      user_threads[ index ].thread_entry,                             
      NULL                                                            
    );                                                                
    if ( status )                                                     
      _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
4000743c:	90 10 20 02 	mov  2, %o0                                    
40007440:	40 00 08 79 	call  40009624 <_Internal_error_Occurred>      
40007444:	92 10 20 01 	mov  1, %o1                                    
                                                                      

4000cc68 <_POSIX_Threads_Sporadic_budget_TSR>: */ void _POSIX_Threads_Sporadic_budget_TSR( Objects_Id id __attribute__((unused)), void *argument ) {
4000cc68:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Thread_Control     *the_thread;                                     
  POSIX_API_Control  *api;                                            
                                                                      
  the_thread = argument;                                              
                                                                      
  api = the_thread->API_Extensions[ THREAD_API_POSIX ];               
4000cc6c:	fa 06 61 50 	ld  [ %i1 + 0x150 ], %i5                       
                                                                      
  /* ticks is guaranteed to be at least one */                        
  ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_init_budget );
4000cc70:	40 00 03 bb 	call  4000db5c <_Timespec_To_ticks>            
4000cc74:	90 07 60 98 	add  %i5, 0x98, %o0                            
                                                                      
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(        
  int priority                                                        
)                                                                     
{                                                                     
  return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
4000cc78:	c4 07 60 88 	ld  [ %i5 + 0x88 ], %g2                        
4000cc7c:	03 10 00 78 	sethi  %hi(0x4001e000), %g1                    
4000cc80:	d2 08 62 dc 	ldub  [ %g1 + 0x2dc ], %o1	! 4001e2dc <rtems_maximum_priority>
   */                                                                 
  #if 0                                                               
    printk( "TSR %d %d %d\n", the_thread->resource_count,             
        the_thread->current_priority, new_priority );                 
  #endif                                                              
  if ( the_thread->resource_count == 0 ) {                            
4000cc84:	c2 06 60 1c 	ld  [ %i1 + 0x1c ], %g1                        
4000cc88:	92 22 40 02 	sub  %o1, %g2, %o1                             
  api = the_thread->API_Extensions[ THREAD_API_POSIX ];               
                                                                      
  /* ticks is guaranteed to be at least one */                        
  ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_init_budget );
                                                                      
  the_thread->cpu_time_budget = ticks;                                
4000cc8c:	d0 26 60 74 	st  %o0, [ %i1 + 0x74 ]                        
   */                                                                 
  #if 0                                                               
    printk( "TSR %d %d %d\n", the_thread->resource_count,             
        the_thread->current_priority, new_priority );                 
  #endif                                                              
  if ( the_thread->resource_count == 0 ) {                            
4000cc90:	80 a0 60 00 	cmp  %g1, 0                                    
4000cc94:	12 80 00 06 	bne  4000ccac <_POSIX_Threads_Sporadic_budget_TSR+0x44><== NEVER TAKEN
4000cc98:	d2 26 60 18 	st  %o1, [ %i1 + 0x18 ]                        
    /*                                                                
     *  If this would make them less important, then do not change it.
     */                                                               
    if ( the_thread->current_priority > new_priority ) {              
4000cc9c:	c2 06 60 14 	ld  [ %i1 + 0x14 ], %g1                        
4000cca0:	80 a0 40 09 	cmp  %g1, %o1                                  
4000cca4:	18 80 00 09 	bgu  4000ccc8 <_POSIX_Threads_Sporadic_budget_TSR+0x60>
4000cca8:	90 10 00 19 	mov  %i1, %o0                                  
      #endif                                                          
    }                                                                 
  }                                                                   
                                                                      
  /* ticks is guaranteed to be at least one */                        
  ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period );
4000ccac:	90 07 60 90 	add  %i5, 0x90, %o0                            
4000ccb0:	40 00 03 ab 	call  4000db5c <_Timespec_To_ticks>            
4000ccb4:	31 10 00 7b 	sethi  %hi(0x4001ec00), %i0                    
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
4000ccb8:	b2 07 60 a8 	add  %i5, 0xa8, %i1                            
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
4000ccbc:	d0 27 60 b4 	st  %o0, [ %i5 + 0xb4 ]                        
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
4000ccc0:	7f ff f7 be 	call  4000abb8 <_Watchdog_Insert>              
4000ccc4:	91 ee 23 58 	restore  %i0, 0x358, %o0                       
  if ( the_thread->resource_count == 0 ) {                            
    /*                                                                
     *  If this would make them less important, then do not change it.
     */                                                               
    if ( the_thread->current_priority > new_priority ) {              
      _Thread_Change_priority( the_thread, new_priority, true );      
4000ccc8:	7f ff f3 46 	call  400099e0 <_Thread_Change_priority>       
4000cccc:	94 10 20 01 	mov  1, %o2                                    
      #endif                                                          
    }                                                                 
  }                                                                   
                                                                      
  /* ticks is guaranteed to be at least one */                        
  ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period );
4000ccd0:	90 07 60 90 	add  %i5, 0x90, %o0                            
4000ccd4:	40 00 03 a2 	call  4000db5c <_Timespec_To_ticks>            
4000ccd8:	31 10 00 7b 	sethi  %hi(0x4001ec00), %i0                    
4000ccdc:	b2 07 60 a8 	add  %i5, 0xa8, %i1                            
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
4000cce0:	d0 27 60 b4 	st  %o0, [ %i5 + 0xb4 ]                        
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
4000cce4:	7f ff f7 b5 	call  4000abb8 <_Watchdog_Insert>              
4000cce8:	91 ee 23 58 	restore  %i0, 0x358, %o0                       
                                                                      

4000ccec <_POSIX_Threads_Sporadic_budget_callout>: ) { POSIX_API_Control *api; uint32_t new_priority; api = the_thread->API_Extensions[ THREAD_API_POSIX ];
4000ccec:	c4 02 21 50 	ld  [ %o0 + 0x150 ], %g2                       
4000ccf0:	c6 00 a0 8c 	ld  [ %g2 + 0x8c ], %g3                        
4000ccf4:	05 10 00 78 	sethi  %hi(0x4001e000), %g2                    
4000ccf8:	d2 08 a2 dc 	ldub  [ %g2 + 0x2dc ], %o1	! 4001e2dc <rtems_maximum_priority>
   */                                                                 
  #if 0                                                               
    printk( "callout %d %d %d\n", the_thread->resource_count,         
	the_thread->current_priority, new_priority );                        
  #endif                                                              
  if ( the_thread->resource_count == 0 ) {                            
4000ccfc:	c4 02 20 1c 	ld  [ %o0 + 0x1c ], %g2                        
4000cd00:	92 22 40 03 	sub  %o1, %g3, %o1                             
                                                                      
  /*                                                                  
   *  This will prevent the thread from consuming its entire "budget" 
   *  while at low priority.                                          
   */                                                                 
  the_thread->cpu_time_budget = 0xFFFFFFFF; /* XXX should be based on MAX_U32 */
4000cd04:	86 10 3f ff 	mov  -1, %g3                                   
                                                                      
  new_priority = _POSIX_Priority_To_core(api->schedparam.sched_ss_low_priority);
  the_thread->real_priority = new_priority;                           
4000cd08:	d2 22 20 18 	st  %o1, [ %o0 + 0x18 ]                        
   */                                                                 
  #if 0                                                               
    printk( "callout %d %d %d\n", the_thread->resource_count,         
	the_thread->current_priority, new_priority );                        
  #endif                                                              
  if ( the_thread->resource_count == 0 ) {                            
4000cd0c:	80 a0 a0 00 	cmp  %g2, 0                                    
4000cd10:	12 80 00 06 	bne  4000cd28 <_POSIX_Threads_Sporadic_budget_callout+0x3c><== NEVER TAKEN
4000cd14:	c6 22 20 74 	st  %g3, [ %o0 + 0x74 ]                        
    /*                                                                
     *  Make sure we are actually lowering it. If they have lowered it
     *  to logically lower than sched_ss_low_priority, then we do not want to
     *  change it.                                                    
     */                                                               
    if ( the_thread->current_priority < new_priority ) {              
4000cd18:	c2 02 20 14 	ld  [ %o0 + 0x14 ], %g1                        
4000cd1c:	80 a0 40 09 	cmp  %g1, %o1                                  
4000cd20:	0a 80 00 04 	bcs  4000cd30 <_POSIX_Threads_Sporadic_budget_callout+0x44><== ALWAYS TAKEN
4000cd24:	94 10 20 01 	mov  1, %o2                                    
4000cd28:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
4000cd2c:	01 00 00 00 	nop                                            <== NOT EXECUTED
      _Thread_Change_priority( the_thread, new_priority, true );      
4000cd30:	82 13 c0 00 	mov  %o7, %g1                                  
4000cd34:	7f ff f3 2b 	call  400099e0 <_Thread_Change_priority>       
4000cd38:	9e 10 40 00 	mov  %g1, %o7                                  
                                                                      

4000eea4 <_POSIX_Threads_cancel_run>: #include <rtems/posix/threadsup.h> void _POSIX_Threads_cancel_run( Thread_Control *the_thread ) {
4000eea4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  POSIX_Cancel_Handler_control      *handler;                         
  Chain_Control                     *handler_stack;                   
  POSIX_API_Control                 *thread_support;                  
  ISR_Level                          level;                           
                                                                      
  thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];    
4000eea8:	f8 06 21 50 	ld  [ %i0 + 0x150 ], %i4                       
                                                                      
  handler_stack = &thread_support->Cancellation_Handlers;             
                                                                      
  thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;       
4000eeac:	84 10 20 01 	mov  1, %g2                                    
                                                                      
  while ( !_Chain_Is_empty( handler_stack ) ) {                       
4000eeb0:	c2 07 20 e4 	ld  [ %i4 + 0xe4 ], %g1                        
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
4000eeb4:	b6 07 20 e8 	add  %i4, 0xe8, %i3                            
4000eeb8:	80 a0 40 1b 	cmp  %g1, %i3                                  
4000eebc:	02 80 00 14 	be  4000ef0c <_POSIX_Threads_cancel_run+0x68>  
4000eec0:	c4 27 20 d8 	st  %g2, [ %i4 + 0xd8 ]                        
    _ISR_Disable( level );                                            
4000eec4:	7f ff cc 78 	call  400020a4 <sparc_disable_interrupts>      
4000eec8:	01 00 00 00 	nop                                            
      handler = (POSIX_Cancel_Handler_control *)                      
4000eecc:	fa 07 20 ec 	ld  [ %i4 + 0xec ], %i5                        
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
4000eed0:	c4 07 40 00 	ld  [ %i5 ], %g2                               
  previous       = the_node->previous;                                
4000eed4:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
  next->previous = previous;                                          
4000eed8:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]                           
  previous->next = next;                                              
4000eedc:	c4 20 40 00 	st  %g2, [ %g1 ]                               
           _Chain_Tail( handler_stack )->previous;                    
      _Chain_Extract_unprotected( &handler->Node );                   
    _ISR_Enable( level );                                             
4000eee0:	7f ff cc 75 	call  400020b4 <sparc_enable_interrupts>       
4000eee4:	01 00 00 00 	nop                                            
                                                                      
    (*handler->routine)( handler->arg );                              
4000eee8:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
4000eeec:	9f c0 40 00 	call  %g1                                      
4000eef0:	d0 07 60 0c 	ld  [ %i5 + 0xc ], %o0                         
                                                                      
    _Workspace_Free( handler );                                       
4000eef4:	7f ff f0 4e 	call  4000b02c <_Workspace_Free>               
4000eef8:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  handler_stack = &thread_support->Cancellation_Handlers;             
                                                                      
  thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;       
                                                                      
  while ( !_Chain_Is_empty( handler_stack ) ) {                       
4000eefc:	c2 07 20 e4 	ld  [ %i4 + 0xe4 ], %g1                        
4000ef00:	80 a0 40 1b 	cmp  %g1, %i3                                  
4000ef04:	12 bf ff f0 	bne  4000eec4 <_POSIX_Threads_cancel_run+0x20> <== NEVER TAKEN
4000ef08:	01 00 00 00 	nop                                            
4000ef0c:	81 c7 e0 08 	ret                                            
4000ef10:	81 e8 00 00 	restore                                        
                                                                      

4000714c <_POSIX_Timer_TSR>: * This is the operation that is run when a timer expires */ void _POSIX_Timer_TSR( Objects_Id timer __attribute__((unused)), void *data) {
4000714c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  bool                 activated;                                     
                                                                      
  ptimer = (POSIX_Timer_Control *)data;                               
                                                                      
  /* Increment the number of expirations. */                          
  ptimer->overrun = ptimer->overrun + 1;                              
40007150:	c4 06 60 68 	ld  [ %i1 + 0x68 ], %g2                        
                                                                      
  /* The timer must be reprogrammed */                                
  if ( ( ptimer->timer_data.it_interval.tv_sec  != 0 ) ||             
40007154:	c2 06 60 54 	ld  [ %i1 + 0x54 ], %g1                        
  bool                 activated;                                     
                                                                      
  ptimer = (POSIX_Timer_Control *)data;                               
                                                                      
  /* Increment the number of expirations. */                          
  ptimer->overrun = ptimer->overrun + 1;                              
40007158:	84 00 a0 01 	inc  %g2                                       
                                                                      
  /* The timer must be reprogrammed */                                
  if ( ( ptimer->timer_data.it_interval.tv_sec  != 0 ) ||             
4000715c:	80 a0 60 00 	cmp  %g1, 0                                    
40007160:	12 80 00 0e 	bne  40007198 <_POSIX_Timer_TSR+0x4c>          
40007164:	c4 26 60 68 	st  %g2, [ %i1 + 0x68 ]                        
40007168:	c2 06 60 58 	ld  [ %i1 + 0x58 ], %g1                        
4000716c:	80 a0 60 00 	cmp  %g1, 0                                    
40007170:	32 80 00 0b 	bne,a   4000719c <_POSIX_Timer_TSR+0x50>       <== ALWAYS TAKEN
40007174:	d2 06 60 64 	ld  [ %i1 + 0x64 ], %o1                        
                                                                      
    /* The state really did not change but just to be safe */         
    ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;                     
  } else {                                                            
   /* Indicates that the timer is stopped */                          
   ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;                     
40007178:	82 10 20 04 	mov  4, %g1                                    <== NOT EXECUTED
4000717c:	c2 2e 60 3c 	stb  %g1, [ %i1 + 0x3c ]                       <== NOT EXECUTED
  /*                                                                  
   * The sending of the signal to the process running the handling function
   * specified for that signal is simulated                           
   */                                                                 
                                                                      
  if ( pthread_kill ( ptimer->thread_id, ptimer->inf.sigev_signo ) ) {
40007180:	d0 06 60 38 	ld  [ %i1 + 0x38 ], %o0                        
40007184:	40 00 18 1c 	call  4000d1f4 <pthread_kill>                  
40007188:	d2 06 60 44 	ld  [ %i1 + 0x44 ], %o1                        
  }                                                                   
                                                                      
  /* After the signal handler returns, the count of expirations of the
   * timer must be set to 0.                                          
   */                                                                 
  ptimer->overrun = 0;                                                
4000718c:	c0 26 60 68 	clr  [ %i1 + 0x68 ]                            
40007190:	81 c7 e0 08 	ret                                            
40007194:	81 e8 00 00 	restore                                        
  ptimer->overrun = ptimer->overrun + 1;                              
                                                                      
  /* The timer must be reprogrammed */                                
  if ( ( ptimer->timer_data.it_interval.tv_sec  != 0 ) ||             
       ( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {            
    activated = _POSIX_Timer_Insert_helper(                           
40007198:	d2 06 60 64 	ld  [ %i1 + 0x64 ], %o1                        
4000719c:	d4 06 60 08 	ld  [ %i1 + 8 ], %o2                           
400071a0:	90 06 60 10 	add  %i1, 0x10, %o0                            
400071a4:	98 10 00 19 	mov  %i1, %o4                                  
400071a8:	17 10 00 1c 	sethi  %hi(0x40007000), %o3                    
400071ac:	40 00 19 39 	call  4000d690 <_POSIX_Timer_Insert_helper>    
400071b0:	96 12 e1 4c 	or  %o3, 0x14c, %o3	! 4000714c <_POSIX_Timer_TSR>
      ptimer->ticks,                                                  
      ptimer->Object.id,                                              
      _POSIX_Timer_TSR,                                               
      ptimer                                                          
    );                                                                
    if ( !activated )                                                 
400071b4:	80 8a 20 ff 	btst  0xff, %o0                                
400071b8:	02 bf ff f6 	be  40007190 <_POSIX_Timer_TSR+0x44>           <== NEVER TAKEN
400071bc:	90 07 bf f8 	add  %fp, -8, %o0                              
400071c0:	13 10 00 7e 	sethi  %hi(0x4001f800), %o1                    
400071c4:	40 00 06 3b 	call  40008ab0 <_TOD_Get_with_nanoseconds>     
400071c8:	92 12 61 58 	or  %o1, 0x158, %o1	! 4001f958 <_TOD>          
                                                                      
  /* After the signal handler returns, the count of expirations of the
   * timer must be set to 0.                                          
   */                                                                 
  ptimer->overrun = 0;                                                
}                                                                     
400071cc:	f8 1a 00 00 	ldd  [ %o0 ], %i4                              
static inline void _Timestamp64_implementation_To_timespec(           
  const Timestamp64_Control *_timestamp,                              
  struct timespec           *_timespec                                
)                                                                     
{                                                                     
  _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);           
400071d0:	94 10 20 00 	clr  %o2                                       
400071d4:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
400071d8:	90 10 00 1c 	mov  %i4, %o0                                  
400071dc:	96 12 e2 00 	or  %o3, 0x200, %o3                            
400071e0:	40 00 4a 34 	call  40019ab0 <__divdi3>                      
400071e4:	92 10 00 1d 	mov  %i5, %o1                                  
  _timespec->tv_nsec = (long) (*_timestamp % 1000000000L);            
400071e8:	94 10 20 00 	clr  %o2                                       
static inline void _Timestamp64_implementation_To_timespec(           
  const Timestamp64_Control *_timestamp,                              
  struct timespec           *_timespec                                
)                                                                     
{                                                                     
  _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);           
400071ec:	d2 26 60 6c 	st  %o1, [ %i1 + 0x6c ]                        
  _timespec->tv_nsec = (long) (*_timestamp % 1000000000L);            
400071f0:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
400071f4:	90 10 00 1c 	mov  %i4, %o0                                  
400071f8:	96 12 e2 00 	or  %o3, 0x200, %o3                            
400071fc:	40 00 4b 18 	call  40019e5c <__moddi3>                      
40007200:	92 10 00 1d 	mov  %i5, %o1                                  
                                                                      
    /* Store the time when the timer was started again */             
    _TOD_Get( &ptimer->time );                                        
                                                                      
    /* The state really did not change but just to be safe */         
    ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;                     
40007204:	82 10 20 03 	mov  3, %g1                                    
40007208:	d2 26 60 70 	st  %o1, [ %i1 + 0x70 ]                        
4000720c:	10 bf ff dd 	b  40007180 <_POSIX_Timer_TSR+0x34>            
40007210:	c2 2e 60 3c 	stb  %g1, [ %i1 + 0x3c ]                       
                                                                      

4000efd8 <_POSIX_signals_Check_signal>: bool _POSIX_signals_Check_signal( POSIX_API_Control *api, int signo, bool is_global ) {
4000efd8:	9d e3 bf 68 	save  %sp, -152, %sp                           
  siginfo_t                   siginfo_struct;                         
  sigset_t                    saved_signals_blocked;                  
  Thread_Wait_information     stored_thread_wait_information;         
                                                                      
  if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct,   
4000efdc:	98 10 20 01 	mov  1, %o4                                    
4000efe0:	90 10 00 18 	mov  %i0, %o0                                  
4000efe4:	92 10 00 19 	mov  %i1, %o1                                  
4000efe8:	94 07 bf cc 	add  %fp, -52, %o2                             
4000efec:	40 00 00 2e 	call  4000f0a4 <_POSIX_signals_Clear_signals>  
4000eff0:	96 10 00 1a 	mov  %i2, %o3                                  
4000eff4:	80 8a 20 ff 	btst  0xff, %o0                                
4000eff8:	02 80 00 23 	be  4000f084 <_POSIX_signals_Check_signal+0xac>
4000effc:	82 10 20 00 	clr  %g1                                       
  #endif                                                              
                                                                      
  /*                                                                  
   *  Just to prevent sending a signal which is currently being ignored.
   */                                                                 
  if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN )        
4000f000:	85 2e 60 02 	sll  %i1, 2, %g2                               
4000f004:	37 10 00 7d 	sethi  %hi(0x4001f400), %i3                    
4000f008:	b9 2e 60 04 	sll  %i1, 4, %i4                               
4000f00c:	b6 16 e0 30 	or  %i3, 0x30, %i3                             
4000f010:	b8 27 00 02 	sub  %i4, %g2, %i4                             
4000f014:	84 06 c0 1c 	add  %i3, %i4, %g2                             
4000f018:	fa 00 a0 08 	ld  [ %g2 + 8 ], %i5                           
4000f01c:	80 a7 60 01 	cmp  %i5, 1                                    
4000f020:	02 80 00 19 	be  4000f084 <_POSIX_signals_Check_signal+0xac><== NEVER TAKEN
4000f024:	21 10 00 7c 	sethi  %hi(0x4001f000), %l0                    
    return false;                                                     
                                                                      
  /*                                                                  
   *  Block the signals requested in sa_mask                          
   */                                                                 
  saved_signals_blocked = api->signals_blocked;                       
4000f028:	f4 06 20 d0 	ld  [ %i0 + 0xd0 ], %i2                        
  api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;    
4000f02c:	c2 00 a0 04 	ld  [ %g2 + 4 ], %g1                           
  /*                                                                  
   *  We have to save the blocking information of the current wait queue
   *  because the signal handler may subsequently go on and put the thread
   *  on a wait queue, for its own purposes.                          
   */                                                                 
  memcpy( &stored_thread_wait_information, &_Thread_Executing->Wait,  
4000f030:	a0 14 23 d0 	or  %l0, 0x3d0, %l0                            
4000f034:	d2 04 20 10 	ld  [ %l0 + 0x10 ], %o1                        
                                                                      
  /*                                                                  
   *  Block the signals requested in sa_mask                          
   */                                                                 
  saved_signals_blocked = api->signals_blocked;                       
  api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;    
4000f038:	82 10 40 1a 	or  %g1, %i2, %g1                              
  /*                                                                  
   *  We have to save the blocking information of the current wait queue
   *  because the signal handler may subsequently go on and put the thread
   *  on a wait queue, for its own purposes.                          
   */                                                                 
  memcpy( &stored_thread_wait_information, &_Thread_Executing->Wait,  
4000f03c:	90 07 bf d8 	add  %fp, -40, %o0                             
                                                                      
  /*                                                                  
   *  Block the signals requested in sa_mask                          
   */                                                                 
  saved_signals_blocked = api->signals_blocked;                       
  api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;    
4000f040:	c2 26 20 d0 	st  %g1, [ %i0 + 0xd0 ]                        
  /*                                                                  
   *  We have to save the blocking information of the current wait queue
   *  because the signal handler may subsequently go on and put the thread
   *  on a wait queue, for its own purposes.                          
   */                                                                 
  memcpy( &stored_thread_wait_information, &_Thread_Executing->Wait,  
4000f044:	92 02 60 20 	add  %o1, 0x20, %o1                            
4000f048:	40 00 04 0f 	call  40010084 <memcpy>                        
4000f04c:	94 10 20 28 	mov  0x28, %o2                                 
          sizeof( Thread_Wait_information ));                         
                                                                      
  /*                                                                  
   *  Here, the signal handler function executes                      
   */                                                                 
  switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {               
4000f050:	c2 06 c0 1c 	ld  [ %i3 + %i4 ], %g1                         
4000f054:	80 a0 60 02 	cmp  %g1, 2                                    
4000f058:	02 80 00 0e 	be  4000f090 <_POSIX_signals_Check_signal+0xb8>
4000f05c:	90 10 00 19 	mov  %i1, %o0                                  
        &siginfo_struct,                                              
        NULL        /* context is undefined per 1003.1b-1993, p. 66 */
      );                                                              
      break;                                                          
    default:                                                          
      (*_POSIX_signals_Vectors[ signo ].sa_handler)( signo );         
4000f060:	9f c7 40 00 	call  %i5                                      
4000f064:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  /*                                                                  
   *  Restore the blocking information                                
   */                                                                 
  memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,  
4000f068:	d0 04 20 10 	ld  [ %l0 + 0x10 ], %o0                        
4000f06c:	92 07 bf d8 	add  %fp, -40, %o1                             
4000f070:	90 02 20 20 	add  %o0, 0x20, %o0                            
4000f074:	40 00 04 04 	call  40010084 <memcpy>                        
4000f078:	94 10 20 28 	mov  0x28, %o2                                 
  /*                                                                  
   *  Restore the previous set of blocked signals                     
   */                                                                 
  api->signals_blocked = saved_signals_blocked;                       
                                                                      
  return true;                                                        
4000f07c:	82 10 20 01 	mov  1, %g1                                    
          sizeof( Thread_Wait_information ));                         
                                                                      
  /*                                                                  
   *  Restore the previous set of blocked signals                     
   */                                                                 
  api->signals_blocked = saved_signals_blocked;                       
4000f080:	f4 26 20 d0 	st  %i2, [ %i0 + 0xd0 ]                        
                                                                      
  return true;                                                        
}                                                                     
4000f084:	b0 08 60 01 	and  %g1, 1, %i0                               
4000f088:	81 c7 e0 08 	ret                                            
4000f08c:	81 e8 00 00 	restore                                        
  /*                                                                  
   *  Here, the signal handler function executes                      
   */                                                                 
  switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {               
    case SA_SIGINFO:                                                  
      (*_POSIX_signals_Vectors[ signo ].sa_sigaction)(                
4000f090:	92 07 bf cc 	add  %fp, -52, %o1                             
4000f094:	9f c7 40 00 	call  %i5                                      
4000f098:	94 10 20 00 	clr  %o2                                       
        signo,                                                        
        &siginfo_struct,                                              
        NULL        /* context is undefined per 1003.1b-1993, p. 66 */
      );                                                              
      break;                                                          
4000f09c:	10 bf ff f4 	b  4000f06c <_POSIX_signals_Check_signal+0x94> 
4000f0a0:	d0 04 20 10 	ld  [ %l0 + 0x10 ], %o0                        
                                                                      

4000f698 <_POSIX_signals_Clear_process_signals>: */ void _POSIX_signals_Clear_process_signals( int signo ) {
4000f698:	9d e3 bf a0 	save  %sp, -96, %sp                            
4000f69c:	84 10 20 01 	mov  1, %g2                                    
4000f6a0:	82 06 3f ff 	add  %i0, -1, %g1                              
  clear_signal = true;                                                
  mask         = signo_to_mask( signo );                              
                                                                      
  ISR_Level  level;                                                   
                                                                      
  _ISR_Disable( level );                                              
4000f6a4:	7f ff ca 80 	call  400020a4 <sparc_disable_interrupts>      
4000f6a8:	bb 28 80 01 	sll  %g2, %g1, %i5                             
    if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {   
4000f6ac:	05 10 00 7d 	sethi  %hi(0x4001f400), %g2                    
4000f6b0:	83 2e 20 02 	sll  %i0, 2, %g1                               
4000f6b4:	84 10 a0 30 	or  %g2, 0x30, %g2                             
4000f6b8:	b1 2e 20 04 	sll  %i0, 4, %i0                               
4000f6bc:	82 26 00 01 	sub  %i0, %g1, %g1                             
4000f6c0:	c4 00 80 01 	ld  [ %g2 + %g1 ], %g2                         
4000f6c4:	80 a0 a0 02 	cmp  %g2, 2                                    
4000f6c8:	02 80 00 08 	be  4000f6e8 <_POSIX_signals_Clear_process_signals+0x50>
4000f6cc:	31 10 00 7d 	sethi  %hi(0x4001f400), %i0                    
      if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )     
       clear_signal = false;                                          
    }                                                                 
    if ( clear_signal ) {                                             
      _POSIX_signals_Pending &= ~mask;                                
4000f6d0:	03 10 00 7d 	sethi  %hi(0x4001f400), %g1                    
4000f6d4:	c4 00 62 24 	ld  [ %g1 + 0x224 ], %g2	! 4001f624 <_POSIX_signals_Pending>
4000f6d8:	ba 28 80 1d 	andn  %g2, %i5, %i5                            
4000f6dc:	fa 20 62 24 	st  %i5, [ %g1 + 0x224 ]                       
    }                                                                 
  _ISR_Enable( level );                                               
4000f6e0:	7f ff ca 75 	call  400020b4 <sparc_enable_interrupts>       
4000f6e4:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      
  ISR_Level  level;                                                   
                                                                      
  _ISR_Disable( level );                                              
    if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {   
      if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )     
4000f6e8:	b0 16 22 28 	or  %i0, 0x228, %i0                            
4000f6ec:	c4 00 40 18 	ld  [ %g1 + %i0 ], %g2                         
4000f6f0:	b0 00 40 18 	add  %g1, %i0, %i0                             
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
4000f6f4:	b0 06 20 04 	add  %i0, 4, %i0                               
4000f6f8:	80 a0 80 18 	cmp  %g2, %i0                                  
4000f6fc:	02 bf ff f6 	be  4000f6d4 <_POSIX_signals_Clear_process_signals+0x3c><== ALWAYS TAKEN
4000f700:	03 10 00 7d 	sethi  %hi(0x4001f400), %g1                    
       clear_signal = false;                                          
    }                                                                 
    if ( clear_signal ) {                                             
      _POSIX_signals_Pending &= ~mask;                                
    }                                                                 
  _ISR_Enable( level );                                               
4000f704:	7f ff ca 6c 	call  400020b4 <sparc_enable_interrupts>       <== NOT EXECUTED
4000f708:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
                                                                      

40007cc0 <_POSIX_signals_Get_lowest>: sigset_t set ) { int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
40007cc0:	82 10 20 1b 	mov  0x1b, %g1                                 
40007cc4:	86 10 20 01 	mov  1, %g3                                    
#include <rtems/posix/psignalimpl.h>                                  
#include <rtems/seterr.h>                                             
#include <rtems/posix/time.h>                                         
#include <rtems/score/isr.h>                                          
                                                                      
static int _POSIX_signals_Get_lowest(                                 
40007cc8:	84 00 7f ff 	add  %g1, -1, %g2                              
40007ccc:	85 28 c0 02 	sll  %g3, %g2, %g2                             
)                                                                     
{                                                                     
  int signo;                                                          
                                                                      
  for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {            
    if ( set & signo_to_mask( signo ) ) {                             
40007cd0:	80 88 80 08 	btst  %g2, %o0                                 
40007cd4:	12 80 00 11 	bne  40007d18 <_POSIX_signals_Get_lowest+0x58> <== NEVER TAKEN
40007cd8:	01 00 00 00 	nop                                            
  sigset_t   set                                                      
)                                                                     
{                                                                     
  int signo;                                                          
                                                                      
  for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {            
40007cdc:	82 00 60 01 	inc  %g1                                       
40007ce0:	80 a0 60 20 	cmp  %g1, 0x20                                 
40007ce4:	12 bf ff fa 	bne  40007ccc <_POSIX_signals_Get_lowest+0xc>  
40007ce8:	84 00 7f ff 	add  %g1, -1, %g2                              
40007cec:	82 10 20 01 	mov  1, %g1                                    
40007cf0:	10 80 00 05 	b  40007d04 <_POSIX_signals_Get_lowest+0x44>   
40007cf4:	86 10 20 01 	mov  1, %g3                                    
   */                                                                 
                                                                      
  #if (SIGHUP != 1)                                                   
    #error "Assumption that SIGHUP==1 violated!!"                     
  #endif                                                              
  for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {        
40007cf8:	80 a0 60 1b 	cmp  %g1, 0x1b                                 
40007cfc:	02 80 00 07 	be  40007d18 <_POSIX_signals_Get_lowest+0x58>  <== NEVER TAKEN
40007d00:	01 00 00 00 	nop                                            
#include <rtems/posix/psignalimpl.h>                                  
#include <rtems/seterr.h>                                             
#include <rtems/posix/time.h>                                         
#include <rtems/score/isr.h>                                          
                                                                      
static int _POSIX_signals_Get_lowest(                                 
40007d04:	84 00 7f ff 	add  %g1, -1, %g2                              
40007d08:	85 28 c0 02 	sll  %g3, %g2, %g2                             
                                                                      
  #if (SIGHUP != 1)                                                   
    #error "Assumption that SIGHUP==1 violated!!"                     
  #endif                                                              
  for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {        
    if ( set & signo_to_mask( signo ) ) {                             
40007d0c:	80 88 80 08 	btst  %g2, %o0                                 
40007d10:	22 bf ff fa 	be,a   40007cf8 <_POSIX_signals_Get_lowest+0x38>
40007d14:	82 00 60 01 	inc  %g1                                       
   *  a return 0.  This routine will NOT be called unless a signal    
   *  is pending in the set passed in.                                
   */                                                                 
found_it:                                                             
  return signo;                                                       
}                                                                     
40007d18:	81 c3 e0 08 	retl                                           
40007d1c:	90 10 00 01 	mov  %g1, %o0                                  
                                                                      

4000c81c <_POSIX_signals_Post_switch_hook>: */ static void _POSIX_signals_Post_switch_hook( Thread_Control *the_thread ) {
4000c81c:	9d e3 bf a0 	save  %sp, -96, %sp                            
                                                                      
  /*                                                                  
   *  We need to ensure that if the signal handler executes a call    
   *  which overwrites the unblocking status, we restore it.          
   */                                                                 
  hold_errno = _Thread_Executing->Wait.return_code;                   
4000c820:	35 10 00 7c 	sethi  %hi(0x4001f000), %i2                    
  POSIX_API_Control  *api;                                            
  int                 signo;                                          
  ISR_Level           level;                                          
  int                 hold_errno;                                     
                                                                      
  api = the_thread->API_Extensions[ THREAD_API_POSIX ];               
4000c824:	f8 06 21 50 	ld  [ %i0 + 0x150 ], %i4                       
                                                                      
  /*                                                                  
   *  We need to ensure that if the signal handler executes a call    
   *  which overwrites the unblocking status, we restore it.          
   */                                                                 
  hold_errno = _Thread_Executing->Wait.return_code;                   
4000c828:	b4 16 a3 d0 	or  %i2, 0x3d0, %i2                            
4000c82c:	c2 06 a0 10 	ld  [ %i2 + 0x10 ], %g1                        
                                                                      
  /*                                                                  
   * api may be NULL in case of a thread close in progress            
   */                                                                 
  if ( !api )                                                         
4000c830:	80 a7 20 00 	cmp  %i4, 0                                    
4000c834:	02 80 00 34 	be  4000c904 <_POSIX_signals_Post_switch_hook+0xe8><== NEVER TAKEN
4000c838:	f2 00 60 34 	ld  [ %g1 + 0x34 ], %i1                        
   *                                                                  
   *  The first thing done is to check there are any signals to be    
   *  processed at all.  No point in doing this loop otherwise.       
   */                                                                 
  while (1) {                                                         
    _ISR_Disable( level );                                            
4000c83c:	7f ff d6 1a 	call  400020a4 <sparc_disable_interrupts>      
4000c840:	37 10 00 7d 	sethi  %hi(0x4001f400), %i3                    
4000c844:	b6 16 e2 24 	or  %i3, 0x224, %i3	! 4001f624 <_POSIX_signals_Pending>
      if ( !(~api->signals_blocked &                                  
            (api->signals_pending | _POSIX_signals_Pending)) ) {      
4000c848:	c6 06 c0 00 	ld  [ %i3 ], %g3                               
4000c84c:	c2 07 20 d4 	ld  [ %i4 + 0xd4 ], %g1                        
   *  The first thing done is to check there are any signals to be    
   *  processed at all.  No point in doing this loop otherwise.       
   */                                                                 
  while (1) {                                                         
    _ISR_Disable( level );                                            
      if ( !(~api->signals_blocked &                                  
4000c850:	c4 07 20 d0 	ld  [ %i4 + 0xd0 ], %g2                        
            (api->signals_pending | _POSIX_signals_Pending)) ) {      
4000c854:	82 10 c0 01 	or  %g3, %g1, %g1                              
   *  The first thing done is to check there are any signals to be    
   *  processed at all.  No point in doing this loop otherwise.       
   */                                                                 
  while (1) {                                                         
    _ISR_Disable( level );                                            
      if ( !(~api->signals_blocked &                                  
4000c858:	80 a8 40 02 	andncc  %g1, %g2, %g0                          
4000c85c:	02 80 00 26 	be  4000c8f4 <_POSIX_signals_Post_switch_hook+0xd8>
4000c860:	01 00 00 00 	nop                                            
            (api->signals_pending | _POSIX_signals_Pending)) ) {      
       _ISR_Enable( level );                                          
       break;                                                         
     }                                                                
    _ISR_Enable( level );                                             
4000c864:	7f ff d6 14 	call  400020b4 <sparc_enable_interrupts>       
4000c868:	ba 10 20 1b 	mov  0x1b, %i5	! 1b <PROM_START+0x1b>          
                                                                      
    for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {          
      _POSIX_signals_Check_signal( api, signo, false );               
4000c86c:	92 10 00 1d 	mov  %i5, %o1                                  
4000c870:	94 10 20 00 	clr  %o2                                       
4000c874:	40 00 09 d9 	call  4000efd8 <_POSIX_signals_Check_signal>   
4000c878:	90 10 00 1c 	mov  %i4, %o0                                  
      _POSIX_signals_Check_signal( api, signo, true );                
4000c87c:	92 10 00 1d 	mov  %i5, %o1                                  
4000c880:	90 10 00 1c 	mov  %i4, %o0                                  
4000c884:	40 00 09 d5 	call  4000efd8 <_POSIX_signals_Check_signal>   
4000c888:	94 10 20 01 	mov  1, %o2                                    
       _ISR_Enable( level );                                          
       break;                                                         
     }                                                                
    _ISR_Enable( level );                                             
                                                                      
    for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {          
4000c88c:	ba 07 60 01 	inc  %i5                                       
4000c890:	80 a7 60 20 	cmp  %i5, 0x20                                 
4000c894:	12 bf ff f7 	bne  4000c870 <_POSIX_signals_Post_switch_hook+0x54>
4000c898:	92 10 00 1d 	mov  %i5, %o1                                  
4000c89c:	ba 10 20 01 	mov  1, %i5                                    
      _POSIX_signals_Check_signal( api, signo, true );                
    }                                                                 
    /* Unfortunately - nothing like __SIGFIRSTNOTRT in newlib signal .h */
                                                                      
    for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {      
      _POSIX_signals_Check_signal( api, signo, false );               
4000c8a0:	92 10 00 1d 	mov  %i5, %o1                                  
4000c8a4:	94 10 20 00 	clr  %o2                                       
4000c8a8:	40 00 09 cc 	call  4000efd8 <_POSIX_signals_Check_signal>   
4000c8ac:	90 10 00 1c 	mov  %i4, %o0                                  
      _POSIX_signals_Check_signal( api, signo, true );                
4000c8b0:	92 10 00 1d 	mov  %i5, %o1                                  
4000c8b4:	90 10 00 1c 	mov  %i4, %o0                                  
4000c8b8:	40 00 09 c8 	call  4000efd8 <_POSIX_signals_Check_signal>   
4000c8bc:	94 10 20 01 	mov  1, %o2                                    
      _POSIX_signals_Check_signal( api, signo, false );               
      _POSIX_signals_Check_signal( api, signo, true );                
    }                                                                 
    /* Unfortunately - nothing like __SIGFIRSTNOTRT in newlib signal .h */
                                                                      
    for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {      
4000c8c0:	ba 07 60 01 	inc  %i5                                       
4000c8c4:	80 a7 60 1b 	cmp  %i5, 0x1b                                 
4000c8c8:	12 bf ff f7 	bne  4000c8a4 <_POSIX_signals_Post_switch_hook+0x88>
4000c8cc:	92 10 00 1d 	mov  %i5, %o1                                  
   *                                                                  
   *  The first thing done is to check there are any signals to be    
   *  processed at all.  No point in doing this loop otherwise.       
   */                                                                 
  while (1) {                                                         
    _ISR_Disable( level );                                            
4000c8d0:	7f ff d5 f5 	call  400020a4 <sparc_disable_interrupts>      
4000c8d4:	01 00 00 00 	nop                                            
      if ( !(~api->signals_blocked &                                  
            (api->signals_pending | _POSIX_signals_Pending)) ) {      
4000c8d8:	c6 06 c0 00 	ld  [ %i3 ], %g3                               
4000c8dc:	c2 07 20 d4 	ld  [ %i4 + 0xd4 ], %g1                        
   *  The first thing done is to check there are any signals to be    
   *  processed at all.  No point in doing this loop otherwise.       
   */                                                                 
  while (1) {                                                         
    _ISR_Disable( level );                                            
      if ( !(~api->signals_blocked &                                  
4000c8e0:	c4 07 20 d0 	ld  [ %i4 + 0xd0 ], %g2                        
            (api->signals_pending | _POSIX_signals_Pending)) ) {      
4000c8e4:	82 10 c0 01 	or  %g3, %g1, %g1                              
   *  The first thing done is to check there are any signals to be    
   *  processed at all.  No point in doing this loop otherwise.       
   */                                                                 
  while (1) {                                                         
    _ISR_Disable( level );                                            
      if ( !(~api->signals_blocked &                                  
4000c8e8:	80 a8 40 02 	andncc  %g1, %g2, %g0                          
4000c8ec:	12 bf ff de 	bne  4000c864 <_POSIX_signals_Post_switch_hook+0x48><== NEVER TAKEN
4000c8f0:	01 00 00 00 	nop                                            
            (api->signals_pending | _POSIX_signals_Pending)) ) {      
       _ISR_Enable( level );                                          
4000c8f4:	7f ff d5 f0 	call  400020b4 <sparc_enable_interrupts>       
4000c8f8:	01 00 00 00 	nop                                            
      _POSIX_signals_Check_signal( api, signo, false );               
      _POSIX_signals_Check_signal( api, signo, true );                
    }                                                                 
  }                                                                   
                                                                      
  _Thread_Executing->Wait.return_code = hold_errno;                   
4000c8fc:	c2 06 a0 10 	ld  [ %i2 + 0x10 ], %g1                        
4000c900:	f2 20 60 34 	st  %i1, [ %g1 + 0x34 ]                        
4000c904:	81 c7 e0 08 	ret                                            
4000c908:	81 e8 00 00 	restore                                        
                                                                      

4001bcf8 <_POSIX_signals_Unblock_thread>: bool _POSIX_signals_Unblock_thread( Thread_Control *the_thread, int signo, siginfo_t *info ) {
4001bcf8:	9d e3 bf a0 	save  %sp, -96, %sp                            
                                                                      
  /*                                                                  
   *  Is the thread is specifically waiting for a signal?             
   */                                                                 
                                                                      
  if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
4001bcfc:	c2 06 20 10 	ld  [ %i0 + 0x10 ], %g1                        
4001bd00:	05 04 00 20 	sethi  %hi(0x10008000), %g2                    
4001bd04:	88 10 20 01 	mov  1, %g4                                    
4001bd08:	86 06 7f ff 	add  %i1, -1, %g3                              
4001bd0c:	ba 08 40 02 	and  %g1, %g2, %i5                             
{                                                                     
  POSIX_API_Control  *api;                                            
  sigset_t            mask;                                           
  siginfo_t          *the_info = NULL;                                
                                                                      
  api = the_thread->API_Extensions[ THREAD_API_POSIX ];               
4001bd10:	f8 06 21 50 	ld  [ %i0 + 0x150 ], %i4                       
                                                                      
  /*                                                                  
   *  Is the thread is specifically waiting for a signal?             
   */                                                                 
                                                                      
  if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
4001bd14:	80 a7 40 02 	cmp  %i5, %g2                                  
4001bd18:	02 80 00 2c 	be  4001bdc8 <_POSIX_signals_Unblock_thread+0xd0>
4001bd1c:	87 29 00 03 	sll  %g4, %g3, %g3                             
  }                                                                   
                                                                      
  /*                                                                  
   *  Thread is not waiting due to a sigwait.                         
   */                                                                 
  if ( ~api->signals_blocked & mask ) {                               
4001bd20:	c4 07 20 d0 	ld  [ %i4 + 0xd0 ], %g2                        
4001bd24:	80 a8 c0 02 	andncc  %g3, %g2, %g0                          
4001bd28:	02 80 00 24 	be  4001bdb8 <_POSIX_signals_Unblock_thread+0xc0>
4001bd2c:	05 04 00 00 	sethi  %hi(0x10000000), %g2                    
     *      it is not blocked, THEN                                   
     *        we need to dispatch at the end of this ISR.             
     *    + Any other combination, do nothing.                        
     */                                                               
                                                                      
    if ( _States_Is_interruptible_by_signal( the_thread->current_state ) ) {
4001bd30:	80 88 40 02 	btst  %g1, %g2                                 
4001bd34:	02 80 00 15 	be  4001bd88 <_POSIX_signals_Unblock_thread+0x90>
4001bd38:	80 a0 60 00 	cmp  %g1, 0                                    
      the_thread->Wait.return_code = EINTR;                           
4001bd3c:	84 10 20 04 	mov  4, %g2                                    
4001bd40:	c4 26 20 34 	st  %g2, [ %i0 + 0x34 ]                        
 */                                                                   
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (        
  States_Control the_states                                           
)                                                                     
{                                                                     
   return (the_states & STATES_WAITING_ON_THREAD_QUEUE);              
4001bd44:	05 00 00 ef 	sethi  %hi(0x3bc00), %g2                       
4001bd48:	84 10 a2 e0 	or  %g2, 0x2e0, %g2	! 3bee0 <PROM_START+0x3bee0>
      /*                                                              
       *  In pthread_cond_wait, a thread will be blocking on a thread 
       *  queue, but is also interruptible by a POSIX signal.         
       */                                                             
       if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) )
4001bd4c:	80 88 40 02 	btst  %g1, %g2                                 
4001bd50:	12 80 00 38 	bne  4001be30 <_POSIX_signals_Unblock_thread+0x138>
4001bd54:	80 88 60 08 	btst  8, %g1                                   
         _Thread_queue_Extract_with_proxy( the_thread );              
       else if ( _States_Is_delaying(the_thread->current_state) ) {   
4001bd58:	22 80 00 19 	be,a   4001bdbc <_POSIX_signals_Unblock_thread+0xc4><== NEVER TAKEN
4001bd5c:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
          (void) _Watchdog_Remove( &the_thread->Timer );              
4001bd60:	7f ff bb f5 	call  4000ad34 <_Watchdog_Remove>              
4001bd64:	90 06 20 48 	add  %i0, 0x48, %o0                            
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Unblock (                           
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
  _Thread_Clear_state( the_thread, STATES_BLOCKED );                  
4001bd68:	90 10 00 18 	mov  %i0, %o0                                  
4001bd6c:	13 04 01 ff 	sethi  %hi(0x1007fc00), %o1                    
    } else if ( the_thread->current_state == STATES_READY ) {         
      if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
        _Thread_Dispatch_necessary = true;                            
    }                                                                 
  }                                                                   
  return false;                                                       
4001bd70:	b0 10 20 00 	clr  %i0                                       
4001bd74:	7f ff b7 68 	call  40009b14 <_Thread_Clear_state>           
4001bd78:	92 12 63 f8 	or  %o1, 0x3f8, %o1                            
4001bd7c:	b0 0e 20 01 	and  %i0, 1, %i0                               
4001bd80:	81 c7 e0 08 	ret                                            
4001bd84:	81 e8 00 00 	restore                                        
       else if ( _States_Is_delaying(the_thread->current_state) ) {   
          (void) _Watchdog_Remove( &the_thread->Timer );              
          _Thread_Unblock( the_thread );                              
       }                                                              
                                                                      
    } else if ( the_thread->current_state == STATES_READY ) {         
4001bd88:	32 80 00 0d 	bne,a   4001bdbc <_POSIX_signals_Unblock_thread+0xc4><== NEVER TAKEN
4001bd8c:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
      if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
4001bd90:	03 10 00 7c 	sethi  %hi(0x4001f000), %g1                    
4001bd94:	82 10 63 d0 	or  %g1, 0x3d0, %g1	! 4001f3d0 <_Per_CPU_Information>
4001bd98:	c4 00 60 08 	ld  [ %g1 + 8 ], %g2                           
4001bd9c:	80 a0 a0 00 	cmp  %g2, 0                                    
4001bda0:	22 80 00 07 	be,a   4001bdbc <_POSIX_signals_Unblock_thread+0xc4>
4001bda4:	b0 10 20 00 	clr  %i0                                       
4001bda8:	c4 00 60 10 	ld  [ %g1 + 0x10 ], %g2                        
4001bdac:	80 a6 00 02 	cmp  %i0, %g2                                  
4001bdb0:	22 80 00 02 	be,a   4001bdb8 <_POSIX_signals_Unblock_thread+0xc0><== ALWAYS TAKEN
4001bdb4:	c8 28 60 0c 	stb  %g4, [ %g1 + 0xc ]                        
        _Thread_Dispatch_necessary = true;                            
    }                                                                 
  }                                                                   
  return false;                                                       
4001bdb8:	b0 10 20 00 	clr  %i0                                       
}                                                                     
4001bdbc:	b0 0e 20 01 	and  %i0, 1, %i0                               
4001bdc0:	81 c7 e0 08 	ret                                            
4001bdc4:	81 e8 00 00 	restore                                        
   *  Is the thread is specifically waiting for a signal?             
   */                                                                 
                                                                      
  if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
                                                                      
    if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
4001bdc8:	c2 06 20 30 	ld  [ %i0 + 0x30 ], %g1                        
4001bdcc:	80 88 c0 01 	btst  %g3, %g1                                 
4001bdd0:	22 80 00 13 	be,a   4001be1c <_POSIX_signals_Unblock_thread+0x124>
4001bdd4:	c2 07 20 d0 	ld  [ %i4 + 0xd0 ], %g1                        
      the_thread->Wait.return_code = EINTR;                           
4001bdd8:	82 10 20 04 	mov  4, %g1                                    
4001bddc:	c2 26 20 34 	st  %g1, [ %i0 + 0x34 ]                        
                                                                      
      the_info = (siginfo_t *) the_thread->Wait.return_argument;      
                                                                      
      if ( !info ) {                                                  
4001bde0:	80 a6 a0 00 	cmp  %i2, 0                                    
4001bde4:	02 80 00 19 	be  4001be48 <_POSIX_signals_Unblock_thread+0x150>
4001bde8:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
        the_info->si_signo = signo;                                   
        the_info->si_code = SI_USER;                                  
        the_info->si_value.sival_int = 0;                             
      } else {                                                        
        *the_info = *info;                                            
4001bdec:	c4 06 80 00 	ld  [ %i2 ], %g2                               
4001bdf0:	c4 20 40 00 	st  %g2, [ %g1 ]                               
4001bdf4:	c4 06 a0 04 	ld  [ %i2 + 4 ], %g2                           
4001bdf8:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
4001bdfc:	c4 06 a0 08 	ld  [ %i2 + 8 ], %g2                           
4001be00:	c4 20 60 08 	st  %g2, [ %g1 + 8 ]                           
      }                                                               
                                                                      
      _Thread_queue_Extract_with_proxy( the_thread );                 
4001be04:	90 10 00 18 	mov  %i0, %o0                                  
4001be08:	7f ff ba 19 	call  4000a66c <_Thread_queue_Extract_with_proxy>
4001be0c:	b0 10 20 01 	mov  1, %i0                                    
      if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
        _Thread_Dispatch_necessary = true;                            
    }                                                                 
  }                                                                   
  return false;                                                       
}                                                                     
4001be10:	b0 0e 20 01 	and  %i0, 1, %i0                               
4001be14:	81 c7 e0 08 	ret                                            
4001be18:	81 e8 00 00 	restore                                        
   *  Is the thread is specifically waiting for a signal?             
   */                                                                 
                                                                      
  if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
                                                                      
    if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
4001be1c:	80 a8 c0 01 	andncc  %g3, %g1, %g0                          
4001be20:	32 bf ff ef 	bne,a   4001bddc <_POSIX_signals_Unblock_thread+0xe4>
4001be24:	82 10 20 04 	mov  4, %g1                                    
    } else if ( the_thread->current_state == STATES_READY ) {         
      if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
        _Thread_Dispatch_necessary = true;                            
    }                                                                 
  }                                                                   
  return false;                                                       
4001be28:	10 bf ff e5 	b  4001bdbc <_POSIX_signals_Unblock_thread+0xc4>
4001be2c:	b0 10 20 00 	clr  %i0                                       
      /*                                                              
       *  In pthread_cond_wait, a thread will be blocking on a thread 
       *  queue, but is also interruptible by a POSIX signal.         
       */                                                             
       if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) )
         _Thread_queue_Extract_with_proxy( the_thread );              
4001be30:	90 10 00 18 	mov  %i0, %o0                                  
4001be34:	7f ff ba 0e 	call  4000a66c <_Thread_queue_Extract_with_proxy>
4001be38:	b0 10 20 00 	clr  %i0                                       
4001be3c:	b0 0e 20 01 	and  %i0, 1, %i0                               
4001be40:	81 c7 e0 08 	ret                                            
4001be44:	81 e8 00 00 	restore                                        
                                                                      
      the_info = (siginfo_t *) the_thread->Wait.return_argument;      
                                                                      
      if ( !info ) {                                                  
        the_info->si_signo = signo;                                   
        the_info->si_code = SI_USER;                                  
4001be48:	84 10 20 01 	mov  1, %g2                                    
      the_thread->Wait.return_code = EINTR;                           
                                                                      
      the_info = (siginfo_t *) the_thread->Wait.return_argument;      
                                                                      
      if ( !info ) {                                                  
        the_info->si_signo = signo;                                   
4001be4c:	f2 20 40 00 	st  %i1, [ %g1 ]                               
        the_info->si_code = SI_USER;                                  
4001be50:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
        the_info->si_value.sival_int = 0;                             
4001be54:	10 bf ff ec 	b  4001be04 <_POSIX_signals_Unblock_thread+0x10c>
4001be58:	c0 20 60 08 	clr  [ %g1 + 8 ]                               
                                                                      

40009df4 <_RBTree_Extract_unprotected>: */ void _RBTree_Extract_unprotected( RBTree_Control *the_rbtree, RBTree_Node *the_node ) {
40009df4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  RBTree_Node *leaf, *target;                                         
  RBTree_Color victim_color;                                          
  RBTree_Direction dir;                                               
                                                                      
  if (!the_node) return;                                              
40009df8:	80 a6 60 00 	cmp  %i1, 0                                    
40009dfc:	02 80 00 4c 	be  40009f2c <_RBTree_Extract_unprotected+0x138>
40009e00:	01 00 00 00 	nop                                            
                                                                      
  /* check if min needs to be updated */                              
  if (the_node == the_rbtree->first[RBT_LEFT]) {                      
40009e04:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
40009e08:	80 a0 40 19 	cmp  %g1, %i1                                  
40009e0c:	02 80 00 56 	be  40009f64 <_RBTree_Extract_unprotected+0x170>
40009e10:	90 10 00 19 	mov  %i1, %o0                                  
    the_rbtree->first[RBT_LEFT] = next;                               
  }                                                                   
                                                                      
  /* Check if max needs to be updated. min=max for 1 element trees so 
   * do not use else if here. */                                      
  if (the_node == the_rbtree->first[RBT_RIGHT]) {                     
40009e14:	c2 06 20 0c 	ld  [ %i0 + 0xc ], %g1                         
40009e18:	80 a0 40 19 	cmp  %g1, %i1                                  
40009e1c:	02 80 00 56 	be  40009f74 <_RBTree_Extract_unprotected+0x180>
40009e20:	90 10 00 19 	mov  %i1, %o0                                  
   * either max in node->child[RBT_LEFT] or min in node->child[RBT_RIGHT],
   * and replace the_node with the target node. This maintains the binary
   * search tree property, but may violate the red-black properties.  
   */                                                                 
                                                                      
  if (the_node->child[RBT_LEFT] && the_node->child[RBT_RIGHT]) {      
40009e24:	fa 06 60 04 	ld  [ %i1 + 4 ], %i5                           
40009e28:	80 a7 60 00 	cmp  %i5, 0                                    
40009e2c:	22 80 00 5a 	be,a   40009f94 <_RBTree_Extract_unprotected+0x1a0>
40009e30:	f8 06 60 08 	ld  [ %i1 + 8 ], %i4                           
40009e34:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
40009e38:	80 a0 60 00 	cmp  %g1, 0                                    
40009e3c:	32 80 00 05 	bne,a   40009e50 <_RBTree_Extract_unprotected+0x5c>
40009e40:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
40009e44:	10 80 00 3c 	b  40009f34 <_RBTree_Extract_unprotected+0x140>
40009e48:	b8 10 00 1d 	mov  %i5, %i4                                  
    target = the_node->child[RBT_LEFT]; /* find max in node->child[RBT_LEFT] */
    while (target->child[RBT_RIGHT]) target = target->child[RBT_RIGHT];
40009e4c:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
40009e50:	80 a0 60 00 	cmp  %g1, 0                                    
40009e54:	32 bf ff fe 	bne,a   40009e4c <_RBTree_Extract_unprotected+0x58>
40009e58:	ba 10 00 01 	mov  %g1, %i5                                  
     * target's position (target is the right child of target->parent)
     * when target vacates it. if there is no child, then target->parent
     * should become NULL. This may cause the coloring to be violated.
     * For now we store the color of the node being deleted in victim_color.
     */                                                               
    leaf = target->child[RBT_LEFT];                                   
40009e5c:	f8 07 60 04 	ld  [ %i5 + 4 ], %i4                           
    if(leaf) {                                                        
40009e60:	80 a7 20 00 	cmp  %i4, 0                                    
40009e64:	02 80 00 48 	be  40009f84 <_RBTree_Extract_unprotected+0x190>
40009e68:	01 00 00 00 	nop                                            
      leaf->parent = target->parent;                                  
40009e6c:	c2 07 40 00 	ld  [ %i5 ], %g1                               
40009e70:	c2 27 00 00 	st  %g1, [ %i4 ]                               
    } else {                                                          
      /* fix the tree here if the child is a null leaf. */            
      _RBTree_Extract_validate_unprotected(target);                   
    }                                                                 
    victim_color = target->color;                                     
    dir = target != target->parent->child[0];                         
40009e74:	c4 07 40 00 	ld  [ %i5 ], %g2                               
    target->parent->child[dir] = leaf;                                
                                                                      
    /* now replace the_node with target */                            
    dir = the_node != the_node->parent->child[0];                     
40009e78:	c2 06 40 00 	ld  [ %i1 ], %g1                               
    } else {                                                          
      /* fix the tree here if the child is a null leaf. */            
      _RBTree_Extract_validate_unprotected(target);                   
    }                                                                 
    victim_color = target->color;                                     
    dir = target != target->parent->child[0];                         
40009e7c:	c8 00 a0 04 	ld  [ %g2 + 4 ], %g4                           
      leaf->parent = target->parent;                                  
    } else {                                                          
      /* fix the tree here if the child is a null leaf. */            
      _RBTree_Extract_validate_unprotected(target);                   
    }                                                                 
    victim_color = target->color;                                     
40009e80:	c6 07 60 0c 	ld  [ %i5 + 0xc ], %g3                         
    dir = target != target->parent->child[0];                         
40009e84:	88 1f 40 04 	xor  %i5, %g4, %g4                             
40009e88:	80 a0 00 04 	cmp  %g0, %g4                                  
40009e8c:	88 40 20 00 	addx  %g0, 0, %g4                              
    target->parent->child[dir] = leaf;                                
40009e90:	89 29 20 02 	sll  %g4, 2, %g4                               
40009e94:	84 00 80 04 	add  %g2, %g4, %g2                             
40009e98:	f8 20 a0 04 	st  %i4, [ %g2 + 4 ]                           
                                                                      
    /* now replace the_node with target */                            
    dir = the_node != the_node->parent->child[0];                     
40009e9c:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
40009ea0:	84 18 80 19 	xor  %g2, %i1, %g2                             
40009ea4:	80 a0 00 02 	cmp  %g0, %g2                                  
40009ea8:	84 40 20 00 	addx  %g0, 0, %g2                              
    the_node->parent->child[dir] = target;                            
40009eac:	85 28 a0 02 	sll  %g2, 2, %g2                               
40009eb0:	82 00 40 02 	add  %g1, %g2, %g1                             
40009eb4:	fa 20 60 04 	st  %i5, [ %g1 + 4 ]                           
                                                                      
    /* set target's new children to the original node's children */   
    target->child[RBT_RIGHT] = the_node->child[RBT_RIGHT];            
40009eb8:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
40009ebc:	c2 27 60 08 	st  %g1, [ %i5 + 8 ]                           
    if (the_node->child[RBT_RIGHT])                                   
40009ec0:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
40009ec4:	80 a0 60 00 	cmp  %g1, 0                                    
40009ec8:	32 80 00 02 	bne,a   40009ed0 <_RBTree_Extract_unprotected+0xdc><== ALWAYS TAKEN
40009ecc:	fa 20 40 00 	st  %i5, [ %g1 ]                               
      the_node->child[RBT_RIGHT]->parent = target;                    
    target->child[RBT_LEFT] = the_node->child[RBT_LEFT];              
40009ed0:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
40009ed4:	c2 27 60 04 	st  %g1, [ %i5 + 4 ]                           
    if (the_node->child[RBT_LEFT])                                    
40009ed8:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
40009edc:	80 a0 60 00 	cmp  %g1, 0                                    
40009ee0:	32 80 00 02 	bne,a   40009ee8 <_RBTree_Extract_unprotected+0xf4>
40009ee4:	fa 20 40 00 	st  %i5, [ %g1 ]                               
    /* finally, update the parent node and recolor. target has completely
     * replaced the_node, and target's child has moved up the tree if needed.
     * the_node is no longer part of the tree, although it has valid pointers
     * still.                                                         
     */                                                               
    target->parent = the_node->parent;                                
40009ee8:	c4 06 40 00 	ld  [ %i1 ], %g2                               
    target->color = the_node->color;                                  
40009eec:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
    /* finally, update the parent node and recolor. target has completely
     * replaced the_node, and target's child has moved up the tree if needed.
     * the_node is no longer part of the tree, although it has valid pointers
     * still.                                                         
     */                                                               
    target->parent = the_node->parent;                                
40009ef0:	c4 27 40 00 	st  %g2, [ %i5 ]                               
    target->color = the_node->color;                                  
40009ef4:	c2 27 60 0c 	st  %g1, [ %i5 + 0xc ]                         
  /* fix coloring. leaf has moved up the tree. The color of the deleted
   * node is in victim_color. There are two cases:                    
   *   1. Deleted a red node, its child must be black. Nothing must be done.
   *   2. Deleted a black node, its child must be red. Paint child black.
   */                                                                 
  if (victim_color == RBT_BLACK) { /* eliminate case 1 */             
40009ef8:	80 a0 e0 00 	cmp  %g3, 0                                    
40009efc:	32 80 00 06 	bne,a   40009f14 <_RBTree_Extract_unprotected+0x120>
40009f00:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
    if (leaf) {                                                       
40009f04:	80 a7 20 00 	cmp  %i4, 0                                    
40009f08:	32 80 00 02 	bne,a   40009f10 <_RBTree_Extract_unprotected+0x11c>
40009f0c:	c0 27 20 0c 	clr  [ %i4 + 0xc ]                             
                                                                      
  /* Wipe the_node */                                                 
  _RBTree_Set_off_rbtree(the_node);                                   
                                                                      
  /* set root to black, if it exists */                               
  if (the_rbtree->root) the_rbtree->root->color = RBT_BLACK;          
40009f10:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
 */                                                                   
RTEMS_INLINE_ROUTINE void _RBTree_Set_off_rbtree(                     
    RBTree_Node *node                                                 
    )                                                                 
{                                                                     
  node->parent = node->child[RBT_LEFT] = node->child[RBT_RIGHT] = NULL;
40009f14:	c0 26 60 08 	clr  [ %i1 + 8 ]                               
40009f18:	c0 26 60 04 	clr  [ %i1 + 4 ]                               
40009f1c:	80 a0 60 00 	cmp  %g1, 0                                    
40009f20:	02 80 00 03 	be  40009f2c <_RBTree_Extract_unprotected+0x138>
40009f24:	c0 26 40 00 	clr  [ %i1 ]                                   
40009f28:	c0 20 60 0c 	clr  [ %g1 + 0xc ]                             
40009f2c:	81 c7 e0 08 	ret                                            
40009f30:	81 e8 00 00 	restore                                        
     * For now we store the color of the node being deleted in victim_color.
     */                                                               
    leaf = the_node->child[RBT_LEFT] ?                                
              the_node->child[RBT_LEFT] : the_node->child[RBT_RIGHT]; 
    if( leaf ) {                                                      
      leaf->parent = the_node->parent;                                
40009f34:	c2 06 40 00 	ld  [ %i1 ], %g1                               
40009f38:	c2 27 00 00 	st  %g1, [ %i4 ]                               
      _RBTree_Extract_validate_unprotected(the_node);                 
    }                                                                 
    victim_color = the_node->color;                                   
                                                                      
    /* remove the_node from the tree */                               
    dir = the_node != the_node->parent->child[0];                     
40009f3c:	c2 06 40 00 	ld  [ %i1 ], %g1                               
      leaf->parent = the_node->parent;                                
    } else {                                                          
      /* fix the tree here if the child is a null leaf. */            
      _RBTree_Extract_validate_unprotected(the_node);                 
    }                                                                 
    victim_color = the_node->color;                                   
40009f40:	c6 06 60 0c 	ld  [ %i1 + 0xc ], %g3                         
                                                                      
    /* remove the_node from the tree */                               
    dir = the_node != the_node->parent->child[0];                     
40009f44:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
40009f48:	84 18 80 19 	xor  %g2, %i1, %g2                             
40009f4c:	80 a0 00 02 	cmp  %g0, %g2                                  
40009f50:	84 40 20 00 	addx  %g0, 0, %g2                              
    the_node->parent->child[dir] = leaf;                              
40009f54:	85 28 a0 02 	sll  %g2, 2, %g2                               
40009f58:	82 00 40 02 	add  %g1, %g2, %g1                             
40009f5c:	10 bf ff e7 	b  40009ef8 <_RBTree_Extract_unprotected+0x104>
40009f60:	f8 20 60 04 	st  %i4, [ %g1 + 4 ]                           
 */                                                                   
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Successor_unprotected(      
  const RBTree_Node *node                                             
)                                                                     
{                                                                     
  return _RBTree_Next_unprotected( node, RBT_RIGHT );                 
40009f64:	40 00 00 eb 	call  4000a310 <_RBTree_Next_unprotected>      
40009f68:	92 10 20 01 	mov  1, %o1                                    
                                                                      
  /* check if min needs to be updated */                              
  if (the_node == the_rbtree->first[RBT_LEFT]) {                      
    RBTree_Node *next;                                                
    next = _RBTree_Successor_unprotected(the_node);                   
    the_rbtree->first[RBT_LEFT] = next;                               
40009f6c:	10 bf ff aa 	b  40009e14 <_RBTree_Extract_unprotected+0x20> 
40009f70:	d0 26 20 08 	st  %o0, [ %i0 + 8 ]                           
 */                                                                   
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Predecessor_unprotected(    
  const RBTree_Node *node                                             
)                                                                     
{                                                                     
  return _RBTree_Next_unprotected( node, RBT_LEFT );                  
40009f74:	40 00 00 e7 	call  4000a310 <_RBTree_Next_unprotected>      
40009f78:	92 10 20 00 	clr  %o1                                       
  /* Check if max needs to be updated. min=max for 1 element trees so 
   * do not use else if here. */                                      
  if (the_node == the_rbtree->first[RBT_RIGHT]) {                     
    RBTree_Node *previous;                                            
    previous = _RBTree_Predecessor_unprotected(the_node);             
    the_rbtree->first[RBT_RIGHT] = previous;                          
40009f7c:	10 bf ff aa 	b  40009e24 <_RBTree_Extract_unprotected+0x30> 
40009f80:	d0 26 20 0c 	st  %o0, [ %i0 + 0xc ]                         
    leaf = target->child[RBT_LEFT];                                   
    if(leaf) {                                                        
      leaf->parent = target->parent;                                  
    } else {                                                          
      /* fix the tree here if the child is a null leaf. */            
      _RBTree_Extract_validate_unprotected(target);                   
40009f84:	7f ff fe d3 	call  40009ad0 <_RBTree_Extract_validate_unprotected>
40009f88:	90 10 00 1d 	mov  %i5, %o0                                  
    }                                                                 
    victim_color = target->color;                                     
    dir = target != target->parent->child[0];                         
40009f8c:	10 bf ff bb 	b  40009e78 <_RBTree_Extract_unprotected+0x84> 
40009f90:	c4 07 40 00 	ld  [ %i5 ], %g2                               
     * violated. We will fix it later.                                
     * For now we store the color of the node being deleted in victim_color.
     */                                                               
    leaf = the_node->child[RBT_LEFT] ?                                
              the_node->child[RBT_LEFT] : the_node->child[RBT_RIGHT]; 
    if( leaf ) {                                                      
40009f94:	80 a7 20 00 	cmp  %i4, 0                                    
40009f98:	32 bf ff e8 	bne,a   40009f38 <_RBTree_Extract_unprotected+0x144>
40009f9c:	c2 06 40 00 	ld  [ %i1 ], %g1                               
      leaf->parent = the_node->parent;                                
    } else {                                                          
      /* fix the tree here if the child is a null leaf. */            
      _RBTree_Extract_validate_unprotected(the_node);                 
40009fa0:	7f ff fe cc 	call  40009ad0 <_RBTree_Extract_validate_unprotected>
40009fa4:	90 10 00 19 	mov  %i1, %o0                                  
    }                                                                 
    victim_color = the_node->color;                                   
                                                                      
    /* remove the_node from the tree */                               
    dir = the_node != the_node->parent->child[0];                     
40009fa8:	10 bf ff e6 	b  40009f40 <_RBTree_Extract_unprotected+0x14c>
40009fac:	c2 06 40 00 	ld  [ %i1 ], %g1                               
                                                                      

40009ad0 <_RBTree_Extract_validate_unprotected>: ) { RBTree_Node *parent, *sibling; RBTree_Direction dir; parent = the_node->parent;
40009ad0:	c2 02 00 00 	ld  [ %o0 ], %g1                               
  if(!parent->parent) return;                                         
40009ad4:	c4 00 40 00 	ld  [ %g1 ], %g2                               
40009ad8:	80 a0 a0 00 	cmp  %g2, 0                                    
40009adc:	02 80 00 3f 	be  40009bd8 <_RBTree_Extract_validate_unprotected+0x108>
40009ae0:	01 00 00 00 	nop                                            
{                                                                     
  if(!the_node) return NULL;                                          
  if(!(the_node->parent)) return NULL;                                
  if(!(the_node->parent->parent)) return NULL;                        
                                                                      
  if(the_node == the_node->parent->child[RBT_LEFT])                   
40009ae4:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
40009ae8:	80 a2 00 02 	cmp  %o0, %g2                                  
40009aec:	22 80 00 02 	be,a   40009af4 <_RBTree_Extract_validate_unprotected+0x24>
40009af0:	c4 00 60 08 	ld  [ %g1 + 8 ], %g2                           
 */                                                                   
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(                             
    const RBTree_Node *the_node                                       
    )                                                                 
{                                                                     
  return (the_node && the_node->color == RBT_RED);                    
40009af4:	c6 02 20 0c 	ld  [ %o0 + 0xc ], %g3                         
40009af8:	80 a0 e0 01 	cmp  %g3, 1                                    
40009afc:	02 80 00 32 	be  40009bc4 <_RBTree_Extract_validate_unprotected+0xf4>
40009b00:	9a 10 20 01 	mov  1, %o5                                    
                                                                      
  sibling = _RBTree_Sibling(the_node);                                
                                                                      
  /* continue to correct tree as long as the_node is black and not the root */
  while (!_RBTree_Is_red(the_node) && parent->parent) {               
40009b04:	c6 00 40 00 	ld  [ %g1 ], %g3                               
40009b08:	80 a0 e0 00 	cmp  %g3, 0                                    
40009b0c:	02 80 00 2e 	be  40009bc4 <_RBTree_Extract_validate_unprotected+0xf4>
40009b10:	80 a0 a0 00 	cmp  %g2, 0                                    
40009b14:	22 80 00 07 	be,a   40009b30 <_RBTree_Extract_validate_unprotected+0x60><== NEVER TAKEN
40009b18:	c6 00 a0 08 	ld  [ %g2 + 8 ], %g3                           <== NOT EXECUTED
40009b1c:	c8 00 a0 0c 	ld  [ %g2 + 0xc ], %g4                         
40009b20:	80 a1 20 01 	cmp  %g4, 1                                    
40009b24:	22 80 00 63 	be,a   40009cb0 <_RBTree_Extract_validate_unprotected+0x1e0>
40009b28:	d8 00 60 04 	ld  [ %g1 + 4 ], %o4                           
      _RBTree_Rotate(parent, dir);                                    
      sibling = parent->child[_RBTree_Opposite_direction(dir)];       
    }                                                                 
                                                                      
    /* sibling is black, see if both of its children are also black. */
    if (!_RBTree_Is_red(sibling->child[RBT_RIGHT]) &&                 
40009b2c:	c6 00 a0 08 	ld  [ %g2 + 8 ], %g3                           
40009b30:	80 a0 e0 00 	cmp  %g3, 0                                    
40009b34:	22 80 00 07 	be,a   40009b50 <_RBTree_Extract_validate_unprotected+0x80>
40009b38:	c6 00 a0 04 	ld  [ %g2 + 4 ], %g3                           
40009b3c:	c6 00 e0 0c 	ld  [ %g3 + 0xc ], %g3                         
40009b40:	80 a0 e0 01 	cmp  %g3, 1                                    
40009b44:	22 80 00 29 	be,a   40009be8 <_RBTree_Extract_validate_unprotected+0x118>
40009b48:	c6 00 60 04 	ld  [ %g1 + 4 ], %g3                           
        !_RBTree_Is_red(sibling->child[RBT_LEFT])) {                  
40009b4c:	c6 00 a0 04 	ld  [ %g2 + 4 ], %g3                           
40009b50:	80 a0 e0 00 	cmp  %g3, 0                                    
40009b54:	22 80 00 07 	be,a   40009b70 <_RBTree_Extract_validate_unprotected+0xa0>
40009b58:	da 20 a0 0c 	st  %o5, [ %g2 + 0xc ]                         
40009b5c:	c6 00 e0 0c 	ld  [ %g3 + 0xc ], %g3                         
40009b60:	80 a0 e0 01 	cmp  %g3, 1                                    
40009b64:	22 80 00 21 	be,a   40009be8 <_RBTree_Extract_validate_unprotected+0x118>
40009b68:	c6 00 60 04 	ld  [ %g1 + 4 ], %g3                           
        sibling->color = RBT_RED;                                     
40009b6c:	da 20 a0 0c 	st  %o5, [ %g2 + 0xc ]                         
40009b70:	c4 00 60 0c 	ld  [ %g1 + 0xc ], %g2                         
40009b74:	80 a0 a0 01 	cmp  %g2, 1                                    
40009b78:	22 80 00 99 	be,a   40009ddc <_RBTree_Extract_validate_unprotected+0x30c>
40009b7c:	c0 20 60 0c 	clr  [ %g1 + 0xc ]                             
        if (_RBTree_Is_red(parent)) {                                 
          parent->color = RBT_BLACK;                                  
          break;                                                      
        }                                                             
        the_node = parent; /* done if parent is red */                
        parent = the_node->parent;                                    
40009b80:	c6 00 40 00 	ld  [ %g1 ], %g3                               
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(                    
  const RBTree_Node *the_node                                         
)                                                                     
{                                                                     
  if(!the_node) return NULL;                                          
  if(!(the_node->parent)) return NULL;                                
40009b84:	80 a0 e0 00 	cmp  %g3, 0                                    
40009b88:	02 80 00 6c 	be  40009d38 <_RBTree_Extract_validate_unprotected+0x268><== NEVER TAKEN
40009b8c:	90 10 00 01 	mov  %g1, %o0                                  
  if(!(the_node->parent->parent)) return NULL;                        
40009b90:	c4 00 c0 00 	ld  [ %g3 ], %g2                               
40009b94:	80 a0 a0 00 	cmp  %g2, 0                                    
40009b98:	02 80 00 69 	be  40009d3c <_RBTree_Extract_validate_unprotected+0x26c>
40009b9c:	84 10 20 00 	clr  %g2                                       
                                                                      
  if(the_node == the_node->parent->child[RBT_LEFT])                   
40009ba0:	c4 00 e0 04 	ld  [ %g3 + 4 ], %g2                           
40009ba4:	80 a0 40 02 	cmp  %g1, %g2                                  
40009ba8:	22 80 00 0e 	be,a   40009be0 <_RBTree_Extract_validate_unprotected+0x110>
40009bac:	c4 00 e0 08 	ld  [ %g3 + 8 ], %g2                           
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(                    
  const RBTree_Node *the_node                                         
)                                                                     
{                                                                     
  if(!the_node) return NULL;                                          
  if(!(the_node->parent)) return NULL;                                
40009bb0:	82 10 00 03 	mov  %g3, %g1                                  
 */                                                                   
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(                             
    const RBTree_Node *the_node                                       
    )                                                                 
{                                                                     
  return (the_node && the_node->color == RBT_RED);                    
40009bb4:	c6 02 20 0c 	ld  [ %o0 + 0xc ], %g3                         
40009bb8:	80 a0 e0 01 	cmp  %g3, 1                                    
40009bbc:	32 bf ff d3 	bne,a   40009b08 <_RBTree_Extract_validate_unprotected+0x38><== ALWAYS TAKEN
40009bc0:	c6 00 40 00 	ld  [ %g1 ], %g3                               
      sibling->child[_RBTree_Opposite_direction(dir)]->color = RBT_BLACK;
      _RBTree_Rotate(parent, dir);                                    
      break; /* done */                                               
    }                                                                 
  } /* while */                                                       
  if(!the_node->parent->parent) the_node->color = RBT_BLACK;          
40009bc4:	c2 02 00 00 	ld  [ %o0 ], %g1                               
40009bc8:	c2 00 40 00 	ld  [ %g1 ], %g1                               
40009bcc:	80 a0 60 00 	cmp  %g1, 0                                    
40009bd0:	02 80 00 5f 	be  40009d4c <_RBTree_Extract_validate_unprotected+0x27c>
40009bd4:	01 00 00 00 	nop                                            
40009bd8:	81 c3 e0 08 	retl                                           
40009bdc:	01 00 00 00 	nop                                            
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(                    
  const RBTree_Node *the_node                                         
)                                                                     
{                                                                     
  if(!the_node) return NULL;                                          
  if(!(the_node->parent)) return NULL;                                
40009be0:	10 bf ff f5 	b  40009bb4 <_RBTree_Extract_validate_unprotected+0xe4>
40009be4:	82 10 00 03 	mov  %g3, %g1                                  
       * cases, either the_node is to the left or the right of the parent.
       * In both cases, first check if one of sibling's children is black,
       * and if so rotate in the proper direction and update sibling pointer.
       * Then switch the sibling and parent colors, and rotate through parent.
       */                                                             
      dir = the_node != parent->child[0];                             
40009be8:	86 1a 00 03 	xor  %o0, %g3, %g3                             
40009bec:	80 a0 00 03 	cmp  %g0, %g3                                  
40009bf0:	9a 40 20 00 	addx  %g0, 0, %o5                              
 */                                                                   
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(     
  RBTree_Direction the_dir                                            
)                                                                     
{                                                                     
  return (RBTree_Direction) !((int) the_dir);                         
40009bf4:	86 1b 60 01 	xor  %o5, 1, %g3                               
      if (!_RBTree_Is_red(sibling->child[_RBTree_Opposite_direction(dir)])) {
40009bf8:	87 28 e0 02 	sll  %g3, 2, %g3                               
40009bfc:	88 00 80 03 	add  %g2, %g3, %g4                             
40009c00:	c8 01 20 04 	ld  [ %g4 + 4 ], %g4                           
 */                                                                   
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(                             
    const RBTree_Node *the_node                                       
    )                                                                 
{                                                                     
  return (the_node && the_node->color == RBT_RED);                    
40009c04:	80 a1 20 00 	cmp  %g4, 0                                    
40009c08:	22 80 00 07 	be,a   40009c24 <_RBTree_Extract_validate_unprotected+0x154>
40009c0c:	9b 2b 60 02 	sll  %o5, 2, %o5                               
40009c10:	d8 01 20 0c 	ld  [ %g4 + 0xc ], %o4                         
40009c14:	80 a3 20 01 	cmp  %o4, 1                                    
40009c18:	22 80 00 4f 	be,a   40009d54 <_RBTree_Extract_validate_unprotected+0x284>
40009c1c:	d6 00 60 0c 	ld  [ %g1 + 0xc ], %o3                         
        sibling->color = RBT_RED;                                     
        sibling->child[dir]->color = RBT_BLACK;                       
40009c20:	9b 2b 60 02 	sll  %o5, 2, %o5                               
40009c24:	98 00 80 0d 	add  %g2, %o5, %o4                             
40009c28:	c8 03 20 04 	ld  [ %o4 + 4 ], %g4                           
       * and if so rotate in the proper direction and update sibling pointer.
       * Then switch the sibling and parent colors, and rotate through parent.
       */                                                             
      dir = the_node != parent->child[0];                             
      if (!_RBTree_Is_red(sibling->child[_RBTree_Opposite_direction(dir)])) {
        sibling->color = RBT_RED;                                     
40009c2c:	96 10 20 01 	mov  1, %o3                                    
40009c30:	d6 20 a0 0c 	st  %o3, [ %g2 + 0xc ]                         
    RBTree_Direction dir                                              
    )                                                                 
{                                                                     
  RBTree_Node *c;                                                     
  if (the_node == NULL) return;                                       
  if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
40009c34:	80 a1 20 00 	cmp  %g4, 0                                    
40009c38:	02 80 00 15 	be  40009c8c <_RBTree_Extract_validate_unprotected+0x1bc><== NEVER TAKEN
40009c3c:	c0 21 20 0c 	clr  [ %g4 + 0xc ]                             
                                                                      
  c = the_node->child[_RBTree_Opposite_direction(dir)];               
  the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];   
40009c40:	96 01 00 03 	add  %g4, %g3, %o3                             
40009c44:	d4 02 e0 04 	ld  [ %o3 + 4 ], %o2                           
40009c48:	d4 23 20 04 	st  %o2, [ %o4 + 4 ]                           
                                                                      
  if (c->child[dir])                                                  
40009c4c:	d8 02 e0 04 	ld  [ %o3 + 4 ], %o4                           
40009c50:	80 a3 20 00 	cmp  %o4, 0                                    
40009c54:	32 80 00 02 	bne,a   40009c5c <_RBTree_Extract_validate_unprotected+0x18c>
40009c58:	c4 23 00 00 	st  %g2, [ %o4 ]                               
    c->child[dir]->parent = the_node;                                 
                                                                      
  c->child[dir] = the_node;                                           
                                                                      
  the_node->parent->child[the_node != the_node->parent->child[0]] = c;
40009c5c:	d8 00 80 00 	ld  [ %g2 ], %o4                               
  the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];   
                                                                      
  if (c->child[dir])                                                  
    c->child[dir]->parent = the_node;                                 
                                                                      
  c->child[dir] = the_node;                                           
40009c60:	96 01 00 03 	add  %g4, %g3, %o3                             
40009c64:	c4 22 e0 04 	st  %g2, [ %o3 + 4 ]                           
                                                                      
  the_node->parent->child[the_node != the_node->parent->child[0]] = c;
40009c68:	d6 03 20 04 	ld  [ %o4 + 4 ], %o3                           
                                                                      
  c->parent = the_node->parent;                                       
40009c6c:	d8 21 00 00 	st  %o4, [ %g4 ]                               
  if (c->child[dir])                                                  
    c->child[dir]->parent = the_node;                                 
                                                                      
  c->child[dir] = the_node;                                           
                                                                      
  the_node->parent->child[the_node != the_node->parent->child[0]] = c;
40009c70:	96 18 80 0b 	xor  %g2, %o3, %o3                             
                                                                      
  c->parent = the_node->parent;                                       
  the_node->parent = c;                                               
40009c74:	c8 20 80 00 	st  %g4, [ %g2 ]                               
  if (c->child[dir])                                                  
    c->child[dir]->parent = the_node;                                 
                                                                      
  c->child[dir] = the_node;                                           
                                                                      
  the_node->parent->child[the_node != the_node->parent->child[0]] = c;
40009c78:	80 a0 00 0b 	cmp  %g0, %o3                                  
40009c7c:	84 40 20 00 	addx  %g0, 0, %g2                              
40009c80:	85 28 a0 02 	sll  %g2, 2, %g2                               
40009c84:	98 03 00 02 	add  %o4, %g2, %o4                             
40009c88:	c8 23 20 04 	st  %g4, [ %o4 + 4 ]                           
        sibling->child[dir]->color = RBT_BLACK;                       
        _RBTree_Rotate(sibling, _RBTree_Opposite_direction(dir));     
        sibling = parent->child[_RBTree_Opposite_direction(dir)];     
      }                                                               
      sibling->color = parent->color;                                 
40009c8c:	c8 00 60 0c 	ld  [ %g1 + 0xc ], %g4                         
      dir = the_node != parent->child[0];                             
      if (!_RBTree_Is_red(sibling->child[_RBTree_Opposite_direction(dir)])) {
        sibling->color = RBT_RED;                                     
        sibling->child[dir]->color = RBT_BLACK;                       
        _RBTree_Rotate(sibling, _RBTree_Opposite_direction(dir));     
        sibling = parent->child[_RBTree_Opposite_direction(dir)];     
40009c90:	84 00 40 03 	add  %g1, %g3, %g2                             
40009c94:	c4 00 a0 04 	ld  [ %g2 + 4 ], %g2                           
      }                                                               
      sibling->color = parent->color;                                 
40009c98:	c8 20 a0 0c 	st  %g4, [ %g2 + 0xc ]                         
40009c9c:	88 00 80 03 	add  %g2, %g3, %g4                             
40009ca0:	c8 01 20 04 	ld  [ %g4 + 4 ], %g4                           
      parent->color = RBT_BLACK;                                      
40009ca4:	c0 20 60 0c 	clr  [ %g1 + 0xc ]                             
      sibling->child[_RBTree_Opposite_direction(dir)]->color = RBT_BLACK;
40009ca8:	10 80 00 33 	b  40009d74 <_RBTree_Extract_validate_unprotected+0x2a4>
40009cac:	c0 21 20 0c 	clr  [ %g4 + 0xc ]                             
     * then rotate parent left, making the sibling be the_node's grandparent.
     * Now the_node has a black sibling and red parent. After rotation,
     * update sibling pointer.                                        
     */                                                               
    if (_RBTree_Is_red(sibling)) {                                    
      parent->color = RBT_RED;                                        
40009cb0:	c8 20 60 0c 	st  %g4, [ %g1 + 0xc ]                         
      sibling->color = RBT_BLACK;                                     
      dir = the_node != parent->child[0];                             
40009cb4:	88 1b 00 08 	xor  %o4, %o0, %g4                             
40009cb8:	80 a0 00 04 	cmp  %g0, %g4                                  
40009cbc:	94 40 20 00 	addx  %g0, 0, %o2                              
 */                                                                   
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(     
  RBTree_Direction the_dir                                            
)                                                                     
{                                                                     
  return (RBTree_Direction) !((int) the_dir);                         
40009cc0:	96 1a a0 01 	xor  %o2, 1, %o3                               
    RBTree_Direction dir                                              
    )                                                                 
{                                                                     
  RBTree_Node *c;                                                     
  if (the_node == NULL) return;                                       
  if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
40009cc4:	97 2a e0 02 	sll  %o3, 2, %o3                               
40009cc8:	98 00 40 0b 	add  %g1, %o3, %o4                             
40009ccc:	c8 03 20 04 	ld  [ %o4 + 4 ], %g4                           
40009cd0:	80 a1 20 00 	cmp  %g4, 0                                    
40009cd4:	02 80 00 1c 	be  40009d44 <_RBTree_Extract_validate_unprotected+0x274><== NEVER TAKEN
40009cd8:	c0 20 a0 0c 	clr  [ %g2 + 0xc ]                             
                                                                      
  c = the_node->child[_RBTree_Opposite_direction(dir)];               
  the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];   
40009cdc:	95 2a a0 02 	sll  %o2, 2, %o2                               
40009ce0:	84 01 00 0a 	add  %g4, %o2, %g2                             
40009ce4:	d2 00 a0 04 	ld  [ %g2 + 4 ], %o1                           
40009ce8:	d2 23 20 04 	st  %o1, [ %o4 + 4 ]                           
                                                                      
  if (c->child[dir])                                                  
40009cec:	c4 00 a0 04 	ld  [ %g2 + 4 ], %g2                           
40009cf0:	80 a0 a0 00 	cmp  %g2, 0                                    
40009cf4:	02 80 00 04 	be  40009d04 <_RBTree_Extract_validate_unprotected+0x234><== NEVER TAKEN
40009cf8:	94 01 00 0a 	add  %g4, %o2, %o2                             
    c->child[dir]->parent = the_node;                                 
40009cfc:	c2 20 80 00 	st  %g1, [ %g2 ]                               
40009d00:	c6 00 40 00 	ld  [ %g1 ], %g3                               
                                                                      
  c->child[dir] = the_node;                                           
40009d04:	c2 22 a0 04 	st  %g1, [ %o2 + 4 ]                           
                                                                      
  the_node->parent->child[the_node != the_node->parent->child[0]] = c;
40009d08:	c4 00 e0 04 	ld  [ %g3 + 4 ], %g2                           
                                                                      
  c->parent = the_node->parent;                                       
40009d0c:	c6 21 00 00 	st  %g3, [ %g4 ]                               
  if (c->child[dir])                                                  
    c->child[dir]->parent = the_node;                                 
                                                                      
  c->child[dir] = the_node;                                           
                                                                      
  the_node->parent->child[the_node != the_node->parent->child[0]] = c;
40009d10:	84 18 40 02 	xor  %g1, %g2, %g2                             
40009d14:	80 a0 00 02 	cmp  %g0, %g2                                  
40009d18:	84 40 20 00 	addx  %g0, 0, %g2                              
40009d1c:	85 28 a0 02 	sll  %g2, 2, %g2                               
40009d20:	96 00 40 0b 	add  %g1, %o3, %o3                             
40009d24:	86 00 c0 02 	add  %g3, %g2, %g3                             
                                                                      
  c->parent = the_node->parent;                                       
  the_node->parent = c;                                               
40009d28:	c8 20 40 00 	st  %g4, [ %g1 ]                               
  if (c->child[dir])                                                  
    c->child[dir]->parent = the_node;                                 
                                                                      
  c->child[dir] = the_node;                                           
                                                                      
  the_node->parent->child[the_node != the_node->parent->child[0]] = c;
40009d2c:	c8 20 e0 04 	st  %g4, [ %g3 + 4 ]                           
40009d30:	10 bf ff 7f 	b  40009b2c <_RBTree_Extract_validate_unprotected+0x5c>
40009d34:	c4 02 e0 04 	ld  [ %o3 + 4 ], %g2                           
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(                    
  const RBTree_Node *the_node                                         
)                                                                     
{                                                                     
  if(!the_node) return NULL;                                          
  if(!(the_node->parent)) return NULL;                                
40009d38:	84 10 20 00 	clr  %g2                                       <== NOT EXECUTED
40009d3c:	10 bf ff 9e 	b  40009bb4 <_RBTree_Extract_validate_unprotected+0xe4>
40009d40:	82 10 00 03 	mov  %g3, %g1                                  
    RBTree_Direction dir                                              
    )                                                                 
{                                                                     
  RBTree_Node *c;                                                     
  if (the_node == NULL) return;                                       
  if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
40009d44:	10 bf ff 7a 	b  40009b2c <_RBTree_Extract_validate_unprotected+0x5c><== NOT EXECUTED
40009d48:	84 10 20 00 	clr  %g2                                       <== NOT EXECUTED
      sibling->child[_RBTree_Opposite_direction(dir)]->color = RBT_BLACK;
      _RBTree_Rotate(parent, dir);                                    
      break; /* done */                                               
    }                                                                 
  } /* while */                                                       
  if(!the_node->parent->parent) the_node->color = RBT_BLACK;          
40009d4c:	81 c3 e0 08 	retl                                           
40009d50:	c0 22 20 0c 	clr  [ %o0 + 0xc ]                             
40009d54:	98 00 40 03 	add  %g1, %g3, %o4                             
        sibling->color = RBT_RED;                                     
        sibling->child[dir]->color = RBT_BLACK;                       
        _RBTree_Rotate(sibling, _RBTree_Opposite_direction(dir));     
        sibling = parent->child[_RBTree_Opposite_direction(dir)];     
      }                                                               
      sibling->color = parent->color;                                 
40009d58:	d6 20 a0 0c 	st  %o3, [ %g2 + 0xc ]                         
      parent->color = RBT_BLACK;                                      
40009d5c:	c0 20 60 0c 	clr  [ %g1 + 0xc ]                             
40009d60:	c4 03 20 04 	ld  [ %o4 + 4 ], %g2                           
40009d64:	80 a0 a0 00 	cmp  %g2, 0                                    
40009d68:	02 bf ff 97 	be  40009bc4 <_RBTree_Extract_validate_unprotected+0xf4><== NEVER TAKEN
40009d6c:	c0 21 20 0c 	clr  [ %g4 + 0xc ]                             
40009d70:	9b 2b 60 02 	sll  %o5, 2, %o5                               
                                                                      
  c = the_node->child[_RBTree_Opposite_direction(dir)];               
  the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];   
40009d74:	88 00 80 0d 	add  %g2, %o5, %g4                             
40009d78:	d8 01 20 04 	ld  [ %g4 + 4 ], %o4                           
40009d7c:	86 00 40 03 	add  %g1, %g3, %g3                             
40009d80:	d8 20 e0 04 	st  %o4, [ %g3 + 4 ]                           
                                                                      
  if (c->child[dir])                                                  
40009d84:	c6 01 20 04 	ld  [ %g4 + 4 ], %g3                           
40009d88:	80 a0 e0 00 	cmp  %g3, 0                                    
40009d8c:	32 80 00 02 	bne,a   40009d94 <_RBTree_Extract_validate_unprotected+0x2c4>
40009d90:	c2 20 c0 00 	st  %g1, [ %g3 ]                               
    c->child[dir]->parent = the_node;                                 
                                                                      
  c->child[dir] = the_node;                                           
                                                                      
  the_node->parent->child[the_node != the_node->parent->child[0]] = c;
40009d94:	c6 00 40 00 	ld  [ %g1 ], %g3                               
  the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];   
                                                                      
  if (c->child[dir])                                                  
    c->child[dir]->parent = the_node;                                 
                                                                      
  c->child[dir] = the_node;                                           
40009d98:	9a 00 80 0d 	add  %g2, %o5, %o5                             
40009d9c:	c2 23 60 04 	st  %g1, [ %o5 + 4 ]                           
                                                                      
  the_node->parent->child[the_node != the_node->parent->child[0]] = c;
40009da0:	c8 00 e0 04 	ld  [ %g3 + 4 ], %g4                           
                                                                      
  c->parent = the_node->parent;                                       
40009da4:	c6 20 80 00 	st  %g3, [ %g2 ]                               
  the_node->parent = c;                                               
40009da8:	c4 20 40 00 	st  %g2, [ %g1 ]                               
  if (c->child[dir])                                                  
    c->child[dir]->parent = the_node;                                 
                                                                      
  c->child[dir] = the_node;                                           
                                                                      
  the_node->parent->child[the_node != the_node->parent->child[0]] = c;
40009dac:	88 18 40 04 	xor  %g1, %g4, %g4                             
40009db0:	80 a0 00 04 	cmp  %g0, %g4                                  
40009db4:	82 40 20 00 	addx  %g0, 0, %g1                              
40009db8:	83 28 60 02 	sll  %g1, 2, %g1                               
40009dbc:	86 00 c0 01 	add  %g3, %g1, %g3                             
      sibling->child[_RBTree_Opposite_direction(dir)]->color = RBT_BLACK;
      _RBTree_Rotate(parent, dir);                                    
      break; /* done */                                               
    }                                                                 
  } /* while */                                                       
  if(!the_node->parent->parent) the_node->color = RBT_BLACK;          
40009dc0:	c2 02 00 00 	ld  [ %o0 ], %g1                               
40009dc4:	c4 20 e0 04 	st  %g2, [ %g3 + 4 ]                           
40009dc8:	c2 00 40 00 	ld  [ %g1 ], %g1                               
40009dcc:	80 a0 60 00 	cmp  %g1, 0                                    
40009dd0:	12 bf ff 82 	bne  40009bd8 <_RBTree_Extract_validate_unprotected+0x108><== ALWAYS TAKEN
40009dd4:	01 00 00 00 	nop                                            
40009dd8:	30 bf ff dd 	b,a   40009d4c <_RBTree_Extract_validate_unprotected+0x27c><== NOT EXECUTED
40009ddc:	c2 02 00 00 	ld  [ %o0 ], %g1                               
40009de0:	c2 00 40 00 	ld  [ %g1 ], %g1                               
40009de4:	80 a0 60 00 	cmp  %g1, 0                                    
40009de8:	12 bf ff 7c 	bne  40009bd8 <_RBTree_Extract_validate_unprotected+0x108><== ALWAYS TAKEN
40009dec:	01 00 00 00 	nop                                            
40009df0:	30 bf ff d7 	b,a   40009d4c <_RBTree_Extract_validate_unprotected+0x27c><== NOT EXECUTED
                                                                      

4000aa6c <_RBTree_Find>: RBTree_Node *_RBTree_Find( RBTree_Control *the_rbtree, RBTree_Node *search_node ) {
4000aa6c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  ISR_Level          level;                                           
  RBTree_Node *return_node;                                           
                                                                      
  return_node = NULL;                                                 
  _ISR_Disable( level );                                              
4000aa70:	7f ff e3 50 	call  400037b0 <sparc_disable_interrupts>      
4000aa74:	b8 10 00 18 	mov  %i0, %i4                                  
4000aa78:	b6 10 00 08 	mov  %o0, %i3                                  
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Find_unprotected(           
    RBTree_Control *the_rbtree,                                       
    RBTree_Node *the_node                                             
    )                                                                 
{                                                                     
  RBTree_Node* iter_node = the_rbtree->root;                          
4000aa7c:	fa 06 20 04 	ld  [ %i0 + 4 ], %i5                           
  RBTree_Node* found = NULL;                                          
  int compare_result;                                                 
  while (iter_node) {                                                 
4000aa80:	80 a7 60 00 	cmp  %i5, 0                                    
4000aa84:	02 80 00 15 	be  4000aad8 <_RBTree_Find+0x6c>               <== NEVER TAKEN
4000aa88:	b0 10 20 00 	clr  %i0                                       
    compare_result = the_rbtree->compare_function(the_node, iter_node);
4000aa8c:	c2 07 20 10 	ld  [ %i4 + 0x10 ], %g1                        
4000aa90:	92 10 00 1d 	mov  %i5, %o1                                  
4000aa94:	9f c0 40 00 	call  %g1                                      
4000aa98:	90 10 00 19 	mov  %i1, %o0                                  
                                                                      
RTEMS_INLINE_ROUTINE bool _RBTree_Is_greater(                         
  int compare_result                                                  
)                                                                     
{                                                                     
  return compare_result > 0;                                          
4000aa9c:	83 3a 20 1f 	sra  %o0, 0x1f, %g1                            
  RBTree_Node* iter_node = the_rbtree->root;                          
  RBTree_Node* found = NULL;                                          
  int compare_result;                                                 
  while (iter_node) {                                                 
    compare_result = the_rbtree->compare_function(the_node, iter_node);
    if ( _RBTree_Is_equal( compare_result ) ) {                       
4000aaa0:	80 a2 20 00 	cmp  %o0, 0                                    
                                                                      
RTEMS_INLINE_ROUTINE bool _RBTree_Is_greater(                         
  int compare_result                                                  
)                                                                     
{                                                                     
  return compare_result > 0;                                          
4000aaa4:	82 20 40 08 	sub  %g1, %o0, %g1                             
4000aaa8:	83 30 60 1f 	srl  %g1, 0x1f, %g1                            
        break;                                                        
    }                                                                 
                                                                      
    RBTree_Direction dir =                                            
      (RBTree_Direction) _RBTree_Is_greater( compare_result );        
    iter_node = iter_node->child[dir];                                
4000aaac:	83 28 60 02 	sll  %g1, 2, %g1                               
  RBTree_Node* iter_node = the_rbtree->root;                          
  RBTree_Node* found = NULL;                                          
  int compare_result;                                                 
  while (iter_node) {                                                 
    compare_result = the_rbtree->compare_function(the_node, iter_node);
    if ( _RBTree_Is_equal( compare_result ) ) {                       
4000aab0:	12 80 00 06 	bne  4000aac8 <_RBTree_Find+0x5c>              
4000aab4:	82 07 40 01 	add  %i5, %g1, %g1                             
      found = iter_node;                                              
      if ( the_rbtree->is_unique )                                    
4000aab8:	c4 0f 20 14 	ldub  [ %i4 + 0x14 ], %g2                      
4000aabc:	80 a0 a0 00 	cmp  %g2, 0                                    
4000aac0:	12 80 00 0a 	bne  4000aae8 <_RBTree_Find+0x7c>              
4000aac4:	b0 10 00 1d 	mov  %i5, %i0                                  
        break;                                                        
    }                                                                 
                                                                      
    RBTree_Direction dir =                                            
      (RBTree_Direction) _RBTree_Is_greater( compare_result );        
    iter_node = iter_node->child[dir];                                
4000aac8:	fa 00 60 04 	ld  [ %g1 + 4 ], %i5                           
    )                                                                 
{                                                                     
  RBTree_Node* iter_node = the_rbtree->root;                          
  RBTree_Node* found = NULL;                                          
  int compare_result;                                                 
  while (iter_node) {                                                 
4000aacc:	80 a7 60 00 	cmp  %i5, 0                                    
4000aad0:	32 bf ff f0 	bne,a   4000aa90 <_RBTree_Find+0x24>           
4000aad4:	c2 07 20 10 	ld  [ %i4 + 0x10 ], %g1                        
      return_node = _RBTree_Find_unprotected( the_rbtree, search_node );
  _ISR_Enable( level );                                               
4000aad8:	7f ff e3 3a 	call  400037c0 <sparc_enable_interrupts>       
4000aadc:	90 10 00 1b 	mov  %i3, %o0                                  
  return return_node;                                                 
}                                                                     
4000aae0:	81 c7 e0 08 	ret                                            
4000aae4:	81 e8 00 00 	restore                                        
  RBTree_Node *return_node;                                           
                                                                      
  return_node = NULL;                                                 
  _ISR_Disable( level );                                              
      return_node = _RBTree_Find_unprotected( the_rbtree, search_node );
  _ISR_Enable( level );                                               
4000aae8:	7f ff e3 36 	call  400037c0 <sparc_enable_interrupts>       
4000aaec:	90 10 00 1b 	mov  %i3, %o0                                  
  return return_node;                                                 
}                                                                     
4000aaf0:	81 c7 e0 08 	ret                                            
4000aaf4:	81 e8 00 00 	restore                                        
                                                                      

4000aed8 <_RBTree_Initialize>: void *starting_address, size_t number_nodes, size_t node_size, bool is_unique ) {
4000aed8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  size_t      count;                                                  
  RBTree_Node *next;                                                  
                                                                      
  /* TODO: Error message? */                                          
  if (!the_rbtree) return;                                            
4000aedc:	80 a6 20 00 	cmp  %i0, 0                                    
4000aee0:	02 80 00 0f 	be  4000af1c <_RBTree_Initialize+0x44>         <== NEVER TAKEN
4000aee4:	80 a6 e0 00 	cmp  %i3, 0                                    
    RBTree_Control          *the_rbtree,                              
    RBTree_Compare_function  compare_function,                        
    bool                     is_unique                                
    )                                                                 
{                                                                     
  the_rbtree->permanent_null   = NULL;                                
4000aee8:	c0 26 00 00 	clr  [ %i0 ]                                   
  the_rbtree->root             = NULL;                                
4000aeec:	c0 26 20 04 	clr  [ %i0 + 4 ]                               
  the_rbtree->first[0]         = NULL;                                
4000aef0:	c0 26 20 08 	clr  [ %i0 + 8 ]                               
  the_rbtree->first[1]         = NULL;                                
4000aef4:	c0 26 20 0c 	clr  [ %i0 + 0xc ]                             
  the_rbtree->compare_function = compare_function;                    
4000aef8:	f2 26 20 10 	st  %i1, [ %i0 + 0x10 ]                        
  /* could do sanity checks here */                                   
  _RBTree_Initialize_empty(the_rbtree, compare_function, is_unique);  
                                                                      
  count = number_nodes;                                               
  next  = starting_address;                                           
  while ( count-- ) {                                                 
4000aefc:	02 80 00 08 	be  4000af1c <_RBTree_Initialize+0x44>         <== NEVER TAKEN
4000af00:	fa 2e 20 14 	stb  %i5, [ %i0 + 0x14 ]                       
    _RBTree_Insert_unprotected(the_rbtree, next);                     
4000af04:	92 10 00 1a 	mov  %i2, %o1                                  
4000af08:	7f ff ff 0b 	call  4000ab34 <_RBTree_Insert_unprotected>    
4000af0c:	90 10 00 18 	mov  %i0, %o0                                  
  /* could do sanity checks here */                                   
  _RBTree_Initialize_empty(the_rbtree, compare_function, is_unique);  
                                                                      
  count = number_nodes;                                               
  next  = starting_address;                                           
  while ( count-- ) {                                                 
4000af10:	b6 86 ff ff 	addcc  %i3, -1, %i3                            
4000af14:	12 bf ff fc 	bne  4000af04 <_RBTree_Initialize+0x2c>        
4000af18:	b4 06 80 1c 	add  %i2, %i4, %i2                             
4000af1c:	81 c7 e0 08 	ret                                            
4000af20:	81 e8 00 00 	restore                                        
                                                                      

40009fd4 <_RBTree_Insert_unprotected>: */ RBTree_Node *_RBTree_Insert_unprotected( RBTree_Control *the_rbtree, RBTree_Node *the_node ) {
40009fd4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if(!the_node) return (RBTree_Node*)-1;                              
40009fd8:	80 a6 60 00 	cmp  %i1, 0                                    
40009fdc:	02 80 00 9c 	be  4000a24c <_RBTree_Insert_unprotected+0x278>
40009fe0:	b8 10 00 18 	mov  %i0, %i4                                  
                                                                      
  RBTree_Node *iter_node = the_rbtree->root;                          
40009fe4:	fa 06 20 04 	ld  [ %i0 + 4 ], %i5                           
  int compare_result;                                                 
                                                                      
  if (!iter_node) { /* special case: first node inserted */           
40009fe8:	80 a7 60 00 	cmp  %i5, 0                                    
40009fec:	32 80 00 05 	bne,a   4000a000 <_RBTree_Insert_unprotected+0x2c>
40009ff0:	c2 07 20 10 	ld  [ %i4 + 0x10 ], %g1                        
    the_node->color = RBT_BLACK;                                      
40009ff4:	10 80 00 9a 	b  4000a25c <_RBTree_Insert_unprotected+0x288> 
40009ff8:	c0 26 60 0c 	clr  [ %i1 + 0xc ]                             
    the_node->parent = (RBTree_Node *) the_rbtree;                    
    the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;    
  } else {                                                            
    /* typical binary search tree insert, descend tree to leaf and insert */
    while (iter_node) {                                               
      compare_result = the_rbtree->compare_function(the_node, iter_node);
40009ffc:	c2 07 20 10 	ld  [ %i4 + 0x10 ], %g1                        
4000a000:	92 10 00 1d 	mov  %i5, %o1                                  
4000a004:	9f c0 40 00 	call  %g1                                      
4000a008:	90 10 00 19 	mov  %i1, %o0                                  
      if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) )
4000a00c:	c4 0f 20 14 	ldub  [ %i4 + 0x14 ], %g2                      
        return iter_node;                                             
      RBTree_Direction dir = !_RBTree_Is_lesser( compare_result );    
4000a010:	b6 38 00 08 	xnor  %g0, %o0, %i3                            
    the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;    
  } else {                                                            
    /* typical binary search tree insert, descend tree to leaf and insert */
    while (iter_node) {                                               
      compare_result = the_rbtree->compare_function(the_node, iter_node);
      if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) )
4000a014:	80 a0 a0 00 	cmp  %g2, 0                                    
        return iter_node;                                             
      RBTree_Direction dir = !_RBTree_Is_lesser( compare_result );    
4000a018:	b7 36 e0 1f 	srl  %i3, 0x1f, %i3                            
      if (!iter_node->child[dir]) {                                   
4000a01c:	83 2e e0 02 	sll  %i3, 2, %g1                               
    the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;    
  } else {                                                            
    /* typical binary search tree insert, descend tree to leaf and insert */
    while (iter_node) {                                               
      compare_result = the_rbtree->compare_function(the_node, iter_node);
      if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) )
4000a020:	02 80 00 05 	be  4000a034 <_RBTree_Insert_unprotected+0x60> 
4000a024:	82 07 40 01 	add  %i5, %g1, %g1                             
4000a028:	80 a2 20 00 	cmp  %o0, 0                                    
4000a02c:	02 80 00 8a 	be  4000a254 <_RBTree_Insert_unprotected+0x280>
4000a030:	01 00 00 00 	nop                                            
        return iter_node;                                             
      RBTree_Direction dir = !_RBTree_Is_lesser( compare_result );    
      if (!iter_node->child[dir]) {                                   
4000a034:	f0 00 60 04 	ld  [ %g1 + 4 ], %i0                           
4000a038:	80 a6 20 00 	cmp  %i0, 0                                    
4000a03c:	32 bf ff f0 	bne,a   40009ffc <_RBTree_Insert_unprotected+0x28>
4000a040:	ba 10 00 18 	mov  %i0, %i5                                  
        the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
        the_node->color = RBT_RED;                                    
        iter_node->child[dir] = the_node;                             
        the_node->parent = iter_node;                                 
        /* update min/max */                                          
        compare_result = the_rbtree->compare_function(                
4000a044:	c4 07 20 10 	ld  [ %i4 + 0x10 ], %g2                        
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_First(                      
  const RBTree_Control *the_rbtree,                                   
  RBTree_Direction dir                                                
)                                                                     
{                                                                     
  return the_rbtree->first[dir];                                      
4000a048:	b4 06 e0 02 	add  %i3, 2, %i2                               
4000a04c:	87 2e a0 02 	sll  %i2, 2, %g3                               
4000a050:	d2 07 00 03 	ld  [ %i4 + %g3 ], %o1                         
      compare_result = the_rbtree->compare_function(the_node, iter_node);
      if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) )
        return iter_node;                                             
      RBTree_Direction dir = !_RBTree_Is_lesser( compare_result );    
      if (!iter_node->child[dir]) {                                   
        the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
4000a054:	c0 26 60 08 	clr  [ %i1 + 8 ]                               
4000a058:	c0 26 60 04 	clr  [ %i1 + 4 ]                               
        the_node->color = RBT_RED;                                    
        iter_node->child[dir] = the_node;                             
4000a05c:	f2 20 60 04 	st  %i1, [ %g1 + 4 ]                           
      if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) )
        return iter_node;                                             
      RBTree_Direction dir = !_RBTree_Is_lesser( compare_result );    
      if (!iter_node->child[dir]) {                                   
        the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
        the_node->color = RBT_RED;                                    
4000a060:	82 10 20 01 	mov  1, %g1                                    
        iter_node->child[dir] = the_node;                             
        the_node->parent = iter_node;                                 
4000a064:	fa 26 40 00 	st  %i5, [ %i1 ]                               
      if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) )
        return iter_node;                                             
      RBTree_Direction dir = !_RBTree_Is_lesser( compare_result );    
      if (!iter_node->child[dir]) {                                   
        the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
        the_node->color = RBT_RED;                                    
4000a068:	c2 26 60 0c 	st  %g1, [ %i1 + 0xc ]                         
        iter_node->child[dir] = the_node;                             
        the_node->parent = iter_node;                                 
        /* update min/max */                                          
        compare_result = the_rbtree->compare_function(                
4000a06c:	9f c0 80 00 	call  %g2                                      
4000a070:	90 10 00 19 	mov  %i1, %o0                                  
            the_node,                                                 
            _RBTree_First(the_rbtree, dir)                            
        );                                                            
        if ( (!dir && _RBTree_Is_lesser(compare_result)) ||           
4000a074:	80 a6 e0 00 	cmp  %i3, 0                                    
4000a078:	12 80 00 10 	bne  4000a0b8 <_RBTree_Insert_unprotected+0xe4>
4000a07c:	80 a2 20 00 	cmp  %o0, 0                                    
4000a080:	06 80 00 10 	bl  4000a0c0 <_RBTree_Insert_unprotected+0xec> 
4000a084:	b5 2e a0 02 	sll  %i2, 2, %i2                               
4000a088:	c2 06 40 00 	ld  [ %i1 ], %g1                               
      if (dir != pdir) {                                              
        _RBTree_Rotate(the_node->parent, pdir);                       
        the_node = the_node->child[pdir];                             
      }                                                               
      the_node->parent->color = RBT_BLACK;                            
      g->color = RBT_RED;                                             
4000a08c:	b4 10 20 01 	mov  1, %i2                                    
 */                                                                   
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Parent(                     
  const RBTree_Node *the_node                                         
)                                                                     
{                                                                     
  if (!the_node->parent->parent) return NULL;                         
4000a090:	c4 00 40 00 	ld  [ %g1 ], %g2                               
4000a094:	86 90 a0 00 	orcc  %g2, 0, %g3                              
4000a098:	22 80 00 06 	be,a   4000a0b0 <_RBTree_Insert_unprotected+0xdc>
4000a09c:	c0 26 60 0c 	clr  [ %i1 + 0xc ]                             
 */                                                                   
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(                             
    const RBTree_Node *the_node                                       
    )                                                                 
{                                                                     
  return (the_node && the_node->color == RBT_RED);                    
4000a0a0:	c8 00 60 0c 	ld  [ %g1 + 0xc ], %g4                         
4000a0a4:	80 a1 20 01 	cmp  %g4, 1                                    
4000a0a8:	22 80 00 08 	be,a   4000a0c8 <_RBTree_Insert_unprotected+0xf4>
4000a0ac:	f6 00 80 00 	ld  [ %g2 ], %i3                               
                                                                      
    /* verify red-black properties */                                 
    _RBTree_Validate_insert_unprotected(the_node);                    
  }                                                                   
  return (RBTree_Node*)0;                                             
}                                                                     
4000a0b0:	81 c7 e0 08 	ret                                            
4000a0b4:	81 e8 00 00 	restore                                        
        compare_result = the_rbtree->compare_function(                
            the_node,                                                 
            _RBTree_First(the_rbtree, dir)                            
        );                                                            
        if ( (!dir && _RBTree_Is_lesser(compare_result)) ||           
              (dir && _RBTree_Is_greater(compare_result)) ) {         
4000a0b8:	04 bf ff f4 	ble  4000a088 <_RBTree_Insert_unprotected+0xb4>
4000a0bc:	b5 2e a0 02 	sll  %i2, 2, %i2                               
          the_rbtree->first[dir] = the_node;                          
4000a0c0:	10 bf ff f2 	b  4000a088 <_RBTree_Insert_unprotected+0xb4>  
4000a0c4:	f2 27 00 1a 	st  %i1, [ %i4 + %i2 ]                         
)                                                                     
{                                                                     
  if(!the_node) return NULL;                                          
  if(!(the_node->parent)) return NULL;                                
  if(!(the_node->parent->parent)) return NULL;                        
  if(!(the_node->parent->parent->parent)) return NULL;                
4000a0c8:	80 a6 e0 00 	cmp  %i3, 0                                    
4000a0cc:	02 80 00 0c 	be  4000a0fc <_RBTree_Insert_unprotected+0x128><== NEVER TAKEN
4000a0d0:	c8 00 a0 04 	ld  [ %g2 + 4 ], %g4                           
{                                                                     
  if(!the_node) return NULL;                                          
  if(!(the_node->parent)) return NULL;                                
  if(!(the_node->parent->parent)) return NULL;                        
                                                                      
  if(the_node == the_node->parent->child[RBT_LEFT])                   
4000a0d4:	80 a1 00 01 	cmp  %g4, %g1                                  
4000a0d8:	02 80 00 5b 	be  4000a244 <_RBTree_Insert_unprotected+0x270>
4000a0dc:	ba 10 00 04 	mov  %g4, %i5                                  
 */                                                                   
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(                             
    const RBTree_Node *the_node                                       
    )                                                                 
{                                                                     
  return (the_node && the_node->color == RBT_RED);                    
4000a0e0:	80 a7 60 00 	cmp  %i5, 0                                    
4000a0e4:	22 80 00 07 	be,a   4000a100 <_RBTree_Insert_unprotected+0x12c>
4000a0e8:	fa 00 60 04 	ld  [ %g1 + 4 ], %i5                           
4000a0ec:	f8 07 60 0c 	ld  [ %i5 + 0xc ], %i4                         
4000a0f0:	80 a7 20 01 	cmp  %i4, 1                                    
4000a0f4:	22 80 00 4f 	be,a   4000a230 <_RBTree_Insert_unprotected+0x25c>
4000a0f8:	c0 20 60 0c 	clr  [ %g1 + 0xc ]                             
      the_node->parent->color = RBT_BLACK;                            
      u->color = RBT_BLACK;                                           
      g->color = RBT_RED;                                             
      the_node = g;                                                   
    } else { /* if uncle is black */                                  
      RBTree_Direction dir = the_node != the_node->parent->child[0];  
4000a0fc:	fa 00 60 04 	ld  [ %g1 + 4 ], %i5                           
      RBTree_Direction pdir = the_node->parent != g->child[0];        
4000a100:	88 18 40 04 	xor  %g1, %g4, %g4                             
4000a104:	80 a0 00 04 	cmp  %g0, %g4                                  
      the_node->parent->color = RBT_BLACK;                            
      u->color = RBT_BLACK;                                           
      g->color = RBT_RED;                                             
      the_node = g;                                                   
    } else { /* if uncle is black */                                  
      RBTree_Direction dir = the_node != the_node->parent->child[0];  
4000a108:	ba 1e 40 1d 	xor  %i1, %i5, %i5                             
      RBTree_Direction pdir = the_node->parent != g->child[0];        
4000a10c:	88 40 20 00 	addx  %g0, 0, %g4                              
      the_node->parent->color = RBT_BLACK;                            
      u->color = RBT_BLACK;                                           
      g->color = RBT_RED;                                             
      the_node = g;                                                   
    } else { /* if uncle is black */                                  
      RBTree_Direction dir = the_node != the_node->parent->child[0];  
4000a110:	80 a0 00 1d 	cmp  %g0, %i5                                  
4000a114:	ba 40 20 00 	addx  %g0, 0, %i5                              
      RBTree_Direction pdir = the_node->parent != g->child[0];        
                                                                      
      /* ensure node is on the same branch direction as parent */     
      if (dir != pdir) {                                              
4000a118:	80 a7 40 04 	cmp  %i5, %g4                                  
4000a11c:	02 80 00 20 	be  4000a19c <_RBTree_Insert_unprotected+0x1c8>
4000a120:	80 a0 00 04 	cmp  %g0, %g4                                  
 */                                                                   
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(     
  RBTree_Direction the_dir                                            
)                                                                     
{                                                                     
  return (RBTree_Direction) !((int) the_dir);                         
4000a124:	b6 60 3f ff 	subx  %g0, -1, %i3                             
    RBTree_Direction dir                                              
    )                                                                 
{                                                                     
  RBTree_Node *c;                                                     
  if (the_node == NULL) return;                                       
  if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
4000a128:	b7 2e e0 02 	sll  %i3, 2, %i3                               
4000a12c:	b6 00 40 1b 	add  %g1, %i3, %i3                             
4000a130:	fa 06 e0 04 	ld  [ %i3 + 4 ], %i5                           
4000a134:	80 a7 60 00 	cmp  %i5, 0                                    
4000a138:	02 80 00 16 	be  4000a190 <_RBTree_Insert_unprotected+0x1bc><== NEVER TAKEN
4000a13c:	b9 29 20 02 	sll  %g4, 2, %i4                               
                                                                      
  c = the_node->child[_RBTree_Opposite_direction(dir)];               
  the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];   
4000a140:	9e 07 40 1c 	add  %i5, %i4, %o7                             
4000a144:	da 03 e0 04 	ld  [ %o7 + 4 ], %o5                           
4000a148:	da 26 e0 04 	st  %o5, [ %i3 + 4 ]                           
                                                                      
  if (c->child[dir])                                                  
4000a14c:	f6 03 e0 04 	ld  [ %o7 + 4 ], %i3                           
4000a150:	80 a6 e0 00 	cmp  %i3, 0                                    
4000a154:	22 80 00 05 	be,a   4000a168 <_RBTree_Insert_unprotected+0x194>
4000a158:	b6 07 40 1c 	add  %i5, %i4, %i3                             
    c->child[dir]->parent = the_node;                                 
4000a15c:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
4000a160:	c4 00 40 00 	ld  [ %g1 ], %g2                               
                                                                      
  c->child[dir] = the_node;                                           
4000a164:	b6 07 40 1c 	add  %i5, %i4, %i3                             
4000a168:	c2 26 e0 04 	st  %g1, [ %i3 + 4 ]                           
                                                                      
  the_node->parent->child[the_node != the_node->parent->child[0]] = c;
4000a16c:	f6 00 a0 04 	ld  [ %g2 + 4 ], %i3                           
                                                                      
  c->parent = the_node->parent;                                       
4000a170:	c4 27 40 00 	st  %g2, [ %i5 ]                               
  if (c->child[dir])                                                  
    c->child[dir]->parent = the_node;                                 
                                                                      
  c->child[dir] = the_node;                                           
                                                                      
  the_node->parent->child[the_node != the_node->parent->child[0]] = c;
4000a174:	b6 1e c0 01 	xor  %i3, %g1, %i3                             
                                                                      
  c->parent = the_node->parent;                                       
  the_node->parent = c;                                               
4000a178:	fa 20 40 00 	st  %i5, [ %g1 ]                               
  if (c->child[dir])                                                  
    c->child[dir]->parent = the_node;                                 
                                                                      
  c->child[dir] = the_node;                                           
                                                                      
  the_node->parent->child[the_node != the_node->parent->child[0]] = c;
4000a17c:	80 a0 00 1b 	cmp  %g0, %i3                                  
4000a180:	82 40 20 00 	addx  %g0, 0, %g1                              
4000a184:	83 28 60 02 	sll  %g1, 2, %g1                               
4000a188:	84 00 80 01 	add  %g2, %g1, %g2                             
4000a18c:	fa 20 a0 04 	st  %i5, [ %g2 + 4 ]                           
        _RBTree_Rotate(the_node->parent, pdir);                       
        the_node = the_node->child[pdir];                             
4000a190:	b2 06 40 1c 	add  %i1, %i4, %i1                             
4000a194:	f2 06 60 04 	ld  [ %i1 + 4 ], %i1                           
4000a198:	c2 06 40 00 	ld  [ %i1 ], %g1                               
      }                                                               
      the_node->parent->color = RBT_BLACK;                            
4000a19c:	c0 20 60 0c 	clr  [ %g1 + 0xc ]                             
      g->color = RBT_RED;                                             
                                                                      
      /* now rotate grandparent in the other branch direction (toward uncle) */
      _RBTree_Rotate(g, (1-pdir));                                    
4000a1a0:	88 26 80 04 	sub  %i2, %g4, %g4                             
4000a1a4:	ba 19 20 01 	xor  %g4, 1, %i5                               
    RBTree_Direction dir                                              
    )                                                                 
{                                                                     
  RBTree_Node *c;                                                     
  if (the_node == NULL) return;                                       
  if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
4000a1a8:	bb 2f 60 02 	sll  %i5, 2, %i5                               
4000a1ac:	ba 00 c0 1d 	add  %g3, %i5, %i5                             
4000a1b0:	c4 07 60 04 	ld  [ %i5 + 4 ], %g2                           
4000a1b4:	80 a0 a0 00 	cmp  %g2, 0                                    
4000a1b8:	02 bf ff b6 	be  4000a090 <_RBTree_Insert_unprotected+0xbc> <== NEVER TAKEN
4000a1bc:	f4 20 e0 0c 	st  %i2, [ %g3 + 0xc ]                         
                                                                      
  c = the_node->child[_RBTree_Opposite_direction(dir)];               
  the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];   
4000a1c0:	89 29 20 02 	sll  %g4, 2, %g4                               
4000a1c4:	82 00 80 04 	add  %g2, %g4, %g1                             
4000a1c8:	f8 00 60 04 	ld  [ %g1 + 4 ], %i4                           
4000a1cc:	f8 27 60 04 	st  %i4, [ %i5 + 4 ]                           
                                                                      
  if (c->child[dir])                                                  
4000a1d0:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
4000a1d4:	80 a0 60 00 	cmp  %g1, 0                                    
4000a1d8:	32 80 00 02 	bne,a   4000a1e0 <_RBTree_Insert_unprotected+0x20c>
4000a1dc:	c6 20 40 00 	st  %g3, [ %g1 ]                               
    c->child[dir]->parent = the_node;                                 
                                                                      
  c->child[dir] = the_node;                                           
                                                                      
  the_node->parent->child[the_node != the_node->parent->child[0]] = c;
4000a1e0:	fa 00 c0 00 	ld  [ %g3 ], %i5                               
  the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];   
                                                                      
  if (c->child[dir])                                                  
    c->child[dir]->parent = the_node;                                 
                                                                      
  c->child[dir] = the_node;                                           
4000a1e4:	88 00 80 04 	add  %g2, %g4, %g4                             
                                                                      
  the_node->parent->child[the_node != the_node->parent->child[0]] = c;
                                                                      
  c->parent = the_node->parent;                                       
4000a1e8:	fa 20 80 00 	st  %i5, [ %g2 ]                               
  the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];   
                                                                      
  if (c->child[dir])                                                  
    c->child[dir]->parent = the_node;                                 
                                                                      
  c->child[dir] = the_node;                                           
4000a1ec:	c6 21 20 04 	st  %g3, [ %g4 + 4 ]                           
                                                                      
  the_node->parent->child[the_node != the_node->parent->child[0]] = c;
4000a1f0:	c8 07 60 04 	ld  [ %i5 + 4 ], %g4                           
                                                                      
  c->parent = the_node->parent;                                       
  the_node->parent = c;                                               
4000a1f4:	c4 20 c0 00 	st  %g2, [ %g3 ]                               
4000a1f8:	c2 06 40 00 	ld  [ %i1 ], %g1                               
  if (c->child[dir])                                                  
    c->child[dir]->parent = the_node;                                 
                                                                      
  c->child[dir] = the_node;                                           
                                                                      
  the_node->parent->child[the_node != the_node->parent->child[0]] = c;
4000a1fc:	86 18 c0 04 	xor  %g3, %g4, %g3                             
4000a200:	80 a0 00 03 	cmp  %g0, %g3                                  
4000a204:	86 40 20 00 	addx  %g0, 0, %g3                              
4000a208:	87 28 e0 02 	sll  %g3, 2, %g3                               
4000a20c:	ba 07 40 03 	add  %i5, %g3, %i5                             
4000a210:	c4 27 60 04 	st  %g2, [ %i5 + 4 ]                           
 */                                                                   
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Parent(                     
  const RBTree_Node *the_node                                         
)                                                                     
{                                                                     
  if (!the_node->parent->parent) return NULL;                         
4000a214:	c4 00 40 00 	ld  [ %g1 ], %g2                               
4000a218:	86 90 a0 00 	orcc  %g2, 0, %g3                              
4000a21c:	32 bf ff a2 	bne,a   4000a0a4 <_RBTree_Insert_unprotected+0xd0><== ALWAYS TAKEN
4000a220:	c8 00 60 0c 	ld  [ %g1 + 0xc ], %g4                         
    }                                                                 
  }                                                                   
  if(!the_node->parent->parent) the_node->color = RBT_BLACK;          
4000a224:	c0 26 60 0c 	clr  [ %i1 + 0xc ]                             <== NOT EXECUTED
                                                                      
    /* verify red-black properties */                                 
    _RBTree_Validate_insert_unprotected(the_node);                    
  }                                                                   
  return (RBTree_Node*)0;                                             
}                                                                     
4000a228:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000a22c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    g = the_node->parent->parent;                                     
                                                                      
    /* if uncle is red, repaint uncle/parent black and grandparent red */
    if(_RBTree_Is_red(u)) {                                           
      the_node->parent->color = RBT_BLACK;                            
      u->color = RBT_BLACK;                                           
4000a230:	c0 27 60 0c 	clr  [ %i5 + 0xc ]                             
      g->color = RBT_RED;                                             
4000a234:	f8 20 a0 0c 	st  %i4, [ %g2 + 0xc ]                         
4000a238:	82 10 00 1b 	mov  %i3, %g1                                  
4000a23c:	10 bf ff 95 	b  4000a090 <_RBTree_Insert_unprotected+0xbc>  
4000a240:	b2 10 00 02 	mov  %g2, %i1                                  
  if(!the_node) return NULL;                                          
  if(!(the_node->parent)) return NULL;                                
  if(!(the_node->parent->parent)) return NULL;                        
                                                                      
  if(the_node == the_node->parent->child[RBT_LEFT])                   
    return the_node->parent->child[RBT_RIGHT];                        
4000a244:	10 bf ff a7 	b  4000a0e0 <_RBTree_Insert_unprotected+0x10c> 
4000a248:	fa 00 a0 08 	ld  [ %g2 + 8 ], %i5                           
RBTree_Node *_RBTree_Insert_unprotected(                              
    RBTree_Control *the_rbtree,                                       
    RBTree_Node *the_node                                             
    )                                                                 
{                                                                     
  if(!the_node) return (RBTree_Node*)-1;                              
4000a24c:	81 c7 e0 08 	ret                                            
4000a250:	91 e8 3f ff 	restore  %g0, -1, %o0                          
    the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;    
  } else {                                                            
    /* typical binary search tree insert, descend tree to leaf and insert */
    while (iter_node) {                                               
      compare_result = the_rbtree->compare_function(the_node, iter_node);
      if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) )
4000a254:	81 c7 e0 08 	ret                                            
4000a258:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
  RBTree_Node *iter_node = the_rbtree->root;                          
  int compare_result;                                                 
                                                                      
  if (!iter_node) { /* special case: first node inserted */           
    the_node->color = RBT_BLACK;                                      
    the_rbtree->root = the_node;                                      
4000a25c:	f2 26 20 04 	st  %i1, [ %i0 + 4 ]                           
    the_rbtree->first[0] = the_rbtree->first[1] = the_node;           
4000a260:	f2 26 20 0c 	st  %i1, [ %i0 + 0xc ]                         
4000a264:	f2 26 20 08 	st  %i1, [ %i0 + 8 ]                           
    the_node->parent = (RBTree_Node *) the_rbtree;                    
4000a268:	f0 26 40 00 	st  %i0, [ %i1 ]                               
    the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;    
4000a26c:	c0 26 60 08 	clr  [ %i1 + 8 ]                               
4000a270:	c0 26 60 04 	clr  [ %i1 + 4 ]                               
    } /* while(iter_node) */                                          
                                                                      
    /* verify red-black properties */                                 
    _RBTree_Validate_insert_unprotected(the_node);                    
  }                                                                   
  return (RBTree_Node*)0;                                             
4000a274:	81 c7 e0 08 	ret                                            
4000a278:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

4000a2ac <_RBTree_Iterate_unprotected>: const RBTree_Control *rbtree, RBTree_Direction dir, RBTree_Visitor visitor, void *visitor_arg ) {
4000a2ac:	9d e3 bf a0 	save  %sp, -96, %sp                            
 */                                                                   
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(     
  RBTree_Direction the_dir                                            
)                                                                     
{                                                                     
  return (RBTree_Direction) !((int) the_dir);                         
4000a2b0:	80 a0 00 19 	cmp  %g0, %i1                                  
4000a2b4:	82 60 3f ff 	subx  %g0, -1, %g1                             
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_First(                      
  const RBTree_Control *the_rbtree,                                   
  RBTree_Direction dir                                                
)                                                                     
{                                                                     
  return the_rbtree->first[dir];                                      
4000a2b8:	82 00 60 02 	add  %g1, 2, %g1                               
4000a2bc:	83 28 60 02 	sll  %g1, 2, %g1                               
4000a2c0:	fa 06 00 01 	ld  [ %i0 + %g1 ], %i5                         
  RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir );       
  const RBTree_Node *current = _RBTree_First( rbtree, opp_dir );      
  bool stop = false;                                                  
                                                                      
  while ( !stop && current != NULL ) {                                
4000a2c4:	80 a7 60 00 	cmp  %i5, 0                                    
4000a2c8:	12 80 00 06 	bne  4000a2e0 <_RBTree_Iterate_unprotected+0x34><== ALWAYS TAKEN
4000a2cc:	94 10 00 1b 	mov  %i3, %o2                                  
4000a2d0:	30 80 00 0e 	b,a   4000a308 <_RBTree_Iterate_unprotected+0x5c><== NOT EXECUTED
4000a2d4:	80 8f 20 ff 	btst  0xff, %i4                                
4000a2d8:	02 80 00 0c 	be  4000a308 <_RBTree_Iterate_unprotected+0x5c><== NEVER TAKEN
4000a2dc:	94 10 00 1b 	mov  %i3, %o2                                  
    stop = (*visitor)( current, dir, visitor_arg );                   
4000a2e0:	90 10 00 1d 	mov  %i5, %o0                                  
4000a2e4:	9f c6 80 00 	call  %i2                                      
4000a2e8:	92 10 00 19 	mov  %i1, %o1                                  
                                                                      
    current = _RBTree_Next_unprotected( current, dir );               
4000a2ec:	92 10 00 19 	mov  %i1, %o1                                  
  RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir );       
  const RBTree_Node *current = _RBTree_First( rbtree, opp_dir );      
  bool stop = false;                                                  
                                                                      
  while ( !stop && current != NULL ) {                                
    stop = (*visitor)( current, dir, visitor_arg );                   
4000a2f0:	b8 10 00 08 	mov  %o0, %i4                                  
                                                                      
    current = _RBTree_Next_unprotected( current, dir );               
4000a2f4:	40 00 00 07 	call  4000a310 <_RBTree_Next_unprotected>      
4000a2f8:	90 10 00 1d 	mov  %i5, %o0                                  
{                                                                     
  RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir );       
  const RBTree_Node *current = _RBTree_First( rbtree, opp_dir );      
  bool stop = false;                                                  
                                                                      
  while ( !stop && current != NULL ) {                                
4000a2fc:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4000a300:	12 bf ff f5 	bne  4000a2d4 <_RBTree_Iterate_unprotected+0x28>
4000a304:	b8 1f 20 01 	xor  %i4, 1, %i4                               
4000a308:	81 c7 e0 08 	ret                                            
4000a30c:	81 e8 00 00 	restore                                        
                                                                      

40008418 <_RTEMS_signal_Post_switch_hook>: #include <rtems/score/thread.h> #include <rtems/score/apiext.h> #include <rtems/rtems/tasks.h> static void _RTEMS_signal_Post_switch_hook( Thread_Control *executing ) {
40008418:	9d e3 bf 98 	save  %sp, -104, %sp                           
  RTEMS_API_Control *api;                                             
  ASR_Information   *asr;                                             
  rtems_signal_set   signal_set;                                      
  Modes_Control      prev_mode;                                       
                                                                      
  api = executing->API_Extensions[ THREAD_API_RTEMS ];                
4000841c:	fa 06 21 4c 	ld  [ %i0 + 0x14c ], %i5                       
  if ( !api )                                                         
40008420:	80 a7 60 00 	cmp  %i5, 0                                    
40008424:	02 80 00 1e 	be  4000849c <_RTEMS_signal_Post_switch_hook+0x84><== NEVER TAKEN
40008428:	01 00 00 00 	nop                                            
   *  Signal Processing                                               
   */                                                                 
                                                                      
  asr = &api->Signal;                                                 
                                                                      
  _ISR_Disable( level );                                              
4000842c:	7f ff ea c7 	call  40002f48 <sparc_disable_interrupts>      
40008430:	01 00 00 00 	nop                                            
    signal_set = asr->signals_posted;                                 
40008434:	f8 07 60 14 	ld  [ %i5 + 0x14 ], %i4                        
    asr->signals_posted = 0;                                          
40008438:	c0 27 60 14 	clr  [ %i5 + 0x14 ]                            
  _ISR_Enable( level );                                               
4000843c:	7f ff ea c7 	call  40002f58 <sparc_enable_interrupts>       
40008440:	01 00 00 00 	nop                                            
                                                                      
                                                                      
  if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ 
40008444:	80 a7 20 00 	cmp  %i4, 0                                    
40008448:	32 80 00 04 	bne,a   40008458 <_RTEMS_signal_Post_switch_hook+0x40>
4000844c:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
40008450:	81 c7 e0 08 	ret                                            
40008454:	81 e8 00 00 	restore                                        
    return;                                                           
                                                                      
  asr->nest_level += 1;                                               
  rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 
40008458:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        
                                                                      
                                                                      
  if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ 
    return;                                                           
                                                                      
  asr->nest_level += 1;                                               
4000845c:	82 00 60 01 	inc  %g1                                       
  rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 
40008460:	94 07 bf fc 	add  %fp, -4, %o2                              
40008464:	37 00 00 3f 	sethi  %hi(0xfc00), %i3                        
                                                                      
                                                                      
  if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ 
    return;                                                           
                                                                      
  asr->nest_level += 1;                                               
40008468:	c2 27 60 1c 	st  %g1, [ %i5 + 0x1c ]                        
  rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 
4000846c:	40 00 01 07 	call  40008888 <rtems_task_mode>               
40008470:	92 16 e3 ff 	or  %i3, 0x3ff, %o1                            
                                                                      
  (*asr->handler)( signal_set );                                      
40008474:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
40008478:	9f c0 40 00 	call  %g1                                      
4000847c:	90 10 00 1c 	mov  %i4, %o0                                  
                                                                      
  asr->nest_level -= 1;                                               
40008480:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
  rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );     
40008484:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
  asr->nest_level += 1;                                               
  rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 
                                                                      
  (*asr->handler)( signal_set );                                      
                                                                      
  asr->nest_level -= 1;                                               
40008488:	82 00 7f ff 	add  %g1, -1, %g1                              
  rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );     
4000848c:	92 16 e3 ff 	or  %i3, 0x3ff, %o1                            
40008490:	94 07 bf fc 	add  %fp, -4, %o2                              
40008494:	40 00 00 fd 	call  40008888 <rtems_task_mode>               
40008498:	c2 27 60 1c 	st  %g1, [ %i5 + 0x1c ]                        
4000849c:	81 c7 e0 08 	ret                                            
400084a0:	81 e8 00 00 	restore                                        
                                                                      

400077cc <_RTEMS_tasks_Initialize_user_tasks_body>: * * Output parameters: NONE */ void _RTEMS_tasks_Initialize_user_tasks_body( void ) {
400077cc:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_initialization_tasks_table *user_tasks;                       
                                                                      
  /*                                                                  
   *  Move information into local variables                           
   */                                                                 
  user_tasks = Configuration_RTEMS_API.User_initialization_tasks_table;
400077d0:	03 10 00 78 	sethi  %hi(0x4001e000), %g1                    
400077d4:	82 10 62 e4 	or  %g1, 0x2e4, %g1	! 4001e2e4 <Configuration_RTEMS_API>
400077d8:	fa 00 60 2c 	ld  [ %g1 + 0x2c ], %i5                        
  maximum    = Configuration_RTEMS_API.number_of_initialization_tasks;
                                                                      
  /*                                                                  
   *  Verify that we have a set of user tasks to iterate              
   */                                                                 
  if ( !user_tasks )                                                  
400077dc:	80 a7 60 00 	cmp  %i5, 0                                    
400077e0:	02 80 00 18 	be  40007840 <_RTEMS_tasks_Initialize_user_tasks_body+0x74>
400077e4:	f6 00 60 28 	ld  [ %g1 + 0x28 ], %i3                        
    return;                                                           
                                                                      
  /*                                                                  
   *  Now iterate over the initialization tasks and create/start them.
   */                                                                 
  for ( index=0 ; index < maximum ; index++ ) {                       
400077e8:	80 a6 e0 00 	cmp  %i3, 0                                    
400077ec:	02 80 00 15 	be  40007840 <_RTEMS_tasks_Initialize_user_tasks_body+0x74><== NEVER TAKEN
400077f0:	b8 10 20 00 	clr  %i4                                       
    return_value = rtems_task_create(                                 
400077f4:	d4 07 60 04 	ld  [ %i5 + 4 ], %o2                           
400077f8:	d0 07 40 00 	ld  [ %i5 ], %o0                               
400077fc:	d2 07 60 08 	ld  [ %i5 + 8 ], %o1                           
40007800:	d6 07 60 14 	ld  [ %i5 + 0x14 ], %o3                        
40007804:	d8 07 60 0c 	ld  [ %i5 + 0xc ], %o4                         
40007808:	7f ff ff 70 	call  400075c8 <rtems_task_create>             
4000780c:	9a 07 bf fc 	add  %fp, -4, %o5                              
      user_tasks[ index ].stack_size,                                 
      user_tasks[ index ].mode_set,                                   
      user_tasks[ index ].attribute_set,                              
      &id                                                             
    );                                                                
    if ( !rtems_is_status_successful( return_value ) )                
40007810:	94 92 20 00 	orcc  %o0, 0, %o2                              
40007814:	12 80 00 0d 	bne  40007848 <_RTEMS_tasks_Initialize_user_tasks_body+0x7c>
40007818:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
      _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value );
                                                                      
    return_value = rtems_task_start(                                  
4000781c:	d4 07 60 18 	ld  [ %i5 + 0x18 ], %o2                        
40007820:	40 00 00 0e 	call  40007858 <rtems_task_start>              
40007824:	d2 07 60 10 	ld  [ %i5 + 0x10 ], %o1                        
      id,                                                             
      user_tasks[ index ].entry_point,                                
      user_tasks[ index ].argument                                    
    );                                                                
    if ( !rtems_is_status_successful( return_value ) )                
40007828:	94 92 20 00 	orcc  %o0, 0, %o2                              
4000782c:	12 80 00 07 	bne  40007848 <_RTEMS_tasks_Initialize_user_tasks_body+0x7c>
40007830:	b8 07 20 01 	inc  %i4                                       
    return;                                                           
                                                                      
  /*                                                                  
   *  Now iterate over the initialization tasks and create/start them.
   */                                                                 
  for ( index=0 ; index < maximum ; index++ ) {                       
40007834:	80 a7 00 1b 	cmp  %i4, %i3                                  
40007838:	12 bf ff ef 	bne  400077f4 <_RTEMS_tasks_Initialize_user_tasks_body+0x28><== NEVER TAKEN
4000783c:	ba 07 60 1c 	add  %i5, 0x1c, %i5                            
40007840:	81 c7 e0 08 	ret                                            
40007844:	81 e8 00 00 	restore                                        
      id,                                                             
      user_tasks[ index ].entry_point,                                
      user_tasks[ index ].argument                                    
    );                                                                
    if ( !rtems_is_status_successful( return_value ) )                
      _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value );
40007848:	90 10 20 01 	mov  1, %o0                                    
4000784c:	40 00 04 30 	call  4000890c <_Internal_error_Occurred>      
40007850:	92 10 20 01 	mov  1, %o1                                    
                                                                      

4000d020 <_RTEMS_tasks_Switch_extension>: /* * Per Task Variables */ tvp = executing->task_variables;
4000d020:	c2 02 21 58 	ld  [ %o0 + 0x158 ], %g1                       
  while (tvp) {                                                       
4000d024:	80 a0 60 00 	cmp  %g1, 0                                    
4000d028:	22 80 00 0c 	be,a   4000d058 <_RTEMS_tasks_Switch_extension+0x38>
4000d02c:	c2 02 61 58 	ld  [ %o1 + 0x158 ], %g1                       
    tvp->tval = *tvp->ptr;                                            
4000d030:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
    *tvp->ptr = tvp->gval;                                            
4000d034:	c6 00 60 08 	ld  [ %g1 + 8 ], %g3                           
   *  Per Task Variables                                              
   */                                                                 
                                                                      
  tvp = executing->task_variables;                                    
  while (tvp) {                                                       
    tvp->tval = *tvp->ptr;                                            
4000d038:	c8 00 80 00 	ld  [ %g2 ], %g4                               
4000d03c:	c8 20 60 0c 	st  %g4, [ %g1 + 0xc ]                         
    *tvp->ptr = tvp->gval;                                            
4000d040:	c6 20 80 00 	st  %g3, [ %g2 ]                               
    tvp = (rtems_task_variable_t *)tvp->next;                         
4000d044:	c2 00 40 00 	ld  [ %g1 ], %g1                               
  /*                                                                  
   *  Per Task Variables                                              
   */                                                                 
                                                                      
  tvp = executing->task_variables;                                    
  while (tvp) {                                                       
4000d048:	80 a0 60 00 	cmp  %g1, 0                                    
4000d04c:	32 bf ff fa 	bne,a   4000d034 <_RTEMS_tasks_Switch_extension+0x14><== NEVER TAKEN
4000d050:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           <== NOT EXECUTED
    tvp->tval = *tvp->ptr;                                            
    *tvp->ptr = tvp->gval;                                            
    tvp = (rtems_task_variable_t *)tvp->next;                         
  }                                                                   
                                                                      
  tvp = heir->task_variables;                                         
4000d054:	c2 02 61 58 	ld  [ %o1 + 0x158 ], %g1                       
  while (tvp) {                                                       
4000d058:	80 a0 60 00 	cmp  %g1, 0                                    
4000d05c:	02 80 00 0d 	be  4000d090 <_RTEMS_tasks_Switch_extension+0x70>
4000d060:	01 00 00 00 	nop                                            
    tvp->gval = *tvp->ptr;                                            
4000d064:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
    *tvp->ptr = tvp->tval;                                            
4000d068:	c6 00 60 0c 	ld  [ %g1 + 0xc ], %g3                         
    tvp = (rtems_task_variable_t *)tvp->next;                         
  }                                                                   
                                                                      
  tvp = heir->task_variables;                                         
  while (tvp) {                                                       
    tvp->gval = *tvp->ptr;                                            
4000d06c:	c8 00 80 00 	ld  [ %g2 ], %g4                               
4000d070:	c8 20 60 08 	st  %g4, [ %g1 + 8 ]                           
    *tvp->ptr = tvp->tval;                                            
4000d074:	c6 20 80 00 	st  %g3, [ %g2 ]                               
    tvp = (rtems_task_variable_t *)tvp->next;                         
4000d078:	c2 00 40 00 	ld  [ %g1 ], %g1                               
    *tvp->ptr = tvp->gval;                                            
    tvp = (rtems_task_variable_t *)tvp->next;                         
  }                                                                   
                                                                      
  tvp = heir->task_variables;                                         
  while (tvp) {                                                       
4000d07c:	80 a0 60 00 	cmp  %g1, 0                                    
4000d080:	32 bf ff fa 	bne,a   4000d068 <_RTEMS_tasks_Switch_extension+0x48><== NEVER TAKEN
4000d084:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           <== NOT EXECUTED
4000d088:	81 c3 e0 08 	retl                                           
4000d08c:	01 00 00 00 	nop                                            
4000d090:	81 c3 e0 08 	retl                                           
                                                                      

4003768c <_Rate_monotonic_Get_status>: bool _Rate_monotonic_Get_status( Rate_monotonic_Control *the_period, Rate_monotonic_Period_time_t *wall_since_last_period, Thread_CPU_usage_t *cpu_since_last_period ) {
4003768c:	9d e3 bf 98 	save  %sp, -104, %sp                           
 */                                                                   
static inline void _TOD_Get_uptime(                                   
  Timestamp_Control *time                                             
)                                                                     
{                                                                     
  _TOD_Get_with_nanoseconds( time, &_TOD.uptime );                    
40037690:	13 10 01 a0 	sethi  %hi(0x40068000), %o1                    
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    Timestamp_Control        uptime;                                  
  #endif                                                              
    Thread_Control          *owning_thread = the_period->owner;       
40037694:	f6 06 20 40 	ld  [ %i0 + 0x40 ], %i3                        
40037698:	90 07 bf f8 	add  %fp, -8, %o0                              
4003769c:	7f ff 41 e1 	call  40007e20 <_TOD_Get_with_nanoseconds>     
400376a0:	92 12 63 f0 	or  %o1, 0x3f0, %o1                            
  /*                                                                  
   *  Determine elapsed wall time since period initiated.             
   */                                                                 
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    _TOD_Get_uptime( &uptime );                                       
    _Timestamp_Subtract(                                              
400376a4:	c4 1f bf f8 	ldd  [ %fp + -8 ], %g2                         
  const Timestamp64_Control *_start,                                  
  const Timestamp64_Control *_end,                                    
  Timestamp64_Control       *_result                                  
)                                                                     
{                                                                     
  *_result = *_end - *_start;                                         
400376a8:	f8 1e 20 50 	ldd  [ %i0 + 0x50 ], %i4                       
   *  Determine cpu usage since period initiated.                     
   */                                                                 
  used = owning_thread->cpu_time_used;                                
                                                                      
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    if (owning_thread == _Thread_Executing) {                         
400376ac:	03 10 01 a2 	sethi  %hi(0x40068800), %g1                    
400376b0:	82 10 61 b0 	or  %g1, 0x1b0, %g1	! 400689b0 <_Per_CPU_Information>
400376b4:	de 00 60 10 	ld  [ %g1 + 0x10 ], %o7                        
400376b8:	ba a0 c0 1d 	subcc  %g3, %i5, %i5                           
400376bc:	b8 60 80 1c 	subx  %g2, %i4, %i4                            
400376c0:	f8 3e 40 00 	std  %i4, [ %i1 ]                              
      if (used < the_period->cpu_usage_period_initiated)              
        return false;                                                 
                                                                      
      *cpu_since_last_period = used - the_period->cpu_usage_period_initiated;
  #endif                                                              
  return true;                                                        
400376c4:	88 10 20 01 	mov  1, %g4                                    
   *  Determine cpu usage since period initiated.                     
   */                                                                 
  used = owning_thread->cpu_time_used;                                
                                                                      
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    if (owning_thread == _Thread_Executing) {                         
400376c8:	80 a3 c0 1b 	cmp  %o7, %i3                                  
400376cc:	02 80 00 05 	be  400376e0 <_Rate_monotonic_Get_status+0x54> 
400376d0:	f8 1e e0 80 	ldd  [ %i3 + 0x80 ], %i4                       
        return false;                                                 
                                                                      
      *cpu_since_last_period = used - the_period->cpu_usage_period_initiated;
  #endif                                                              
  return true;                                                        
}                                                                     
400376d4:	b0 09 20 01 	and  %g4, 1, %i0                               
400376d8:	81 c7 e0 08 	ret                                            
400376dc:	81 e8 00 00 	restore                                        
400376e0:	d8 18 60 20 	ldd  [ %g1 + 0x20 ], %o4                       
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
400376e4:	f0 1e 20 48 	ldd  [ %i0 + 0x48 ], %i0                       
400376e8:	86 a0 c0 0d 	subcc  %g3, %o5, %g3                           
400376ec:	84 60 80 0c 	subx  %g2, %o4, %g2                            
static inline void _Timestamp64_implementation_Add_to(                
  Timestamp64_Control       *_time,                                   
  const Timestamp64_Control *_add                                     
)                                                                     
{                                                                     
  *_time += *_add;                                                    
400376f0:	9a 87 40 03 	addcc  %i5, %g3, %o5                           
400376f4:	98 47 00 02 	addx  %i4, %g2, %o4                            
                                                                      
      /*                                                              
       *  The cpu usage info was reset while executing.  Can't        
       *  determine a status.                                         
       */                                                             
      if (_Timestamp_Less_than(&used, &the_period->cpu_usage_period_initiated))
400376f8:	80 a6 00 0c 	cmp  %i0, %o4                                  
400376fc:	14 bf ff f6 	bg  400376d4 <_Rate_monotonic_Get_status+0x48> <== NEVER TAKEN
40037700:	88 10 20 00 	clr  %g4                                       
40037704:	02 80 00 09 	be  40037728 <_Rate_monotonic_Get_status+0x9c> 
40037708:	80 a6 40 0d 	cmp  %i1, %o5                                  
  const Timestamp64_Control *_start,                                  
  const Timestamp64_Control *_end,                                    
  Timestamp64_Control       *_result                                  
)                                                                     
{                                                                     
  *_result = *_end - *_start;                                         
4003770c:	9a a3 40 19 	subcc  %o5, %i1, %o5                           
      if (used < the_period->cpu_usage_period_initiated)              
        return false;                                                 
                                                                      
      *cpu_since_last_period = used - the_period->cpu_usage_period_initiated;
  #endif                                                              
  return true;                                                        
40037710:	88 10 20 01 	mov  1, %g4                                    
40037714:	98 63 00 18 	subx  %o4, %i0, %o4                            
}                                                                     
40037718:	b0 09 20 01 	and  %g4, 1, %i0                               
4003771c:	d8 3e 80 00 	std  %o4, [ %i2 ]                              
40037720:	81 c7 e0 08 	ret                                            
40037724:	81 e8 00 00 	restore                                        
                                                                      
      /*                                                              
       *  The cpu usage info was reset while executing.  Can't        
       *  determine a status.                                         
       */                                                             
      if (_Timestamp_Less_than(&used, &the_period->cpu_usage_period_initiated))
40037728:	28 bf ff fa 	bleu,a   40037710 <_Rate_monotonic_Get_status+0x84>
4003772c:	9a a3 40 19 	subcc  %o5, %i1, %o5                           
        return false;                                                 
40037730:	10 bf ff e9 	b  400376d4 <_Rate_monotonic_Get_status+0x48>  
40037734:	88 10 20 00 	clr  %g4                                       
                                                                      

40037adc <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) {
40037adc:	9d e3 bf 98 	save  %sp, -104, %sp                           
40037ae0:	11 10 01 a3 	sethi  %hi(0x40068c00), %o0                    
40037ae4:	92 10 00 18 	mov  %i0, %o1                                  
40037ae8:	90 12 23 78 	or  %o0, 0x378, %o0                            
40037aec:	7f ff 43 a1 	call  40008970 <_Objects_Get>                  
40037af0:	94 07 bf fc 	add  %fp, -4, %o2                              
  /*                                                                  
   *  When we get here, the Timer is already off the chain so we do not
   *  have to worry about that -- hence no _Watchdog_Remove().        
   */                                                                 
  the_period = _Rate_monotonic_Get( id, &location );                  
  switch ( location ) {                                               
40037af4:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40037af8:	80 a0 60 00 	cmp  %g1, 0                                    
40037afc:	12 80 00 16 	bne  40037b54 <_Rate_monotonic_Timeout+0x78>   <== NEVER TAKEN
40037b00:	ba 10 00 08 	mov  %o0, %i5                                  
                                                                      
    case OBJECTS_LOCAL:                                               
      the_thread = the_period->owner;                                 
40037b04:	d0 02 20 40 	ld  [ %o0 + 0x40 ], %o0                        
      if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
40037b08:	03 00 00 10 	sethi  %hi(0x4000), %g1                        
 */                                                                   
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_for_period (             
  States_Control the_states                                           
)                                                                     
{                                                                     
   return (the_states & STATES_WAITING_FOR_PERIOD);                   
40037b0c:	c4 02 20 10 	ld  [ %o0 + 0x10 ], %g2                        
40037b10:	80 88 80 01 	btst  %g2, %g1                                 
40037b14:	22 80 00 08 	be,a   40037b34 <_Rate_monotonic_Timeout+0x58> 
40037b18:	c2 07 60 38 	ld  [ %i5 + 0x38 ], %g1                        
40037b1c:	c4 02 20 20 	ld  [ %o0 + 0x20 ], %g2                        
40037b20:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
40037b24:	80 a0 80 01 	cmp  %g2, %g1                                  
40037b28:	02 80 00 19 	be  40037b8c <_Rate_monotonic_Timeout+0xb0>    
40037b2c:	13 04 01 ff 	sethi  %hi(0x1007fc00), %o1                    
        _Thread_Unblock( the_thread );                                
                                                                      
        _Rate_monotonic_Initiate_statistics( the_period );            
                                                                      
        _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
      } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
40037b30:	c2 07 60 38 	ld  [ %i5 + 0x38 ], %g1                        
40037b34:	80 a0 60 01 	cmp  %g1, 1                                    
40037b38:	02 80 00 09 	be  40037b5c <_Rate_monotonic_Timeout+0x80>    
40037b3c:	82 10 20 04 	mov  4, %g1                                    
                                                                      
        _Rate_monotonic_Initiate_statistics( the_period );            
                                                                      
        _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
      } else                                                          
        the_period->state = RATE_MONOTONIC_EXPIRED;                   
40037b40:	c2 27 60 38 	st  %g1, [ %i5 + 0x38 ]                        
   *                                                                  
   * This routine decrements the thread dispatch level.               
   */                                                                 
  RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
  {                                                                   
    uint32_t level = _Thread_Dispatch_disable_level;                  
40037b44:	03 10 01 a1 	sethi  %hi(0x40068400), %g1                    
40037b48:	c4 00 60 a0 	ld  [ %g1 + 0xa0 ], %g2	! 400684a0 <_Thread_Dispatch_disable_level>
                                                                      
    --level;                                                          
40037b4c:	84 00 bf ff 	add  %g2, -1, %g2                              
    _Thread_Dispatch_disable_level = level;                           
40037b50:	c4 20 60 a0 	st  %g2, [ %g1 + 0xa0 ]                        
40037b54:	81 c7 e0 08 	ret                                            
40037b58:	81 e8 00 00 	restore                                        
                                                                      
        _Rate_monotonic_Initiate_statistics( the_period );            
                                                                      
        _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
      } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
        the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;    
40037b5c:	82 10 20 03 	mov  3, %g1                                    
                                                                      
        _Rate_monotonic_Initiate_statistics( the_period );            
40037b60:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
        _Rate_monotonic_Initiate_statistics( the_period );            
                                                                      
        _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
      } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
        the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;    
40037b64:	c2 27 60 38 	st  %g1, [ %i5 + 0x38 ]                        
                                                                      
        _Rate_monotonic_Initiate_statistics( the_period );            
40037b68:	7f ff ff 43 	call  40037874 <_Rate_monotonic_Initiate_statistics>
40037b6c:	01 00 00 00 	nop                                            
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
40037b70:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
40037b74:	11 10 01 a1 	sethi  %hi(0x40068400), %o0                    
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
40037b78:	c2 27 60 1c 	st  %g1, [ %i5 + 0x1c ]                        
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
40037b7c:	90 12 21 38 	or  %o0, 0x138, %o0                            
40037b80:	7f ff 4a 6f 	call  4000a53c <_Watchdog_Insert>              
40037b84:	92 07 60 10 	add  %i5, 0x10, %o1                            
40037b88:	30 bf ff ef 	b,a   40037b44 <_Rate_monotonic_Timeout+0x68>  
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Unblock (                           
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
  _Thread_Clear_state( the_thread, STATES_BLOCKED );                  
40037b8c:	7f ff 46 43 	call  40009498 <_Thread_Clear_state>           
40037b90:	92 12 63 f8 	or  %o1, 0x3f8, %o1                            
      the_thread = the_period->owner;                                 
      if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
            the_thread->Wait.id == the_period->Object.id ) {          
        _Thread_Unblock( the_thread );                                
                                                                      
        _Rate_monotonic_Initiate_statistics( the_period );            
40037b94:	10 bf ff f5 	b  40037b68 <_Rate_monotonic_Timeout+0x8c>     
40037b98:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      

40037738 <_Rate_monotonic_Update_statistics>: } static void _Rate_monotonic_Update_statistics( Rate_monotonic_Control *the_period ) {
40037738:	9d e3 bf 90 	save  %sp, -112, %sp                           
                                                                      
  /*                                                                  
   *  Update the counts.                                              
   */                                                                 
  stats = &the_period->Statistics;                                    
  stats->count++;                                                     
4003773c:	c4 06 20 58 	ld  [ %i0 + 0x58 ], %g2                        
                                                                      
  if ( the_period->state == RATE_MONOTONIC_EXPIRED )                  
40037740:	c2 06 20 38 	ld  [ %i0 + 0x38 ], %g1                        
                                                                      
  /*                                                                  
   *  Update the counts.                                              
   */                                                                 
  stats = &the_period->Statistics;                                    
  stats->count++;                                                     
40037744:	84 00 a0 01 	inc  %g2                                       
                                                                      
  if ( the_period->state == RATE_MONOTONIC_EXPIRED )                  
40037748:	80 a0 60 04 	cmp  %g1, 4                                    
4003774c:	02 80 00 32 	be  40037814 <_Rate_monotonic_Update_statistics+0xdc>
40037750:	c4 26 20 58 	st  %g2, [ %i0 + 0x58 ]                        
    stats->missed_count++;                                            
                                                                      
  /*                                                                  
   *  Grab status for time statistics.                                
   */                                                                 
  valid_status =                                                      
40037754:	90 10 00 18 	mov  %i0, %o0                                  
40037758:	92 07 bf f8 	add  %fp, -8, %o1                              
4003775c:	7f ff ff cc 	call  4003768c <_Rate_monotonic_Get_status>    
40037760:	94 07 bf f0 	add  %fp, -16, %o2                             
    _Rate_monotonic_Get_status( the_period, &since_last_period, &executed );
  if (!valid_status)                                                  
40037764:	80 8a 20 ff 	btst  0xff, %o0                                
40037768:	02 80 00 21 	be  400377ec <_Rate_monotonic_Update_statistics+0xb4>
4003776c:	c4 1f bf f0 	ldd  [ %fp + -16 ], %g2                        
static inline void _Timestamp64_implementation_Add_to(                
  Timestamp64_Control       *_time,                                   
  const Timestamp64_Control *_add                                     
)                                                                     
{                                                                     
  *_time += *_add;                                                    
40037770:	f8 1e 20 70 	ldd  [ %i0 + 0x70 ], %i4                       
   *  Update CPU time                                                 
   */                                                                 
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    _Timestamp_Add_to( &stats->total_cpu_time, &executed );           
                                                                      
    if ( _Timestamp_Less_than( &executed, &stats->min_cpu_time ) )    
40037774:	c2 06 20 60 	ld  [ %i0 + 0x60 ], %g1                        
40037778:	b6 87 40 03 	addcc  %i5, %g3, %i3                           
4003777c:	b4 47 00 02 	addx  %i4, %g2, %i2                            
40037780:	80 a0 40 02 	cmp  %g1, %g2                                  
40037784:	04 80 00 1c 	ble  400377f4 <_Rate_monotonic_Update_statistics+0xbc>
40037788:	f4 3e 20 70 	std  %i2, [ %i0 + 0x70 ]                       
      stats->min_cpu_time = executed;                                 
4003778c:	c4 3e 20 60 	std  %g2, [ %i0 + 0x60 ]                       
                                                                      
    if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) ) 
40037790:	c2 06 20 68 	ld  [ %i0 + 0x68 ], %g1                        
40037794:	80 a0 40 02 	cmp  %g1, %g2                                  
40037798:	26 80 00 05 	bl,a   400377ac <_Rate_monotonic_Update_statistics+0x74><== NEVER TAKEN
4003779c:	c4 3e 20 68 	std  %g2, [ %i0 + 0x68 ]                       <== NOT EXECUTED
400377a0:	80 a0 40 02 	cmp  %g1, %g2                                  
400377a4:	22 80 00 28 	be,a   40037844 <_Rate_monotonic_Update_statistics+0x10c><== ALWAYS TAKEN
400377a8:	c2 06 20 6c 	ld  [ %i0 + 0x6c ], %g1                        
                                                                      
  /*                                                                  
   *  Update Wall time                                                
   */                                                                 
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    _Timestamp_Add_to( &stats->total_wall_time, &since_last_period ); 
400377ac:	c4 1f bf f8 	ldd  [ %fp + -8 ], %g2                         
400377b0:	f8 1e 20 88 	ldd  [ %i0 + 0x88 ], %i4                       
                                                                      
    if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) )
400377b4:	c2 06 20 78 	ld  [ %i0 + 0x78 ], %g1                        
400377b8:	b6 87 40 03 	addcc  %i5, %g3, %i3                           
400377bc:	b4 47 00 02 	addx  %i4, %g2, %i2                            
400377c0:	80 a0 40 02 	cmp  %g1, %g2                                  
400377c4:	14 80 00 1b 	bg  40037830 <_Rate_monotonic_Update_statistics+0xf8>
400377c8:	f4 3e 20 88 	std  %i2, [ %i0 + 0x88 ]                       
400377cc:	80 a0 40 02 	cmp  %g1, %g2                                  
400377d0:	22 80 00 15 	be,a   40037824 <_Rate_monotonic_Update_statistics+0xec><== ALWAYS TAKEN
400377d4:	c2 06 20 7c 	ld  [ %i0 + 0x7c ], %g1                        
      stats->min_wall_time = since_last_period;                       
                                                                      
    if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) )
400377d8:	c2 06 20 80 	ld  [ %i0 + 0x80 ], %g1                        <== NOT EXECUTED
400377dc:	80 a0 40 02 	cmp  %g1, %g2                                  
400377e0:	16 80 00 1e 	bge  40037858 <_Rate_monotonic_Update_statistics+0x120><== ALWAYS TAKEN
400377e4:	01 00 00 00 	nop                                            
      stats->max_wall_time = since_last_period;                       
400377e8:	c4 3e 20 80 	std  %g2, [ %i0 + 0x80 ]                       <== NOT EXECUTED
400377ec:	81 c7 e0 08 	ret                                            
400377f0:	81 e8 00 00 	restore                                        
   *  Update CPU time                                                 
   */                                                                 
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    _Timestamp_Add_to( &stats->total_cpu_time, &executed );           
                                                                      
    if ( _Timestamp_Less_than( &executed, &stats->min_cpu_time ) )    
400377f4:	32 bf ff e8 	bne,a   40037794 <_Rate_monotonic_Update_statistics+0x5c><== NEVER TAKEN
400377f8:	c2 06 20 68 	ld  [ %i0 + 0x68 ], %g1                        <== NOT EXECUTED
400377fc:	c2 06 20 64 	ld  [ %i0 + 0x64 ], %g1                        
40037800:	80 a0 40 03 	cmp  %g1, %g3                                  
40037804:	28 bf ff e4 	bleu,a   40037794 <_Rate_monotonic_Update_statistics+0x5c>
40037808:	c2 06 20 68 	ld  [ %i0 + 0x68 ], %g1                        
      stats->min_cpu_time = executed;                                 
4003780c:	10 bf ff e1 	b  40037790 <_Rate_monotonic_Update_statistics+0x58>
40037810:	c4 3e 20 60 	std  %g2, [ %i0 + 0x60 ]                       
   */                                                                 
  stats = &the_period->Statistics;                                    
  stats->count++;                                                     
                                                                      
  if ( the_period->state == RATE_MONOTONIC_EXPIRED )                  
    stats->missed_count++;                                            
40037814:	c2 06 20 5c 	ld  [ %i0 + 0x5c ], %g1                        
40037818:	82 00 60 01 	inc  %g1                                       
4003781c:	10 bf ff ce 	b  40037754 <_Rate_monotonic_Update_statistics+0x1c>
40037820:	c2 26 20 5c 	st  %g1, [ %i0 + 0x5c ]                        
   *  Update Wall time                                                
   */                                                                 
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    _Timestamp_Add_to( &stats->total_wall_time, &since_last_period ); 
                                                                      
    if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) )
40037824:	80 a0 40 03 	cmp  %g1, %g3                                  
40037828:	28 bf ff ed 	bleu,a   400377dc <_Rate_monotonic_Update_statistics+0xa4>
4003782c:	c2 06 20 80 	ld  [ %i0 + 0x80 ], %g1                        
      stats->min_wall_time = since_last_period;                       
                                                                      
    if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) )
40037830:	c2 06 20 80 	ld  [ %i0 + 0x80 ], %g1                        
40037834:	80 a0 40 02 	cmp  %g1, %g2                                  
40037838:	06 bf ff ec 	bl  400377e8 <_Rate_monotonic_Update_statistics+0xb0><== NEVER TAKEN
4003783c:	c4 3e 20 78 	std  %g2, [ %i0 + 0x78 ]                       
40037840:	30 80 00 06 	b,a   40037858 <_Rate_monotonic_Update_statistics+0x120>
    _Timestamp_Add_to( &stats->total_cpu_time, &executed );           
                                                                      
    if ( _Timestamp_Less_than( &executed, &stats->min_cpu_time ) )    
      stats->min_cpu_time = executed;                                 
                                                                      
    if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) ) 
40037844:	80 a0 40 03 	cmp  %g1, %g3                                  
40037848:	3a bf ff da 	bcc,a   400377b0 <_Rate_monotonic_Update_statistics+0x78>
4003784c:	c4 1f bf f8 	ldd  [ %fp + -8 ], %g2                         
      stats->max_cpu_time = executed;                                 
40037850:	10 bf ff d7 	b  400377ac <_Rate_monotonic_Update_statistics+0x74>
40037854:	c4 3e 20 68 	std  %g2, [ %i0 + 0x68 ]                       
    _Timestamp_Add_to( &stats->total_wall_time, &since_last_period ); 
                                                                      
    if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) )
      stats->min_wall_time = since_last_period;                       
                                                                      
    if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) )
40037858:	12 bf ff e5 	bne  400377ec <_Rate_monotonic_Update_statistics+0xb4><== NEVER TAKEN
4003785c:	01 00 00 00 	nop                                            
40037860:	c2 06 20 84 	ld  [ %i0 + 0x84 ], %g1                        
40037864:	80 a0 40 03 	cmp  %g1, %g3                                  
40037868:	2a bf ff e1 	bcs,a   400377ec <_Rate_monotonic_Update_statistics+0xb4>
4003786c:	c4 3e 20 80 	std  %g2, [ %i0 + 0x80 ]                       
40037870:	30 bf ff df 	b,a   400377ec <_Rate_monotonic_Update_statistics+0xb4>
                                                                      

40009dbc <_Scheduler_CBS_Allocate>: #include <rtems/score/wkspace.h> void *_Scheduler_CBS_Allocate( Thread_Control *the_thread ) {
40009dbc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  void *sched;                                                        
  Scheduler_CBS_Per_thread *schinfo;                                  
                                                                      
  sched = _Workspace_Allocate(sizeof(Scheduler_CBS_Per_thread));      
40009dc0:	40 00 07 11 	call  4000ba04 <_Workspace_Allocate>           
40009dc4:	90 10 20 1c 	mov  0x1c, %o0                                 
  if ( sched ) {                                                      
40009dc8:	80 a2 20 00 	cmp  %o0, 0                                    
40009dcc:	02 80 00 06 	be  40009de4 <_Scheduler_CBS_Allocate+0x28>    <== NEVER TAKEN
40009dd0:	82 10 20 02 	mov  2, %g1                                    
    the_thread->scheduler_info = sched;                               
40009dd4:	d0 26 20 88 	st  %o0, [ %i0 + 0x88 ]                        
    schinfo = (Scheduler_CBS_Per_thread *)(the_thread->scheduler_info);
    schinfo->edf_per_thread.thread = the_thread;                      
40009dd8:	f0 22 00 00 	st  %i0, [ %o0 ]                               
    schinfo->edf_per_thread.queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN;
40009ddc:	c2 22 20 14 	st  %g1, [ %o0 + 0x14 ]                        
    schinfo->cbs_server = NULL;                                       
40009de0:	c0 22 20 18 	clr  [ %o0 + 0x18 ]                            
  }                                                                   
                                                                      
  return sched;                                                       
}                                                                     
40009de4:	81 c7 e0 08 	ret                                            
40009de8:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

4000b190 <_Scheduler_CBS_Budget_callout>: Scheduler_CBS_Server **_Scheduler_CBS_Server_list; void _Scheduler_CBS_Budget_callout( Thread_Control *the_thread ) {
4000b190:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Priority_Control          new_priority;                             
  Scheduler_CBS_Per_thread *sched_info;                               
  Scheduler_CBS_Server_id   server_id;                                
                                                                      
  /* Put violating task to background until the end of period. */     
  new_priority = the_thread->Start.initial_priority;                  
4000b194:	d2 06 20 ac 	ld  [ %i0 + 0xac ], %o1                        
  if ( the_thread->real_priority != new_priority )                    
4000b198:	c2 06 20 18 	ld  [ %i0 + 0x18 ], %g1                        
4000b19c:	80 a0 40 09 	cmp  %g1, %o1                                  
4000b1a0:	32 80 00 02 	bne,a   4000b1a8 <_Scheduler_CBS_Budget_callout+0x18><== ALWAYS TAKEN
4000b1a4:	d2 26 20 18 	st  %o1, [ %i0 + 0x18 ]                        
    the_thread->real_priority = new_priority;                         
  if ( the_thread->current_priority != new_priority )                 
4000b1a8:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
4000b1ac:	80 a0 40 09 	cmp  %g1, %o1                                  
4000b1b0:	02 80 00 04 	be  4000b1c0 <_Scheduler_CBS_Budget_callout+0x30><== NEVER TAKEN
4000b1b4:	90 10 00 18 	mov  %i0, %o0                                  
    _Thread_Change_priority(the_thread, new_priority, true);          
4000b1b8:	40 00 01 92 	call  4000b800 <_Thread_Change_priority>       
4000b1bc:	94 10 20 01 	mov  1, %o2                                    
                                                                      
  /* Invoke callback function if any. */                              
  sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
4000b1c0:	fa 06 20 88 	ld  [ %i0 + 0x88 ], %i5                        
  if ( sched_info->cbs_server->cbs_budget_overrun ) {                 
4000b1c4:	c2 07 60 18 	ld  [ %i5 + 0x18 ], %g1                        
4000b1c8:	c4 00 60 0c 	ld  [ %g1 + 0xc ], %g2                         
4000b1cc:	80 a0 a0 00 	cmp  %g2, 0                                    
4000b1d0:	02 80 00 09 	be  4000b1f4 <_Scheduler_CBS_Budget_callout+0x64><== NEVER TAKEN
4000b1d4:	01 00 00 00 	nop                                            
    _Scheduler_CBS_Get_server_id(                                     
4000b1d8:	d0 00 40 00 	ld  [ %g1 ], %o0                               
4000b1dc:	7f ff ff d5 	call  4000b130 <_Scheduler_CBS_Get_server_id>  
4000b1e0:	92 07 bf fc 	add  %fp, -4, %o1                              
        sched_info->cbs_server->task_id,                              
        &server_id                                                    
    );                                                                
    sched_info->cbs_server->cbs_budget_overrun( server_id );          
4000b1e4:	c2 07 60 18 	ld  [ %i5 + 0x18 ], %g1                        
4000b1e8:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
4000b1ec:	9f c0 40 00 	call  %g1                                      
4000b1f0:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
4000b1f4:	81 c7 e0 08 	ret                                            
4000b1f8:	81 e8 00 00 	restore                                        
                                                                      

4000ace8 <_Scheduler_CBS_Cleanup>: #include <rtems/config.h> #include <rtems/score/scheduler.h> #include <rtems/score/schedulercbs.h> int _Scheduler_CBS_Cleanup (void) {
4000ace8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  unsigned int i;                                                     
                                                                      
  for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {              
4000acec:	39 10 00 86 	sethi  %hi(0x40021800), %i4                    
4000acf0:	c2 07 23 20 	ld  [ %i4 + 0x320 ], %g1	! 40021b20 <_Scheduler_CBS_Maximum_servers>
4000acf4:	80 a0 60 00 	cmp  %g1, 0                                    
4000acf8:	02 80 00 18 	be  4000ad58 <_Scheduler_CBS_Cleanup+0x70>     <== NEVER TAKEN
4000acfc:	03 10 00 8b 	sethi  %hi(0x40022c00), %g1                    
4000ad00:	37 10 00 8b 	sethi  %hi(0x40022c00), %i3                    
4000ad04:	c4 06 e0 38 	ld  [ %i3 + 0x38 ], %g2	! 40022c38 <_Scheduler_CBS_Server_list>
4000ad08:	ba 10 20 00 	clr  %i5                                       
4000ad0c:	b8 17 23 20 	or  %i4, 0x320, %i4                            
    if ( _Scheduler_CBS_Server_list[ i ] )                            
4000ad10:	83 2f 60 02 	sll  %i5, 2, %g1                               
4000ad14:	c2 00 80 01 	ld  [ %g2 + %g1 ], %g1                         
4000ad18:	80 a0 60 00 	cmp  %g1, 0                                    
4000ad1c:	02 80 00 05 	be  4000ad30 <_Scheduler_CBS_Cleanup+0x48>     
4000ad20:	90 10 00 1d 	mov  %i5, %o0                                  
      _Scheduler_CBS_Destroy_server( i );                             
4000ad24:	40 00 00 46 	call  4000ae3c <_Scheduler_CBS_Destroy_server> 
4000ad28:	01 00 00 00 	nop                                            
4000ad2c:	c4 06 e0 38 	ld  [ %i3 + 0x38 ], %g2                        
                                                                      
int _Scheduler_CBS_Cleanup (void)                                     
{                                                                     
  unsigned int i;                                                     
                                                                      
  for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {              
4000ad30:	c2 07 00 00 	ld  [ %i4 ], %g1                               
4000ad34:	ba 07 60 01 	inc  %i5                                       
4000ad38:	80 a0 40 1d 	cmp  %g1, %i5                                  
4000ad3c:	18 bf ff f6 	bgu  4000ad14 <_Scheduler_CBS_Cleanup+0x2c>    
4000ad40:	83 2f 60 02 	sll  %i5, 2, %g1                               
    if ( _Scheduler_CBS_Server_list[ i ] )                            
      _Scheduler_CBS_Destroy_server( i );                             
  }                                                                   
  _Workspace_Free( _Scheduler_CBS_Server_list );                      
  return SCHEDULER_CBS_OK;                                            
}                                                                     
4000ad44:	b0 10 20 00 	clr  %i0                                       
                                                                      
  for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {              
    if ( _Scheduler_CBS_Server_list[ i ] )                            
      _Scheduler_CBS_Destroy_server( i );                             
  }                                                                   
  _Workspace_Free( _Scheduler_CBS_Server_list );                      
4000ad48:	40 00 08 41 	call  4000ce4c <_Workspace_Free>               
4000ad4c:	90 10 00 02 	mov  %g2, %o0                                  
  return SCHEDULER_CBS_OK;                                            
}                                                                     
4000ad50:	81 c7 e0 08 	ret                                            
4000ad54:	81 e8 00 00 	restore                                        
4000ad58:	10 bf ff fb 	b  4000ad44 <_Scheduler_CBS_Cleanup+0x5c>      <== NOT EXECUTED
4000ad5c:	c4 00 60 38 	ld  [ %g1 + 0x38 ], %g2                        <== NOT EXECUTED
                                                                      

4000ad60 <_Scheduler_CBS_Create_server>: int _Scheduler_CBS_Create_server ( Scheduler_CBS_Parameters *params, Scheduler_CBS_Budget_overrun budget_overrun_callback, rtems_id *server_id ) {
4000ad60:	9d e3 bf a0 	save  %sp, -96, %sp                            
  unsigned int i;                                                     
  Scheduler_CBS_Server *the_server;                                   
                                                                      
  if ( params->budget <= 0 ||                                         
4000ad64:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
4000ad68:	80 a0 60 00 	cmp  %g1, 0                                    
4000ad6c:	04 80 00 30 	ble  4000ae2c <_Scheduler_CBS_Create_server+0xcc>
4000ad70:	b8 10 00 18 	mov  %i0, %i4                                  
4000ad74:	c2 06 00 00 	ld  [ %i0 ], %g1                               
4000ad78:	80 a0 60 00 	cmp  %g1, 0                                    
4000ad7c:	04 80 00 2c 	ble  4000ae2c <_Scheduler_CBS_Create_server+0xcc>
4000ad80:	03 10 00 86 	sethi  %hi(0x40021800), %g1                    
       params->deadline <= 0 ||                                       
       params->budget >= SCHEDULER_EDF_PRIO_MSB ||                    
       params->deadline >= SCHEDULER_EDF_PRIO_MSB )                   
    return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;                     
                                                                      
  for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {              
4000ad84:	c8 00 63 20 	ld  [ %g1 + 0x320 ], %g4	! 40021b20 <_Scheduler_CBS_Maximum_servers>
4000ad88:	80 a1 20 00 	cmp  %g4, 0                                    
4000ad8c:	02 80 00 11 	be  4000add0 <_Scheduler_CBS_Create_server+0x70><== NEVER TAKEN
4000ad90:	37 10 00 8b 	sethi  %hi(0x40022c00), %i3                    
    if ( !_Scheduler_CBS_Server_list[i] )                             
4000ad94:	fa 06 e0 38 	ld  [ %i3 + 0x38 ], %i5	! 40022c38 <_Scheduler_CBS_Server_list>
4000ad98:	c2 07 40 00 	ld  [ %i5 ], %g1                               
4000ad9c:	80 a0 60 00 	cmp  %g1, 0                                    
4000ada0:	02 80 00 21 	be  4000ae24 <_Scheduler_CBS_Create_server+0xc4>
4000ada4:	b0 10 20 00 	clr  %i0                                       
4000ada8:	10 80 00 06 	b  4000adc0 <_Scheduler_CBS_Create_server+0x60>
4000adac:	82 10 20 00 	clr  %g1                                       
4000adb0:	c6 07 40 02 	ld  [ %i5 + %g2 ], %g3                         
4000adb4:	80 a0 e0 00 	cmp  %g3, 0                                    
4000adb8:	02 80 00 08 	be  4000add8 <_Scheduler_CBS_Create_server+0x78>
4000adbc:	b0 10 00 02 	mov  %g2, %i0                                  
       params->deadline <= 0 ||                                       
       params->budget >= SCHEDULER_EDF_PRIO_MSB ||                    
       params->deadline >= SCHEDULER_EDF_PRIO_MSB )                   
    return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;                     
                                                                      
  for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {              
4000adc0:	82 00 60 01 	inc  %g1                                       
4000adc4:	80 a0 40 04 	cmp  %g1, %g4                                  
4000adc8:	12 bf ff fa 	bne  4000adb0 <_Scheduler_CBS_Create_server+0x50>
4000adcc:	85 28 60 02 	sll  %g1, 2, %g2                               
    if ( !_Scheduler_CBS_Server_list[i] )                             
      break;                                                          
  }                                                                   
                                                                      
  if ( i == _Scheduler_CBS_Maximum_servers )                          
    return SCHEDULER_CBS_ERROR_FULL;                                  
4000add0:	81 c7 e0 08 	ret                                            
4000add4:	91 e8 3f e6 	restore  %g0, -26, %o0                         
                                                                      
  *server_id = i;                                                     
4000add8:	c2 26 80 00 	st  %g1, [ %i2 ]                               
  _Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)   
    _Workspace_Allocate( sizeof(Scheduler_CBS_Server) );              
4000addc:	40 00 08 14 	call  4000ce2c <_Workspace_Allocate>           
4000ade0:	90 10 20 10 	mov  0x10, %o0                                 
  the_server = _Scheduler_CBS_Server_list[*server_id];                
4000ade4:	c2 06 80 00 	ld  [ %i2 ], %g1                               
                                                                      
  if ( i == _Scheduler_CBS_Maximum_servers )                          
    return SCHEDULER_CBS_ERROR_FULL;                                  
                                                                      
  *server_id = i;                                                     
  _Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)   
4000ade8:	d0 27 40 18 	st  %o0, [ %i5 + %i0 ]                         
    _Workspace_Allocate( sizeof(Scheduler_CBS_Server) );              
  the_server = _Scheduler_CBS_Server_list[*server_id];                
4000adec:	c4 06 e0 38 	ld  [ %i3 + 0x38 ], %g2                        
4000adf0:	83 28 60 02 	sll  %g1, 2, %g1                               
4000adf4:	c2 00 80 01 	ld  [ %g2 + %g1 ], %g1                         
  if ( !the_server )                                                  
4000adf8:	80 a0 60 00 	cmp  %g1, 0                                    
4000adfc:	02 80 00 0e 	be  4000ae34 <_Scheduler_CBS_Create_server+0xd4><== NEVER TAKEN
4000ae00:	86 10 3f ff 	mov  -1, %g3                                   
    return SCHEDULER_CBS_ERROR_NO_MEMORY;                             
                                                                      
  the_server->parameters = *params;                                   
4000ae04:	c4 07 00 00 	ld  [ %i4 ], %g2                               
4000ae08:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
4000ae0c:	c4 07 20 04 	ld  [ %i4 + 4 ], %g2                           
  the_server->task_id = -1;                                           
4000ae10:	c6 20 40 00 	st  %g3, [ %g1 ]                               
    _Workspace_Allocate( sizeof(Scheduler_CBS_Server) );              
  the_server = _Scheduler_CBS_Server_list[*server_id];                
  if ( !the_server )                                                  
    return SCHEDULER_CBS_ERROR_NO_MEMORY;                             
                                                                      
  the_server->parameters = *params;                                   
4000ae14:	c4 20 60 08 	st  %g2, [ %g1 + 8 ]                           
  the_server->task_id = -1;                                           
  the_server->cbs_budget_overrun = budget_overrun_callback;           
4000ae18:	f2 20 60 0c 	st  %i1, [ %g1 + 0xc ]                         
  return SCHEDULER_CBS_OK;                                            
4000ae1c:	81 c7 e0 08 	ret                                            
4000ae20:	91 e8 20 00 	restore  %g0, 0, %o0                           
       params->budget >= SCHEDULER_EDF_PRIO_MSB ||                    
       params->deadline >= SCHEDULER_EDF_PRIO_MSB )                   
    return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;                     
                                                                      
  for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {              
    if ( !_Scheduler_CBS_Server_list[i] )                             
4000ae24:	10 bf ff ed 	b  4000add8 <_Scheduler_CBS_Create_server+0x78>
4000ae28:	82 10 20 00 	clr  %g1                                       
                                                                      
  if ( params->budget <= 0 ||                                         
       params->deadline <= 0 ||                                       
       params->budget >= SCHEDULER_EDF_PRIO_MSB ||                    
       params->deadline >= SCHEDULER_EDF_PRIO_MSB )                   
    return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;                     
4000ae2c:	81 c7 e0 08 	ret                                            
4000ae30:	91 e8 3f ee 	restore  %g0, -18, %o0                         
                                                                      
  the_server->parameters = *params;                                   
  the_server->task_id = -1;                                           
  the_server->cbs_budget_overrun = budget_overrun_callback;           
  return SCHEDULER_CBS_OK;                                            
}                                                                     
4000ae34:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000ae38:	91 e8 3f ef 	restore  %g0, -17, %o0                         <== NOT EXECUTED
                                                                      

4000aebc <_Scheduler_CBS_Detach_thread>: int _Scheduler_CBS_Detach_thread ( Scheduler_CBS_Server_id server_id, rtems_id task_id ) {
4000aebc:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Objects_Locations location;                                         
  Thread_Control *the_thread;                                         
  Scheduler_CBS_Per_thread *sched_info;                               
                                                                      
  the_thread = _Thread_Get(task_id, &location);                       
4000aec0:	92 07 bf fc 	add  %fp, -4, %o1                              
4000aec4:	40 00 03 95 	call  4000bd18 <_Thread_Get>                   
4000aec8:	90 10 00 19 	mov  %i1, %o0                                  
  /* The routine _Thread_Get may disable dispatch and not enable again. */
  if ( the_thread ) {                                                 
4000aecc:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4000aed0:	02 80 00 1e 	be  4000af48 <_Scheduler_CBS_Detach_thread+0x8c>
4000aed4:	01 00 00 00 	nop                                            
    _Thread_Enable_dispatch();                                        
4000aed8:	40 00 03 84 	call  4000bce8 <_Thread_Enable_dispatch>       
4000aedc:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  if ( server_id >= _Scheduler_CBS_Maximum_servers )                  
4000aee0:	03 10 00 86 	sethi  %hi(0x40021800), %g1                    
4000aee4:	c2 00 63 20 	ld  [ %g1 + 0x320 ], %g1	! 40021b20 <_Scheduler_CBS_Maximum_servers>
4000aee8:	80 a6 00 01 	cmp  %i0, %g1                                  
4000aeec:	1a 80 00 17 	bcc  4000af48 <_Scheduler_CBS_Detach_thread+0x8c>
4000aef0:	03 10 00 8b 	sethi  %hi(0x40022c00), %g1                    
    return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;                     
  if ( !the_thread )                                                  
    return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;                     
  /* Server is not valid. */                                          
  if ( !_Scheduler_CBS_Server_list[server_id] )                       
4000aef4:	c2 00 60 38 	ld  [ %g1 + 0x38 ], %g1	! 40022c38 <_Scheduler_CBS_Server_list>
4000aef8:	b1 2e 20 02 	sll  %i0, 2, %i0                               
4000aefc:	c2 00 40 18 	ld  [ %g1 + %i0 ], %g1                         
4000af00:	80 a0 60 00 	cmp  %g1, 0                                    
4000af04:	02 80 00 13 	be  4000af50 <_Scheduler_CBS_Detach_thread+0x94>
4000af08:	01 00 00 00 	nop                                            
    return SCHEDULER_CBS_ERROR_NOSERVER;                              
  /* Thread and server are not attached. */                           
  if ( _Scheduler_CBS_Server_list[server_id]->task_id != task_id )    
4000af0c:	c4 00 40 00 	ld  [ %g1 ], %g2                               
4000af10:	80 a0 80 19 	cmp  %g2, %i1                                  
4000af14:	12 80 00 0d 	bne  4000af48 <_Scheduler_CBS_Detach_thread+0x8c><== NEVER TAKEN
4000af18:	84 10 3f ff 	mov  -1, %g2                                   
    return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;                     
                                                                      
  _Scheduler_CBS_Server_list[server_id]->task_id = -1;                
  sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
  sched_info->cbs_server = NULL;                                      
4000af1c:	c8 07 60 88 	ld  [ %i5 + 0x88 ], %g4                        
                                                                      
  the_thread->budget_algorithm = the_thread->Start.budget_algorithm;  
4000af20:	c6 07 60 a0 	ld  [ %i5 + 0xa0 ], %g3                        
    return SCHEDULER_CBS_ERROR_NOSERVER;                              
  /* Thread and server are not attached. */                           
  if ( _Scheduler_CBS_Server_list[server_id]->task_id != task_id )    
    return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;                     
                                                                      
  _Scheduler_CBS_Server_list[server_id]->task_id = -1;                
4000af24:	c4 20 40 00 	st  %g2, [ %g1 ]                               
  sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
  sched_info->cbs_server = NULL;                                      
                                                                      
  the_thread->budget_algorithm = the_thread->Start.budget_algorithm;  
  the_thread->budget_callout   = the_thread->Start.budget_callout;    
4000af28:	c4 07 60 a4 	ld  [ %i5 + 0xa4 ], %g2                        
  the_thread->is_preemptible   = the_thread->Start.is_preemptible;    
4000af2c:	c2 0f 60 9c 	ldub  [ %i5 + 0x9c ], %g1                      
  if ( _Scheduler_CBS_Server_list[server_id]->task_id != task_id )    
    return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;                     
                                                                      
  _Scheduler_CBS_Server_list[server_id]->task_id = -1;                
  sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
  sched_info->cbs_server = NULL;                                      
4000af30:	c0 21 20 18 	clr  [ %g4 + 0x18 ]                            
                                                                      
  the_thread->budget_algorithm = the_thread->Start.budget_algorithm;  
4000af34:	c6 27 60 78 	st  %g3, [ %i5 + 0x78 ]                        
  the_thread->budget_callout   = the_thread->Start.budget_callout;    
4000af38:	c4 27 60 7c 	st  %g2, [ %i5 + 0x7c ]                        
  the_thread->is_preemptible   = the_thread->Start.is_preemptible;    
4000af3c:	c2 2f 60 70 	stb  %g1, [ %i5 + 0x70 ]                       
                                                                      
  return SCHEDULER_CBS_OK;                                            
4000af40:	81 c7 e0 08 	ret                                            
4000af44:	91 e8 20 00 	restore  %g0, 0, %o0                           
  if ( the_thread ) {                                                 
    _Thread_Enable_dispatch();                                        
  }                                                                   
                                                                      
  if ( server_id >= _Scheduler_CBS_Maximum_servers )                  
    return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;                     
4000af48:	81 c7 e0 08 	ret                                            
4000af4c:	91 e8 3f ee 	restore  %g0, -18, %o0                         
  the_thread->budget_algorithm = the_thread->Start.budget_algorithm;  
  the_thread->budget_callout   = the_thread->Start.budget_callout;    
  the_thread->is_preemptible   = the_thread->Start.is_preemptible;    
                                                                      
  return SCHEDULER_CBS_OK;                                            
}                                                                     
4000af50:	81 c7 e0 08 	ret                                            
4000af54:	91 e8 3f e7 	restore  %g0, -25, %o0                         
                                                                      

4000b130 <_Scheduler_CBS_Get_server_id>: rtems_id task_id, Scheduler_CBS_Server_id *server_id ) { unsigned int i; for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
4000b130:	03 10 00 86 	sethi  %hi(0x40021800), %g1                    
4000b134:	c6 00 63 20 	ld  [ %g1 + 0x320 ], %g3	! 40021b20 <_Scheduler_CBS_Maximum_servers>
4000b138:	80 a0 e0 00 	cmp  %g3, 0                                    
4000b13c:	02 80 00 11 	be  4000b180 <_Scheduler_CBS_Get_server_id+0x50><== NEVER TAKEN
4000b140:	03 10 00 8b 	sethi  %hi(0x40022c00), %g1                    
4000b144:	c8 00 60 38 	ld  [ %g1 + 0x38 ], %g4	! 40022c38 <_Scheduler_CBS_Server_list>
4000b148:	82 10 20 00 	clr  %g1                                       
#include <rtems/system.h>                                             
#include <rtems/config.h>                                             
#include <rtems/score/scheduler.h>                                    
#include <rtems/score/schedulercbs.h>                                 
                                                                      
int _Scheduler_CBS_Get_server_id (                                    
4000b14c:	85 28 60 02 	sll  %g1, 2, %g2                               
  Scheduler_CBS_Server_id *server_id                                  
)                                                                     
{                                                                     
  unsigned int i;                                                     
  for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {              
    if ( _Scheduler_CBS_Server_list[i] &&                             
4000b150:	c4 01 00 02 	ld  [ %g4 + %g2 ], %g2                         
4000b154:	80 a0 a0 00 	cmp  %g2, 0                                    
4000b158:	22 80 00 07 	be,a   4000b174 <_Scheduler_CBS_Get_server_id+0x44>
4000b15c:	82 00 60 01 	inc  %g1                                       
4000b160:	c4 00 80 00 	ld  [ %g2 ], %g2                               
4000b164:	80 a0 80 08 	cmp  %g2, %o0                                  
4000b168:	22 80 00 08 	be,a   4000b188 <_Scheduler_CBS_Get_server_id+0x58>
4000b16c:	c2 22 40 00 	st  %g1, [ %o1 ]                               
  rtems_id                 task_id,                                   
  Scheduler_CBS_Server_id *server_id                                  
)                                                                     
{                                                                     
  unsigned int i;                                                     
  for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {              
4000b170:	82 00 60 01 	inc  %g1                                       
4000b174:	80 a0 40 03 	cmp  %g1, %g3                                  
4000b178:	12 bf ff f6 	bne  4000b150 <_Scheduler_CBS_Get_server_id+0x20>
4000b17c:	85 28 60 02 	sll  %g1, 2, %g2                               
      *server_id = i;                                                 
      return SCHEDULER_CBS_OK;                                        
    }                                                                 
  }                                                                   
  return SCHEDULER_CBS_ERROR_NOSERVER;                                
}                                                                     
4000b180:	81 c3 e0 08 	retl                                           
4000b184:	90 10 3f e7 	mov  -25, %o0                                  
  unsigned int i;                                                     
  for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {              
    if ( _Scheduler_CBS_Server_list[i] &&                             
         _Scheduler_CBS_Server_list[i]->task_id == task_id ) {        
      *server_id = i;                                                 
      return SCHEDULER_CBS_OK;                                        
4000b188:	81 c3 e0 08 	retl                                           
4000b18c:	90 10 20 00 	clr  %o0                                       
                                                                      

4000b1fc <_Scheduler_CBS_Initialize>: } } int _Scheduler_CBS_Initialize(void) {
4000b1fc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  unsigned int i;                                                     
  _Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
      _Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
4000b200:	3b 10 00 86 	sethi  %hi(0x40021800), %i5                    
4000b204:	d0 07 63 20 	ld  [ %i5 + 0x320 ], %o0	! 40021b20 <_Scheduler_CBS_Maximum_servers>
}                                                                     
                                                                      
int _Scheduler_CBS_Initialize(void)                                   
{                                                                     
  unsigned int i;                                                     
  _Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
4000b208:	40 00 07 09 	call  4000ce2c <_Workspace_Allocate>           
4000b20c:	91 2a 20 02 	sll  %o0, 2, %o0                               
4000b210:	09 10 00 8b 	sethi  %hi(0x40022c00), %g4                    
      _Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
  if ( !_Scheduler_CBS_Server_list )                                  
4000b214:	80 a2 20 00 	cmp  %o0, 0                                    
4000b218:	02 80 00 10 	be  4000b258 <_Scheduler_CBS_Initialize+0x5c>  <== NEVER TAKEN
4000b21c:	d0 21 20 38 	st  %o0, [ %g4 + 0x38 ]                        
    return SCHEDULER_CBS_ERROR_NO_MEMORY;                             
  for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {                
4000b220:	c6 07 63 20 	ld  [ %i5 + 0x320 ], %g3                       
4000b224:	80 a0 e0 00 	cmp  %g3, 0                                    
4000b228:	12 80 00 05 	bne  4000b23c <_Scheduler_CBS_Initialize+0x40> <== ALWAYS TAKEN
4000b22c:	82 10 20 00 	clr  %g1                                       
    _Scheduler_CBS_Server_list[i] = NULL;                             
  }                                                                   
  return SCHEDULER_CBS_OK;                                            
4000b230:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000b234:	91 e8 20 00 	restore  %g0, 0, %o0                           <== NOT EXECUTED
4000b238:	d0 01 20 38 	ld  [ %g4 + 0x38 ], %o0                        
  _Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
      _Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
  if ( !_Scheduler_CBS_Server_list )                                  
    return SCHEDULER_CBS_ERROR_NO_MEMORY;                             
  for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {                
    _Scheduler_CBS_Server_list[i] = NULL;                             
4000b23c:	85 28 60 02 	sll  %g1, 2, %g2                               
  unsigned int i;                                                     
  _Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
      _Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
  if ( !_Scheduler_CBS_Server_list )                                  
    return SCHEDULER_CBS_ERROR_NO_MEMORY;                             
  for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {                
4000b240:	82 00 60 01 	inc  %g1                                       
4000b244:	80 a0 40 03 	cmp  %g1, %g3                                  
4000b248:	12 bf ff fc 	bne  4000b238 <_Scheduler_CBS_Initialize+0x3c> 
4000b24c:	c0 22 00 02 	clr  [ %o0 + %g2 ]                             
    _Scheduler_CBS_Server_list[i] = NULL;                             
  }                                                                   
  return SCHEDULER_CBS_OK;                                            
4000b250:	81 c7 e0 08 	ret                                            
4000b254:	91 e8 20 00 	restore  %g0, 0, %o0                           
{                                                                     
  unsigned int i;                                                     
  _Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
      _Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
  if ( !_Scheduler_CBS_Server_list )                                  
    return SCHEDULER_CBS_ERROR_NO_MEMORY;                             
4000b258:	b0 10 3f ef 	mov  -17, %i0                                  <== NOT EXECUTED
  for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {                
    _Scheduler_CBS_Server_list[i] = NULL;                             
  }                                                                   
  return SCHEDULER_CBS_OK;                                            
}                                                                     
4000b25c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000b260:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40009dec <_Scheduler_CBS_Release_job>: { Priority_Control new_priority; Scheduler_CBS_Per_thread *sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info; Scheduler_CBS_Server *serv_info = (Scheduler_CBS_Server *) sched_info->cbs_server;
40009dec:	c2 02 20 88 	ld  [ %o0 + 0x88 ], %g1                        
                                                                      
  if (deadline) {                                                     
40009df0:	80 a2 60 00 	cmp  %o1, 0                                    
40009df4:	02 80 00 11 	be  40009e38 <_Scheduler_CBS_Release_job+0x4c> 
40009df8:	c2 00 60 18 	ld  [ %g1 + 0x18 ], %g1                        
    /* Initializing or shifting deadline. */                          
    if (serv_info)                                                    
40009dfc:	80 a0 60 00 	cmp  %g1, 0                                    
40009e00:	02 80 00 13 	be  40009e4c <_Scheduler_CBS_Release_job+0x60> 
40009e04:	07 10 00 83 	sethi  %hi(0x40020c00), %g3                    
      new_priority = (_Watchdog_Ticks_since_boot + serv_info->parameters.deadline)
40009e08:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
40009e0c:	d2 00 e0 08 	ld  [ %g3 + 8 ], %o1                           
40009e10:	92 02 40 02 	add  %o1, %g2, %o1                             
40009e14:	05 20 00 00 	sethi  %hi(0x80000000), %g2                    
40009e18:	92 2a 40 02 	andn  %o1, %g2, %o1                            
    new_priority = the_thread->Start.initial_priority;                
  }                                                                   
                                                                      
  /* Budget replenishment for the next job. */                        
  if (serv_info)                                                      
    the_thread->cpu_time_budget = serv_info->parameters.budget;       
40009e1c:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
40009e20:	c2 22 20 74 	st  %g1, [ %o0 + 0x74 ]                        
                                                                      
  the_thread->real_priority = new_priority;                           
40009e24:	d2 22 20 18 	st  %o1, [ %o0 + 0x18 ]                        
  _Thread_Change_priority(the_thread, new_priority, true);            
40009e28:	94 10 20 01 	mov  1, %o2                                    
40009e2c:	82 13 c0 00 	mov  %o7, %g1                                  
40009e30:	40 00 01 3a 	call  4000a318 <_Thread_Change_priority>       
40009e34:	9e 10 40 00 	mov  %g1, %o7                                  
    /* Switch back to background priority. */                         
    new_priority = the_thread->Start.initial_priority;                
  }                                                                   
                                                                      
  /* Budget replenishment for the next job. */                        
  if (serv_info)                                                      
40009e38:	80 a0 60 00 	cmp  %g1, 0                                    
40009e3c:	12 bf ff f8 	bne  40009e1c <_Scheduler_CBS_Release_job+0x30><== ALWAYS TAKEN
40009e40:	d2 02 20 ac 	ld  [ %o0 + 0xac ], %o1                        
    the_thread->cpu_time_budget = serv_info->parameters.budget;       
                                                                      
  the_thread->real_priority = new_priority;                           
40009e44:	10 bf ff f9 	b  40009e28 <_Scheduler_CBS_Release_job+0x3c>  <== NOT EXECUTED
40009e48:	d2 22 20 18 	st  %o1, [ %o0 + 0x18 ]                        <== NOT EXECUTED
    /* Initializing or shifting deadline. */                          
    if (serv_info)                                                    
      new_priority = (_Watchdog_Ticks_since_boot + serv_info->parameters.deadline)
        & ~SCHEDULER_EDF_PRIO_MSB;                                    
    else                                                              
      new_priority = (_Watchdog_Ticks_since_boot + deadline)          
40009e4c:	03 10 00 83 	sethi  %hi(0x40020c00), %g1                    
40009e50:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1	! 40020c08 <_Watchdog_Ticks_since_boot>
40009e54:	92 02 40 01 	add  %o1, %g1, %o1                             
40009e58:	03 20 00 00 	sethi  %hi(0x80000000), %g1                    
40009e5c:	10 bf ff f2 	b  40009e24 <_Scheduler_CBS_Release_job+0x38>  
40009e60:	92 2a 40 01 	andn  %o1, %g1, %o1                            
                                                                      

40009e64 <_Scheduler_CBS_Unblock>: #include <rtems/score/schedulercbs.h> void _Scheduler_CBS_Unblock( Thread_Control *the_thread ) {
40009e64:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Scheduler_CBS_Per_thread *sched_info;                               
  Scheduler_CBS_Server *serv_info;                                    
  Priority_Control new_priority;                                      
                                                                      
  _Scheduler_EDF_Enqueue(the_thread);                                 
40009e68:	40 00 00 50 	call  40009fa8 <_Scheduler_EDF_Enqueue>        
40009e6c:	90 10 00 18 	mov  %i0, %o0                                  
  /* TODO: flash critical section? */                                 
                                                                      
  sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
  serv_info = (Scheduler_CBS_Server *) sched_info->cbs_server;        
40009e70:	c2 06 20 88 	ld  [ %i0 + 0x88 ], %g1                        
40009e74:	fa 00 60 18 	ld  [ %g1 + 0x18 ], %i5                        
   * Late unblock rule for deadline-driven tasks. The remaining time to
   * deadline must be sufficient to serve the remaining computation time
   * without increased utilization of this task. It might cause a deadline
   * miss of another task.                                            
   */                                                                 
  if (serv_info) {                                                    
40009e78:	80 a7 60 00 	cmp  %i5, 0                                    
40009e7c:	02 80 00 19 	be  40009ee0 <_Scheduler_CBS_Unblock+0x7c>     
40009e80:	03 10 00 83 	sethi  %hi(0x40020c00), %g1                    
    time_t budget = serv_info->parameters.budget;                     
    time_t deadline_left = the_thread->cpu_time_budget;               
    time_t budget_left = the_thread->real_priority -                  
                           _Watchdog_Ticks_since_boot;                
                                                                      
    if ( deadline*budget_left > budget*deadline_left ) {              
40009e84:	d2 07 60 04 	ld  [ %i5 + 4 ], %o1                           
   */                                                                 
  if (serv_info) {                                                    
    time_t deadline = serv_info->parameters.deadline;                 
    time_t budget = serv_info->parameters.budget;                     
    time_t deadline_left = the_thread->cpu_time_budget;               
    time_t budget_left = the_thread->real_priority -                  
40009e88:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           
40009e8c:	f8 06 20 18 	ld  [ %i0 + 0x18 ], %i4                        
                           _Watchdog_Ticks_since_boot;                
                                                                      
    if ( deadline*budget_left > budget*deadline_left ) {              
40009e90:	40 00 40 c1 	call  4001a194 <.umul>                         
40009e94:	90 27 00 08 	sub  %i4, %o0, %o0                             
40009e98:	d2 06 20 74 	ld  [ %i0 + 0x74 ], %o1                        
40009e9c:	b6 10 00 08 	mov  %o0, %i3                                  
40009ea0:	40 00 40 bd 	call  4001a194 <.umul>                         
40009ea4:	d0 07 60 08 	ld  [ %i5 + 8 ], %o0                           
40009ea8:	80 a6 c0 08 	cmp  %i3, %o0                                  
40009eac:	24 80 00 0e 	ble,a   40009ee4 <_Scheduler_CBS_Unblock+0x80> 
40009eb0:	d0 06 20 14 	ld  [ %i0 + 0x14 ], %o0                        
      /* Put late unblocked task to background until the end of period. */
      new_priority = the_thread->Start.initial_priority;              
40009eb4:	d2 06 20 ac 	ld  [ %i0 + 0xac ], %o1                        
      if ( the_thread->real_priority != new_priority )                
40009eb8:	80 a7 00 09 	cmp  %i4, %o1                                  
40009ebc:	32 80 00 02 	bne,a   40009ec4 <_Scheduler_CBS_Unblock+0x60> 
40009ec0:	d2 26 20 18 	st  %o1, [ %i0 + 0x18 ]                        
        the_thread->real_priority = new_priority;                     
      if ( the_thread->current_priority != new_priority )             
40009ec4:	d0 06 20 14 	ld  [ %i0 + 0x14 ], %o0                        
40009ec8:	80 a2 00 09 	cmp  %o0, %o1                                  
40009ecc:	02 80 00 07 	be  40009ee8 <_Scheduler_CBS_Unblock+0x84>     
40009ed0:	3b 10 00 84 	sethi  %hi(0x40021000), %i5                    
        _Thread_Change_priority(the_thread, new_priority, true);      
40009ed4:	90 10 00 18 	mov  %i0, %o0                                  
40009ed8:	40 00 01 10 	call  4000a318 <_Thread_Change_priority>       
40009edc:	94 10 20 01 	mov  1, %o2                                    
40009ee0:	d0 06 20 14 	ld  [ %i0 + 0x14 ], %o0                        
   *    a context switch.                                             
   *  Pseudo-ISR case:                                                
   *    Even if the thread isn't preemptible, if the new heir is      
   *    a pseudo-ISR system task, we need to do a context switch.     
   */                                                                 
  if ( _Scheduler_Is_priority_higher_than( the_thread->current_priority,
40009ee4:	3b 10 00 84 	sethi  %hi(0x40021000), %i5                    
40009ee8:	ba 17 60 30 	or  %i5, 0x30, %i5	! 40021030 <_Per_CPU_Information>
40009eec:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
40009ef0:	d2 00 60 14 	ld  [ %g1 + 0x14 ], %o1                        
40009ef4:	03 10 00 7f 	sethi  %hi(0x4001fc00), %g1                    
40009ef8:	c2 00 63 74 	ld  [ %g1 + 0x374 ], %g1	! 4001ff74 <_Scheduler+0x30>
40009efc:	9f c0 40 00 	call  %g1                                      
40009f00:	01 00 00 00 	nop                                            
40009f04:	80 a2 20 00 	cmp  %o0, 0                                    
40009f08:	04 80 00 0a 	ble  40009f30 <_Scheduler_CBS_Unblock+0xcc>    
40009f0c:	01 00 00 00 	nop                                            
       _Thread_Heir->current_priority)) {                             
    _Thread_Heir = the_thread;                                        
    if ( _Thread_Executing->is_preemptible ||                         
40009f10:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
   *    Even if the thread isn't preemptible, if the new heir is      
   *    a pseudo-ISR system task, we need to do a context switch.     
   */                                                                 
  if ( _Scheduler_Is_priority_higher_than( the_thread->current_priority,
       _Thread_Heir->current_priority)) {                             
    _Thread_Heir = the_thread;                                        
40009f14:	f0 27 60 14 	st  %i0, [ %i5 + 0x14 ]                        
    if ( _Thread_Executing->is_preemptible ||                         
40009f18:	c2 08 60 70 	ldub  [ %g1 + 0x70 ], %g1                      
40009f1c:	80 a0 60 00 	cmp  %g1, 0                                    
40009f20:	22 80 00 06 	be,a   40009f38 <_Scheduler_CBS_Unblock+0xd4>  
40009f24:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
         the_thread->current_priority == 0 )                          
      _Thread_Dispatch_necessary = true;                              
40009f28:	82 10 20 01 	mov  1, %g1                                    
40009f2c:	c2 2f 60 0c 	stb  %g1, [ %i5 + 0xc ]                        
40009f30:	81 c7 e0 08 	ret                                            
40009f34:	81 e8 00 00 	restore                                        
   *    a pseudo-ISR system task, we need to do a context switch.     
   */                                                                 
  if ( _Scheduler_Is_priority_higher_than( the_thread->current_priority,
       _Thread_Heir->current_priority)) {                             
    _Thread_Heir = the_thread;                                        
    if ( _Thread_Executing->is_preemptible ||                         
40009f38:	80 a0 60 00 	cmp  %g1, 0                                    
40009f3c:	12 bf ff fd 	bne  40009f30 <_Scheduler_CBS_Unblock+0xcc>    <== ALWAYS TAKEN
40009f40:	82 10 20 01 	mov  1, %g1                                    
         the_thread->current_priority == 0 )                          
      _Thread_Dispatch_necessary = true;                              
40009f44:	c2 2f 60 0c 	stb  %g1, [ %i5 + 0xc ]                        <== NOT EXECUTED
40009f48:	30 bf ff fa 	b,a   40009f30 <_Scheduler_CBS_Unblock+0xcc>   <== NOT EXECUTED
                                                                      

40009dbc <_Scheduler_EDF_Allocate>: #include <rtems/score/wkspace.h> void *_Scheduler_EDF_Allocate( Thread_Control *the_thread ) {
40009dbc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  void *sched;                                                        
  Scheduler_EDF_Per_thread *schinfo;                                  
                                                                      
  sched = _Workspace_Allocate( sizeof(Scheduler_EDF_Per_thread) );    
40009dc0:	40 00 06 e8 	call  4000b960 <_Workspace_Allocate>           
40009dc4:	90 10 20 18 	mov  0x18, %o0                                 
                                                                      
  if ( sched ) {                                                      
40009dc8:	80 a2 20 00 	cmp  %o0, 0                                    
40009dcc:	02 80 00 05 	be  40009de0 <_Scheduler_EDF_Allocate+0x24>    <== NEVER TAKEN
40009dd0:	82 10 20 02 	mov  2, %g1                                    
    the_thread->scheduler_info = sched;                               
40009dd4:	d0 26 20 88 	st  %o0, [ %i0 + 0x88 ]                        
    schinfo = (Scheduler_EDF_Per_thread *)(the_thread->scheduler_info);
    schinfo->thread = the_thread;                                     
40009dd8:	f0 22 00 00 	st  %i0, [ %o0 ]                               
    schinfo->queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN;  
40009ddc:	c2 22 20 14 	st  %g1, [ %o0 + 0x14 ]                        
  }                                                                   
                                                                      
  return sched;                                                       
}                                                                     
40009de0:	81 c7 e0 08 	ret                                            
40009de4:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

40009fa0 <_Scheduler_EDF_Unblock>: #include <rtems/score/scheduleredf.h> void _Scheduler_EDF_Unblock( Thread_Control *the_thread ) {
40009fa0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  _Scheduler_EDF_Enqueue(the_thread);                                 
40009fa4:	7f ff ff a8 	call  40009e44 <_Scheduler_EDF_Enqueue>        
40009fa8:	90 10 00 18 	mov  %i0, %o0                                  
   *    a context switch.                                             
   *  Pseudo-ISR case:                                                
   *    Even if the thread isn't preemptible, if the new heir is      
   *    a pseudo-ISR system task, we need to do a context switch.     
   */                                                                 
  if ( _Scheduler_Is_priority_lower_than(                             
40009fac:	3b 10 00 83 	sethi  %hi(0x40020c00), %i5                    
40009fb0:	ba 17 63 90 	or  %i5, 0x390, %i5	! 40020f90 <_Per_CPU_Information>
40009fb4:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
40009fb8:	d0 00 60 14 	ld  [ %g1 + 0x14 ], %o0                        
40009fbc:	03 10 00 7f 	sethi  %hi(0x4001fc00), %g1                    
40009fc0:	c2 00 62 d4 	ld  [ %g1 + 0x2d4 ], %g1	! 4001fed4 <_Scheduler+0x30>
40009fc4:	9f c0 40 00 	call  %g1                                      
40009fc8:	d2 06 20 14 	ld  [ %i0 + 0x14 ], %o1                        
40009fcc:	80 a2 20 00 	cmp  %o0, 0                                    
40009fd0:	26 80 00 04 	bl,a   40009fe0 <_Scheduler_EDF_Unblock+0x40>  
40009fd4:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
40009fd8:	81 c7 e0 08 	ret                                            
40009fdc:	81 e8 00 00 	restore                                        
         _Thread_Heir->current_priority,                              
         the_thread->current_priority )) {                            
    _Thread_Heir = the_thread;                                        
40009fe0:	f0 27 60 14 	st  %i0, [ %i5 + 0x14 ]                        
    if ( _Thread_Executing->is_preemptible ||                         
40009fe4:	c2 08 60 70 	ldub  [ %g1 + 0x70 ], %g1                      
40009fe8:	80 a0 60 00 	cmp  %g1, 0                                    
40009fec:	22 80 00 06 	be,a   4000a004 <_Scheduler_EDF_Unblock+0x64>  
40009ff0:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
         the_thread->current_priority == 0 )                          
      _Thread_Dispatch_necessary = true;                              
40009ff4:	82 10 20 01 	mov  1, %g1                                    
40009ff8:	c2 2f 60 0c 	stb  %g1, [ %i5 + 0xc ]                        
40009ffc:	81 c7 e0 08 	ret                                            
4000a000:	81 e8 00 00 	restore                                        
   */                                                                 
  if ( _Scheduler_Is_priority_lower_than(                             
         _Thread_Heir->current_priority,                              
         the_thread->current_priority )) {                            
    _Thread_Heir = the_thread;                                        
    if ( _Thread_Executing->is_preemptible ||                         
4000a004:	80 a0 60 00 	cmp  %g1, 0                                    
4000a008:	12 bf ff f4 	bne  40009fd8 <_Scheduler_EDF_Unblock+0x38>    <== ALWAYS TAKEN
4000a00c:	82 10 20 01 	mov  1, %g1                                    
         the_thread->current_priority == 0 )                          
      _Thread_Dispatch_necessary = true;                              
4000a010:	c2 2f 60 0c 	stb  %g1, [ %i5 + 0xc ]                        <== NOT EXECUTED
4000a014:	30 bf ff fa 	b,a   40009ffc <_Scheduler_EDF_Unblock+0x5c>   <== NOT EXECUTED
                                                                      

40009710 <_Scheduler_priority_Tick>: #include <rtems/system.h> #include <rtems/score/schedulerpriority.h> void _Scheduler_priority_Tick( void ) {
40009710:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Thread_Control *executing;                                          
                                                                      
  executing = _Thread_Executing;                                      
40009714:	03 10 00 7c 	sethi  %hi(0x4001f000), %g1                    
40009718:	d0 00 63 e0 	ld  [ %g1 + 0x3e0 ], %o0	! 4001f3e0 <_Per_CPU_Information+0x10>
  /*                                                                  
   *  If the thread is not preemptible or is not ready, then          
   *  just return.                                                    
   */                                                                 
                                                                      
  if ( !executing->is_preemptible )                                   
4000971c:	c2 0a 20 70 	ldub  [ %o0 + 0x70 ], %g1                      
40009720:	80 a0 60 00 	cmp  %g1, 0                                    
40009724:	02 80 00 26 	be  400097bc <_Scheduler_priority_Tick+0xac>   
40009728:	01 00 00 00 	nop                                            
    return;                                                           
                                                                      
  if ( !_States_Is_ready( executing->current_state ) )                
4000972c:	c2 02 20 10 	ld  [ %o0 + 0x10 ], %g1                        
40009730:	80 a0 60 00 	cmp  %g1, 0                                    
40009734:	12 80 00 22 	bne  400097bc <_Scheduler_priority_Tick+0xac>  
40009738:	01 00 00 00 	nop                                            
                                                                      
  /*                                                                  
   *  The cpu budget algorithm determines what happens next.          
   */                                                                 
                                                                      
  switch ( executing->budget_algorithm ) {                            
4000973c:	c2 02 20 78 	ld  [ %o0 + 0x78 ], %g1                        
40009740:	80 a0 60 01 	cmp  %g1, 1                                    
40009744:	0a 80 00 07 	bcs  40009760 <_Scheduler_priority_Tick+0x50>  
40009748:	80 a0 60 02 	cmp  %g1, 2                                    
4000974c:	28 80 00 10 	bleu,a   4000978c <_Scheduler_priority_Tick+0x7c>
40009750:	c2 02 20 74 	ld  [ %o0 + 0x74 ], %g1                        
40009754:	80 a0 60 03 	cmp  %g1, 3                                    
40009758:	22 80 00 04 	be,a   40009768 <_Scheduler_priority_Tick+0x58><== ALWAYS TAKEN
4000975c:	c2 02 20 74 	ld  [ %o0 + 0x74 ], %g1                        
40009760:	81 c7 e0 08 	ret                                            
40009764:	81 e8 00 00 	restore                                        
      }                                                               
      break;                                                          
                                                                      
    #if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT)          
      case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:                       
	if ( --executing->cpu_time_budget == 0 )                             
40009768:	82 00 7f ff 	add  %g1, -1, %g1                              
4000976c:	80 a0 60 00 	cmp  %g1, 0                                    
40009770:	12 bf ff fc 	bne  40009760 <_Scheduler_priority_Tick+0x50>  
40009774:	c2 22 20 74 	st  %g1, [ %o0 + 0x74 ]                        
	  (*executing->budget_callout)( executing );                         
40009778:	c2 02 20 7c 	ld  [ %o0 + 0x7c ], %g1                        
4000977c:	9f c0 40 00 	call  %g1                                      
40009780:	01 00 00 00 	nop                                            
40009784:	81 c7 e0 08 	ret                                            
40009788:	81 e8 00 00 	restore                                        
                                                                      
    case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE:                 
    #if defined(RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE)          
      case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE:             
    #endif                                                            
      if ( (int)(--executing->cpu_time_budget) <= 0 ) {               
4000978c:	82 00 7f ff 	add  %g1, -1, %g1                              
40009790:	80 a0 60 00 	cmp  %g1, 0                                    
40009794:	14 bf ff f3 	bg  40009760 <_Scheduler_priority_Tick+0x50>   
40009798:	c2 22 20 74 	st  %g1, [ %o0 + 0x74 ]                        
 *  always operates on the scheduler that 'owns' the currently executing
 *  thread.                                                           
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void )                    
{                                                                     
  _Scheduler.Operations.yield();                                      
4000979c:	03 10 00 78 	sethi  %hi(0x4001e000), %g1                    
400097a0:	c2 00 63 70 	ld  [ %g1 + 0x370 ], %g1	! 4001e370 <_Scheduler+0xc>
400097a4:	9f c0 40 00 	call  %g1                                      
400097a8:	d0 27 bf fc 	st  %o0, [ %fp + -4 ]                          
         *  executing thread's timeslice is reset.  Otherwise, the    
         *  currently executing thread is placed at the rear of the   
         *  FIFO for this priority and a new heir is selected.        
         */                                                           
        _Scheduler_Yield();                                           
        executing->cpu_time_budget = _Thread_Ticks_per_timeslice;     
400097ac:	03 10 00 7b 	sethi  %hi(0x4001ec00), %g1                    
400097b0:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
400097b4:	c2 00 62 20 	ld  [ %g1 + 0x220 ], %g1                       
400097b8:	c2 22 20 74 	st  %g1, [ %o0 + 0x74 ]                        
400097bc:	81 c7 e0 08 	ret                                            
400097c0:	81 e8 00 00 	restore                                        
                                                                      

40009fb8 <_Scheduler_simple_Ready_queue_enqueue_first>: { Chain_Control *ready; Chain_Node *the_node; Thread_Control *current; ready = (Chain_Control *)_Scheduler.information;
40009fb8:	03 10 00 7c 	sethi  %hi(0x4001f000), %g1                    
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return _Chain_Head( the_chain )->next;                              
40009fbc:	c2 00 63 64 	ld  [ %g1 + 0x364 ], %g1	! 4001f364 <_Scheduler>
   */                                                                 
  for ( the_node = _Chain_First(ready) ; ; the_node = the_node->next ) {
    current = (Thread_Control *) the_node;                            
                                                                      
    /* break when AT HEAD OF (or PAST) our priority */                
    if ( the_thread->current_priority <= current->current_priority ) {
40009fc0:	c6 02 20 14 	ld  [ %o0 + 0x14 ], %g3                        
40009fc4:	c2 00 40 00 	ld  [ %g1 ], %g1                               
40009fc8:	c4 00 60 14 	ld  [ %g1 + 0x14 ], %g2                        
40009fcc:	80 a0 80 03 	cmp  %g2, %g3                                  
40009fd0:	3a 80 00 08 	bcc,a   40009ff0 <_Scheduler_simple_Ready_queue_enqueue_first+0x38>
40009fd4:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
   * Do NOT need to check for end of chain because there is always    
   * at least one task on the ready chain -- the IDLE task.  It can   
   * never block, should never attempt to obtain a semaphore or mutex,
   * and thus will always be there.                                   
   */                                                                 
  for ( the_node = _Chain_First(ready) ; ; the_node = the_node->next ) {
40009fd8:	c2 00 40 00 	ld  [ %g1 ], %g1                               
    current = (Thread_Control *) the_node;                            
                                                                      
    /* break when AT HEAD OF (or PAST) our priority */                
    if ( the_thread->current_priority <= current->current_priority ) {
40009fdc:	c4 00 60 14 	ld  [ %g1 + 0x14 ], %g2                        
40009fe0:	80 a0 80 03 	cmp  %g2, %g3                                  
40009fe4:	2a bf ff fe 	bcs,a   40009fdc <_Scheduler_simple_Ready_queue_enqueue_first+0x24><== NEVER TAKEN
40009fe8:	c2 00 40 00 	ld  [ %g1 ], %g1                               <== NOT EXECUTED
      current = (Thread_Control *)current->Object.Node.previous;      
40009fec:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
40009ff0:	c4 00 40 00 	ld  [ %g1 ], %g2                               
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
40009ff4:	c2 22 20 04 	st  %g1, [ %o0 + 4 ]                           
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
40009ff8:	d0 20 40 00 	st  %o0, [ %g1 ]                               
  the_node->next        = before_node;                                
40009ffc:	c4 22 00 00 	st  %g2, [ %o0 ]                               
  before_node->previous = the_node;                                   
4000a000:	81 c3 e0 08 	retl                                           
4000a004:	d0 20 a0 04 	st  %o0, [ %g2 + 4 ]                           
                                                                      

40008034 <_TOD_Validate>: }; bool _TOD_Validate( const rtems_time_of_day *the_tod ) {
40008034:	9d e3 bf a0 	save  %sp, -96, %sp                            
  uint32_t   days_in_month;                                           
  uint32_t   ticks_per_second;                                        
                                                                      
  ticks_per_second = TOD_MICROSECONDS_PER_SECOND /                    
	    rtems_configuration_get_microseconds_per_tick();                 
40008038:	03 10 00 79 	sethi  %hi(0x4001e400), %g1                    
)                                                                     
{                                                                     
  uint32_t   days_in_month;                                           
  uint32_t   ticks_per_second;                                        
                                                                      
  ticks_per_second = TOD_MICROSECONDS_PER_SECOND /                    
4000803c:	d2 00 62 7c 	ld  [ %g1 + 0x27c ], %o1	! 4001e67c <Configuration+0xc>
40008040:	11 00 03 d0 	sethi  %hi(0xf4000), %o0                       
40008044:	40 00 4a 77 	call  4001aa20 <.udiv>                         
40008048:	90 12 22 40 	or  %o0, 0x240, %o0	! f4240 <PROM_START+0xf4240>
	    rtems_configuration_get_microseconds_per_tick();                 
  if ((!the_tod)                                  ||                  
4000804c:	80 a6 20 00 	cmp  %i0, 0                                    
40008050:	02 80 00 2c 	be  40008100 <_TOD_Validate+0xcc>              <== NEVER TAKEN
40008054:	82 10 20 00 	clr  %g1                                       
40008058:	c4 06 20 18 	ld  [ %i0 + 0x18 ], %g2                        
4000805c:	80 a2 00 02 	cmp  %o0, %g2                                  
40008060:	28 80 00 26 	bleu,a   400080f8 <_TOD_Validate+0xc4>         
40008064:	b0 08 60 01 	and  %g1, 1, %i0                               
      (the_tod->ticks  >= ticks_per_second)       ||                  
40008068:	c4 06 20 14 	ld  [ %i0 + 0x14 ], %g2                        
4000806c:	80 a0 a0 3b 	cmp  %g2, 0x3b                                 
40008070:	38 80 00 22 	bgu,a   400080f8 <_TOD_Validate+0xc4>          
40008074:	b0 08 60 01 	and  %g1, 1, %i0                               
      (the_tod->second >= TOD_SECONDS_PER_MINUTE) ||                  
40008078:	c4 06 20 10 	ld  [ %i0 + 0x10 ], %g2                        
4000807c:	80 a0 a0 3b 	cmp  %g2, 0x3b                                 
40008080:	38 80 00 1e 	bgu,a   400080f8 <_TOD_Validate+0xc4>          
40008084:	b0 08 60 01 	and  %g1, 1, %i0                               
      (the_tod->minute >= TOD_MINUTES_PER_HOUR)   ||                  
40008088:	c4 06 20 0c 	ld  [ %i0 + 0xc ], %g2                         
4000808c:	80 a0 a0 17 	cmp  %g2, 0x17                                 
40008090:	38 80 00 1a 	bgu,a   400080f8 <_TOD_Validate+0xc4>          
40008094:	b0 08 60 01 	and  %g1, 1, %i0                               
      (the_tod->hour   >= TOD_HOURS_PER_DAY)      ||                  
      (the_tod->month  == 0)                      ||                  
40008098:	c4 06 20 04 	ld  [ %i0 + 4 ], %g2                           
	    rtems_configuration_get_microseconds_per_tick();                 
  if ((!the_tod)                                  ||                  
      (the_tod->ticks  >= ticks_per_second)       ||                  
      (the_tod->second >= TOD_SECONDS_PER_MINUTE) ||                  
      (the_tod->minute >= TOD_MINUTES_PER_HOUR)   ||                  
      (the_tod->hour   >= TOD_HOURS_PER_DAY)      ||                  
4000809c:	80 a0 a0 00 	cmp  %g2, 0                                    
400080a0:	02 80 00 15 	be  400080f4 <_TOD_Validate+0xc0>              <== NEVER TAKEN
400080a4:	80 a0 a0 0c 	cmp  %g2, 0xc                                  
      (the_tod->month  == 0)                      ||                  
400080a8:	38 80 00 14 	bgu,a   400080f8 <_TOD_Validate+0xc4>          
400080ac:	b0 08 60 01 	and  %g1, 1, %i0                               
      (the_tod->month  >  TOD_MONTHS_PER_YEAR)    ||                  
      (the_tod->year   <  TOD_BASE_YEAR)          ||                  
400080b0:	c6 06 00 00 	ld  [ %i0 ], %g3                               
      (the_tod->ticks  >= ticks_per_second)       ||                  
      (the_tod->second >= TOD_SECONDS_PER_MINUTE) ||                  
      (the_tod->minute >= TOD_MINUTES_PER_HOUR)   ||                  
      (the_tod->hour   >= TOD_HOURS_PER_DAY)      ||                  
      (the_tod->month  == 0)                      ||                  
      (the_tod->month  >  TOD_MONTHS_PER_YEAR)    ||                  
400080b4:	80 a0 e7 c3 	cmp  %g3, 0x7c3                                
400080b8:	28 80 00 10 	bleu,a   400080f8 <_TOD_Validate+0xc4>         
400080bc:	b0 08 60 01 	and  %g1, 1, %i0                               
      (the_tod->year   <  TOD_BASE_YEAR)          ||                  
      (the_tod->day    == 0) )                                        
400080c0:	c8 06 20 08 	ld  [ %i0 + 8 ], %g4                           
      (the_tod->second >= TOD_SECONDS_PER_MINUTE) ||                  
      (the_tod->minute >= TOD_MINUTES_PER_HOUR)   ||                  
      (the_tod->hour   >= TOD_HOURS_PER_DAY)      ||                  
      (the_tod->month  == 0)                      ||                  
      (the_tod->month  >  TOD_MONTHS_PER_YEAR)    ||                  
      (the_tod->year   <  TOD_BASE_YEAR)          ||                  
400080c4:	80 a1 20 00 	cmp  %g4, 0                                    
400080c8:	02 80 00 0b 	be  400080f4 <_TOD_Validate+0xc0>              <== NEVER TAKEN
400080cc:	80 88 e0 03 	btst  3, %g3                                   
      (the_tod->day    == 0) )                                        
     return false;                                                    
                                                                      
  if ( (the_tod->year % 4) == 0 )                                     
400080d0:	32 80 00 0f 	bne,a   4000810c <_TOD_Validate+0xd8>          
400080d4:	85 28 a0 02 	sll  %g2, 2, %g2                               
    days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];       
400080d8:	82 00 a0 0d 	add  %g2, 0xd, %g1                             
400080dc:	05 10 00 7d 	sethi  %hi(0x4001f400), %g2                    
400080e0:	83 28 60 02 	sll  %g1, 2, %g1                               
400080e4:	84 10 a3 70 	or  %g2, 0x370, %g2                            
400080e8:	c2 00 80 01 	ld  [ %g2 + %g1 ], %g1                         
  else                                                                
    days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];       
                                                                      
  if ( the_tod->day > days_in_month )                                 
400080ec:	80 a0 40 04 	cmp  %g1, %g4                                  
400080f0:	82 60 3f ff 	subx  %g0, -1, %g1                             
    return false;                                                     
                                                                      
  return true;                                                        
}                                                                     
400080f4:	b0 08 60 01 	and  %g1, 1, %i0                               
400080f8:	81 c7 e0 08 	ret                                            
400080fc:	81 e8 00 00 	restore                                        
40008100:	b0 08 60 01 	and  %g1, 1, %i0                               <== NOT EXECUTED
40008104:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40008108:	81 e8 00 00 	restore                                        <== NOT EXECUTED
     return false;                                                    
                                                                      
  if ( (the_tod->year % 4) == 0 )                                     
    days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];       
  else                                                                
    days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];       
4000810c:	03 10 00 7d 	sethi  %hi(0x4001f400), %g1                    
40008110:	82 10 63 70 	or  %g1, 0x370, %g1	! 4001f770 <_TOD_Days_per_month>
40008114:	c2 00 40 02 	ld  [ %g1 + %g2 ], %g1                         
                                                                      
  if ( the_tod->day > days_in_month )                                 
40008118:	80 a0 40 04 	cmp  %g1, %g4                                  
4000811c:	10 bf ff f6 	b  400080f4 <_TOD_Validate+0xc0>               
40008120:	82 60 3f ff 	subx  %g0, -1, %g1                             
                                                                      

400099e0 <_Thread_Change_priority>: void _Thread_Change_priority( Thread_Control *the_thread, Priority_Control new_priority, bool prepend_it ) {
400099e0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  States_Control state, original_state;                               
                                                                      
  /*                                                                  
   * Save original state                                              
   */                                                                 
  original_state = the_thread->current_state;                         
400099e4:	f6 06 20 10 	ld  [ %i0 + 0x10 ], %i3                        
  /*                                                                  
   * Set a transient state for the thread so it is pulled off the Ready chains.
   * This will prevent it from being scheduled no matter what happens in an
   * ISR.                                                             
   */                                                                 
  _Thread_Set_transient( the_thread );                                
400099e8:	40 00 03 9a 	call  4000a850 <_Thread_Set_transient>         
400099ec:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
  /*                                                                  
   *  Do not bother recomputing all the priority related information if
   *  we are not REALLY changing priority.                            
   */                                                                 
 if ( the_thread->current_priority != new_priority )                  
400099f0:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
400099f4:	80 a0 40 19 	cmp  %g1, %i1                                  
400099f8:	02 80 00 05 	be  40009a0c <_Thread_Change_priority+0x2c>    
400099fc:	ba 10 00 18 	mov  %i0, %i5                                  
    _Thread_Set_priority( the_thread, new_priority );                 
40009a00:	90 10 00 18 	mov  %i0, %o0                                  
40009a04:	40 00 03 79 	call  4000a7e8 <_Thread_Set_priority>          
40009a08:	92 10 00 19 	mov  %i1, %o1                                  
                                                                      
  _ISR_Disable( level );                                              
40009a0c:	7f ff e1 a6 	call  400020a4 <sparc_disable_interrupts>      
40009a10:	01 00 00 00 	nop                                            
40009a14:	b2 10 00 08 	mov  %o0, %i1                                  
                                                                      
  /*                                                                  
   *  If the thread has more than STATES_TRANSIENT set, then it is blocked,
   *  If it is blocked on a thread queue, then we need to requeue it. 
   */                                                                 
  state = the_thread->current_state;                                  
40009a18:	f8 07 60 10 	ld  [ %i5 + 0x10 ], %i4                        
  if ( state != STATES_TRANSIENT ) {                                  
40009a1c:	80 a7 20 04 	cmp  %i4, 4                                    
40009a20:	02 80 00 18 	be  40009a80 <_Thread_Change_priority+0xa0>    
40009a24:	80 8e e0 04 	btst  4, %i3                                   
    /* Only clear the transient state if it wasn't set already */     
    if ( ! _States_Is_transient( original_state ) )                   
40009a28:	02 80 00 0b 	be  40009a54 <_Thread_Change_priority+0x74>    <== ALWAYS TAKEN
40009a2c:	82 0f 3f fb 	and  %i4, -5, %g1                              
      the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
    _ISR_Enable( level );                                             
40009a30:	7f ff e1 a1 	call  400020b4 <sparc_enable_interrupts>       <== NOT EXECUTED
40009a34:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (        
  States_Control the_states                                           
)                                                                     
{                                                                     
   return (the_states & STATES_WAITING_ON_THREAD_QUEUE);              
40009a38:	03 00 00 ef 	sethi  %hi(0x3bc00), %g1                       <== NOT EXECUTED
40009a3c:	82 10 62 e0 	or  %g1, 0x2e0, %g1	! 3bee0 <PROM_START+0x3bee0><== NOT EXECUTED
    if ( _States_Is_waiting_on_thread_queue( state ) ) {              
40009a40:	80 8f 00 01 	btst  %i4, %g1                                 <== NOT EXECUTED
40009a44:	32 80 00 0d 	bne,a   40009a78 <_Thread_Change_priority+0x98><== NOT EXECUTED
40009a48:	f0 07 60 44 	ld  [ %i5 + 0x44 ], %i0                        <== NOT EXECUTED
40009a4c:	81 c7 e0 08 	ret                                            
40009a50:	81 e8 00 00 	restore                                        
   */                                                                 
  state = the_thread->current_state;                                  
  if ( state != STATES_TRANSIENT ) {                                  
    /* Only clear the transient state if it wasn't set already */     
    if ( ! _States_Is_transient( original_state ) )                   
      the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
40009a54:	c2 27 60 10 	st  %g1, [ %i5 + 0x10 ]                        
    _ISR_Enable( level );                                             
40009a58:	7f ff e1 97 	call  400020b4 <sparc_enable_interrupts>       
40009a5c:	90 10 00 19 	mov  %i1, %o0                                  
40009a60:	03 00 00 ef 	sethi  %hi(0x3bc00), %g1                       
40009a64:	82 10 62 e0 	or  %g1, 0x2e0, %g1	! 3bee0 <PROM_START+0x3bee0>
    if ( _States_Is_waiting_on_thread_queue( state ) ) {              
40009a68:	80 8f 00 01 	btst  %i4, %g1                                 
40009a6c:	02 bf ff f8 	be  40009a4c <_Thread_Change_priority+0x6c>    
40009a70:	01 00 00 00 	nop                                            
      _Thread_queue_Requeue( the_thread->Wait.queue, the_thread );    
40009a74:	f0 07 60 44 	ld  [ %i5 + 0x44 ], %i0                        
40009a78:	40 00 03 2c 	call  4000a728 <_Thread_queue_Requeue>         
40009a7c:	93 e8 00 1d 	restore  %g0, %i5, %o1                         
    }                                                                 
    return;                                                           
  }                                                                   
                                                                      
  /* Only clear the transient state if it wasn't set already */       
  if ( ! _States_Is_transient( original_state ) ) {                   
40009a80:	22 80 00 19 	be,a   40009ae4 <_Thread_Change_priority+0x104><== ALWAYS TAKEN
40009a84:	c0 27 60 10 	clr  [ %i5 + 0x10 ]                            
40009a88:	39 10 00 78 	sethi  %hi(0x4001e000), %i4                    <== NOT EXECUTED
40009a8c:	b8 17 23 64 	or  %i4, 0x364, %i4	! 4001e364 <_Scheduler>    <== NOT EXECUTED
      _Scheduler_Enqueue_first( the_thread );                         
    else                                                              
      _Scheduler_Enqueue( the_thread );                               
  }                                                                   
                                                                      
  _ISR_Flash( level );                                                
40009a90:	7f ff e1 89 	call  400020b4 <sparc_enable_interrupts>       
40009a94:	90 10 00 19 	mov  %i1, %o0                                  
40009a98:	7f ff e1 83 	call  400020a4 <sparc_disable_interrupts>      
40009a9c:	01 00 00 00 	nop                                            
40009aa0:	b0 10 00 08 	mov  %o0, %i0                                  
 *  This kernel routine implements the scheduling decision logic for  
 *  the scheduler. It does NOT dispatch.                              
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_Schedule( void )                 
{                                                                     
  _Scheduler.Operations.schedule();                                   
40009aa4:	c2 07 20 08 	ld  [ %i4 + 8 ], %g1                           
40009aa8:	9f c0 40 00 	call  %g1                                      
40009aac:	01 00 00 00 	nop                                            
 *  is also the heir thread, and false otherwise.                     
 */                                                                   
                                                                      
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void )  
{                                                                     
  return ( _Thread_Executing == _Thread_Heir );                       
40009ab0:	03 10 00 7c 	sethi  %hi(0x4001f000), %g1                    
40009ab4:	82 10 63 d0 	or  %g1, 0x3d0, %g1	! 4001f3d0 <_Per_CPU_Information>
   *  We altered the set of thread priorities.  So let's figure out   
   *  who is the heir and if we need to switch to them.               
   */                                                                 
  _Scheduler_Schedule();                                              
                                                                      
  if ( !_Thread_Is_executing_also_the_heir() &&                       
40009ab8:	c4 18 60 10 	ldd  [ %g1 + 0x10 ], %g2                       
40009abc:	80 a0 80 03 	cmp  %g2, %g3                                  
40009ac0:	02 80 00 07 	be  40009adc <_Thread_Change_priority+0xfc>    
40009ac4:	01 00 00 00 	nop                                            
40009ac8:	c4 08 a0 70 	ldub  [ %g2 + 0x70 ], %g2                      
40009acc:	80 a0 a0 00 	cmp  %g2, 0                                    
40009ad0:	02 80 00 03 	be  40009adc <_Thread_Change_priority+0xfc>    
40009ad4:	84 10 20 01 	mov  1, %g2                                    
       _Thread_Executing->is_preemptible )                            
    _Thread_Dispatch_necessary = true;                                
40009ad8:	c4 28 60 0c 	stb  %g2, [ %g1 + 0xc ]                        
  _ISR_Enable( level );                                               
40009adc:	7f ff e1 76 	call  400020b4 <sparc_enable_interrupts>       
40009ae0:	81 e8 00 00 	restore                                        
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(                   
  Thread_Control    *the_thread                                       
)                                                                     
{                                                                     
  _Scheduler.Operations.enqueue_first( the_thread );                  
40009ae4:	39 10 00 78 	sethi  %hi(0x4001e000), %i4                    
     *  the TRANSIENT state.  So we have to place it on the appropriate
     *  Ready Queue with interrupts off.                              
     */                                                               
    the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
                                                                      
    if ( prepend_it )                                                 
40009ae8:	80 a6 a0 00 	cmp  %i2, 0                                    
40009aec:	02 80 00 06 	be  40009b04 <_Thread_Change_priority+0x124>   
40009af0:	b8 17 23 64 	or  %i4, 0x364, %i4                            
40009af4:	c2 07 20 28 	ld  [ %i4 + 0x28 ], %g1                        
40009af8:	9f c0 40 00 	call  %g1                                      
40009afc:	90 10 00 1d 	mov  %i5, %o0                                  
40009b00:	30 bf ff e4 	b,a   40009a90 <_Thread_Change_priority+0xb0>  
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(                         
  Thread_Control    *the_thread                                       
)                                                                     
{                                                                     
  _Scheduler.Operations.enqueue( the_thread );                        
40009b04:	c2 07 20 24 	ld  [ %i4 + 0x24 ], %g1                        
40009b08:	9f c0 40 00 	call  %g1                                      
40009b0c:	90 10 00 1d 	mov  %i5, %o0                                  
40009b10:	30 bf ff e0 	b,a   40009a90 <_Thread_Change_priority+0xb0>  
                                                                      

40009d00 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored __attribute__((unused)) ) {
40009d00:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Thread_Control    *the_thread;                                      
  Objects_Locations  location;                                        
                                                                      
  the_thread = _Thread_Get( id, &location );                          
40009d04:	90 10 00 18 	mov  %i0, %o0                                  
40009d08:	40 00 00 7c 	call  40009ef8 <_Thread_Get>                   
40009d0c:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
40009d10:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40009d14:	80 a0 60 00 	cmp  %g1, 0                                    
40009d18:	12 80 00 08 	bne  40009d38 <_Thread_Delay_ended+0x38>       <== NEVER TAKEN
40009d1c:	13 04 00 00 	sethi  %hi(0x10000000), %o1                    
#if defined(RTEMS_MULTIPROCESSING)                                    
    case OBJECTS_REMOTE:  /* impossible */                            
#endif                                                                
      break;                                                          
    case OBJECTS_LOCAL:                                               
      _Thread_Clear_state(                                            
40009d20:	7f ff ff 7d 	call  40009b14 <_Thread_Clear_state>           
40009d24:	92 12 60 18 	or  %o1, 0x18, %o1	! 10000018 <RAM_SIZE+0xfc00018>
   *                                                                  
   * This routine decrements the thread dispatch level.               
   */                                                                 
  RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
  {                                                                   
    uint32_t level = _Thread_Dispatch_disable_level;                  
40009d28:	03 10 00 7b 	sethi  %hi(0x4001ec00), %g1                    
40009d2c:	c4 00 62 c0 	ld  [ %g1 + 0x2c0 ], %g2	! 4001eec0 <_Thread_Dispatch_disable_level>
                                                                      
    --level;                                                          
40009d30:	84 00 bf ff 	add  %g2, -1, %g2                              
    _Thread_Dispatch_disable_level = level;                           
40009d34:	c4 20 62 c0 	st  %g2, [ %g1 + 0x2c0 ]                       
40009d38:	81 c7 e0 08 	ret                                            
40009d3c:	81 e8 00 00 	restore                                        
                                                                      

40009d40 <_Thread_Dispatch>: #if defined(RTEMS_SMP) #include <rtems/score/smp.h> #endif void _Thread_Dispatch( void ) {
40009d40:	9d e3 bf 98 	save  %sp, -104, %sp                           
  #endif                                                              
                                                                      
  /*                                                                  
   *  Now determine if we need to perform a dispatch on the current CPU.
   */                                                                 
  executing   = _Thread_Executing;                                    
40009d44:	31 10 00 7c 	sethi  %hi(0x4001f000), %i0                    
40009d48:	b0 16 23 d0 	or  %i0, 0x3d0, %i0	! 4001f3d0 <_Per_CPU_Information>
  _ISR_Disable( level );                                              
40009d4c:	7f ff e0 d6 	call  400020a4 <sparc_disable_interrupts>      
40009d50:	f6 06 20 10 	ld  [ %i0 + 0x10 ], %i3                        
  while ( _Thread_Dispatch_necessary == true ) {                      
40009d54:	c2 0e 20 0c 	ldub  [ %i0 + 0xc ], %g1                       
40009d58:	80 a0 60 00 	cmp  %g1, 0                                    
40009d5c:	02 80 00 46 	be  40009e74 <_Thread_Dispatch+0x134>          
40009d60:	21 10 00 7b 	sethi  %hi(0x4001ec00), %l0                    
    heir = _Thread_Heir;                                              
40009d64:	f4 06 20 14 	ld  [ %i0 + 0x14 ], %i2                        
   * This routine sets thread dispatch level to the                   
   * value passed in.                                                 
   */                                                                 
  RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_set_disable_level(uint32_t value)
  {                                                                   
    _Thread_Dispatch_disable_level = value;                           
40009d68:	82 10 20 01 	mov  1, %g1                                    
40009d6c:	c2 24 22 c0 	st  %g1, [ %l0 + 0x2c0 ]                       
    #ifndef RTEMS_SMP                                                 
      _Thread_Dispatch_set_disable_level( 1 );                        
    #endif                                                            
    _Thread_Dispatch_necessary = false;                               
40009d70:	c0 2e 20 0c 	clrb  [ %i0 + 0xc ]                            
    /*                                                                
     *  When the heir and executing are the same, then we are being   
     *  requested to do the post switch dispatching.  This is normally
     *  done to dispatch signals.                                     
     */                                                               
    if ( heir == executing )                                          
40009d74:	80 a6 c0 1a 	cmp  %i3, %i2                                  
40009d78:	02 80 00 3f 	be  40009e74 <_Thread_Dispatch+0x134>          
40009d7c:	f4 26 20 10 	st  %i2, [ %i0 + 0x10 ]                        
40009d80:	23 10 00 79 	sethi  %hi(0x4001e400), %l1                    
40009d84:	27 10 00 7b 	sethi  %hi(0x4001ec00), %l3                    
40009d88:	a2 14 60 8c 	or  %l1, 0x8c, %l1                             
 */                                                                   
static inline void _TOD_Get_uptime(                                   
  Timestamp_Control *time                                             
)                                                                     
{                                                                     
  _TOD_Get_with_nanoseconds( time, &_TOD.uptime );                    
40009d8c:	25 10 00 7b 	sethi  %hi(0x4001ec00), %l2                    
40009d90:	a6 14 e3 2c 	or  %l3, 0x32c, %l3                            
40009d94:	b2 04 60 04 	add  %l1, 4, %i1                               
#if __RTEMS_ADA__                                                     
    executing->rtems_ada_self = rtems_ada_self;                       
    rtems_ada_self = heir->rtems_ada_self;                            
#endif                                                                
    if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE )
      heir->cpu_time_budget = _Thread_Ticks_per_timeslice;            
40009d98:	2b 10 00 7b 	sethi  %hi(0x4001ec00), %l5                    
40009d9c:	a4 14 a2 10 	or  %l2, 0x210, %l2                            
40009da0:	a8 10 20 01 	mov  1, %l4                                    
     */                                                               
#if __RTEMS_ADA__                                                     
    executing->rtems_ada_self = rtems_ada_self;                       
    rtems_ada_self = heir->rtems_ada_self;                            
#endif                                                                
    if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE )
40009da4:	c2 06 a0 78 	ld  [ %i2 + 0x78 ], %g1                        
40009da8:	80 a0 60 01 	cmp  %g1, 1                                    
40009dac:	02 80 00 45 	be  40009ec0 <_Thread_Dispatch+0x180>          
40009db0:	c2 05 62 20 	ld  [ %l5 + 0x220 ], %g1                       
      heir->cpu_time_budget = _Thread_Ticks_per_timeslice;            
                                                                      
    _ISR_Enable( level );                                             
40009db4:	7f ff e0 c0 	call  400020b4 <sparc_enable_interrupts>       
40009db8:	01 00 00 00 	nop                                            
40009dbc:	90 07 bf f8 	add  %fp, -8, %o0                              
40009dc0:	7f ff f9 8b 	call  400083ec <_TOD_Get_with_nanoseconds>     
40009dc4:	92 10 00 12 	mov  %l2, %o1                                  
40009dc8:	c4 1e e0 80 	ldd  [ %i3 + 0x80 ], %g2                       
  const Timestamp64_Control *_start,                                  
  const Timestamp64_Control *_end,                                    
  Timestamp64_Control       *_result                                  
)                                                                     
{                                                                     
  *_result = *_end - *_start;                                         
40009dcc:	f8 1e 20 20 	ldd  [ %i0 + 0x20 ], %i4                       
                                                                      
    #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                        
      {                                                               
        Timestamp_Control uptime, ran;                                
        _TOD_Get_uptime( &uptime );                                   
        _Timestamp_Subtract(                                          
40009dd0:	d8 1f bf f8 	ldd  [ %fp + -8 ], %o4                         
    #endif                                                            
                                                                      
    /*                                                                
     * Switch libc's task specific data.                              
     */                                                               
    if ( _Thread_libc_reent ) {                                       
40009dd4:	c2 04 c0 00 	ld  [ %l3 ], %g1                               
40009dd8:	ba a3 40 1d 	subcc  %o5, %i5, %i5                           
40009ddc:	b8 63 00 1c 	subx  %o4, %i4, %i4                            
static inline void _Timestamp64_implementation_Add_to(                
  Timestamp64_Control       *_time,                                   
  const Timestamp64_Control *_add                                     
)                                                                     
{                                                                     
  *_time += *_add;                                                    
40009de0:	96 80 c0 1d 	addcc  %g3, %i5, %o3                           
40009de4:	94 40 80 1c 	addx  %g2, %i4, %o2                            
40009de8:	d4 3e e0 80 	std  %o2, [ %i3 + 0x80 ]                       
40009dec:	80 a0 60 00 	cmp  %g1, 0                                    
40009df0:	02 80 00 06 	be  40009e08 <_Thread_Dispatch+0xc8>           <== NEVER TAKEN
40009df4:	d8 3e 20 20 	std  %o4, [ %i0 + 0x20 ]                       
      executing->libc_reent = *_Thread_libc_reent;                    
40009df8:	c4 00 40 00 	ld  [ %g1 ], %g2                               
40009dfc:	c4 26 e1 48 	st  %g2, [ %i3 + 0x148 ]                       
      *_Thread_libc_reent = heir->libc_reent;                         
40009e00:	c4 06 a1 48 	ld  [ %i2 + 0x148 ], %g2                       
40009e04:	c4 20 40 00 	st  %g2, [ %g1 ]                               
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(        
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_head( the_chain )->next;                    
40009e08:	fa 04 40 00 	ld  [ %l1 ], %i5                               
{                                                                     
  const Chain_Control *chain = &_User_extensions_Switches_list;       
  const Chain_Node    *tail = _Chain_Immutable_tail( chain );         
  const Chain_Node    *node = _Chain_Immutable_first( chain );        
                                                                      
  while ( node != tail ) {                                            
40009e0c:	80 a7 40 19 	cmp  %i5, %i1                                  
40009e10:	02 80 00 0b 	be  40009e3c <_Thread_Dispatch+0xfc>           <== NEVER TAKEN
40009e14:	90 06 e0 c0 	add  %i3, 0xc0, %o0                            
    const User_extensions_Switch_control *extension =                 
      (const User_extensions_Switch_control *) node;                  
                                                                      
    (*extension->thread_switch)( executing, heir );                   
40009e18:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
40009e1c:	90 10 00 1b 	mov  %i3, %o0                                  
40009e20:	9f c0 40 00 	call  %g1                                      
40009e24:	92 10 00 1a 	mov  %i2, %o1                                  
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_next(         
  const Chain_Node *the_node                                          
)                                                                     
{                                                                     
  return the_node->next;                                              
40009e28:	fa 07 40 00 	ld  [ %i5 ], %i5                               
{                                                                     
  const Chain_Control *chain = &_User_extensions_Switches_list;       
  const Chain_Node    *tail = _Chain_Immutable_tail( chain );         
  const Chain_Node    *node = _Chain_Immutable_first( chain );        
                                                                      
  while ( node != tail ) {                                            
40009e2c:	80 a7 40 19 	cmp  %i5, %i1                                  
40009e30:	32 bf ff fb 	bne,a   40009e1c <_Thread_Dispatch+0xdc>       
40009e34:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
    if ( executing->fp_context != NULL )                              
      _Context_Save_fp( &executing->fp_context );                     
#endif                                                                
#endif                                                                
                                                                      
    _Context_Switch( &executing->Registers, &heir->Registers );       
40009e38:	90 06 e0 c0 	add  %i3, 0xc0, %o0                            
40009e3c:	40 00 04 91 	call  4000b080 <_CPU_Context_switch>           
40009e40:	92 06 a0 c0 	add  %i2, 0xc0, %o1                            
#endif                                                                
#endif                                                                
                                                                      
    executing = _Thread_Executing;                                    
                                                                      
    _ISR_Disable( level );                                            
40009e44:	7f ff e0 98 	call  400020a4 <sparc_disable_interrupts>      
40009e48:	f6 06 20 10 	ld  [ %i0 + 0x10 ], %i3                        
  /*                                                                  
   *  Now determine if we need to perform a dispatch on the current CPU.
   */                                                                 
  executing   = _Thread_Executing;                                    
  _ISR_Disable( level );                                              
  while ( _Thread_Dispatch_necessary == true ) {                      
40009e4c:	c2 0e 20 0c 	ldub  [ %i0 + 0xc ], %g1                       
40009e50:	80 a0 60 00 	cmp  %g1, 0                                    
40009e54:	02 80 00 08 	be  40009e74 <_Thread_Dispatch+0x134>          
40009e58:	01 00 00 00 	nop                                            
    heir = _Thread_Heir;                                              
40009e5c:	f4 06 20 14 	ld  [ %i0 + 0x14 ], %i2                        
40009e60:	e8 24 22 c0 	st  %l4, [ %l0 + 0x2c0 ]                       
    #ifndef RTEMS_SMP                                                 
      _Thread_Dispatch_set_disable_level( 1 );                        
    #endif                                                            
    _Thread_Dispatch_necessary = false;                               
40009e64:	c0 2e 20 0c 	clrb  [ %i0 + 0xc ]                            
    /*                                                                
     *  When the heir and executing are the same, then we are being   
     *  requested to do the post switch dispatching.  This is normally
     *  done to dispatch signals.                                     
     */                                                               
    if ( heir == executing )                                          
40009e68:	80 a6 80 1b 	cmp  %i2, %i3                                  
40009e6c:	12 bf ff ce 	bne  40009da4 <_Thread_Dispatch+0x64>          <== ALWAYS TAKEN
40009e70:	f4 26 20 10 	st  %i2, [ %i0 + 0x10 ]                        
40009e74:	c0 24 22 c0 	clr  [ %l0 + 0x2c0 ]                           
post_switch:                                                          
  #ifndef RTEMS_SMP                                                   
    _Thread_Dispatch_set_disable_level( 0 );                          
  #endif                                                              
                                                                      
  _ISR_Enable( level );                                               
40009e78:	7f ff e0 8f 	call  400020b4 <sparc_enable_interrupts>       
40009e7c:	01 00 00 00 	nop                                            
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(        
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_head( the_chain )->next;                    
40009e80:	03 10 00 7b 	sethi  %hi(0x4001ec00), %g1                    
40009e84:	fa 00 63 30 	ld  [ %g1 + 0x330 ], %i5	! 4001ef30 <_API_extensions_Post_switch_list>
40009e88:	82 10 63 30 	or  %g1, 0x330, %g1                            
{                                                                     
  const Chain_Control *chain = &_API_extensions_Post_switch_list;     
  const Chain_Node    *tail = _Chain_Immutable_tail( chain );         
  const Chain_Node    *node = _Chain_Immutable_first( chain );        
                                                                      
  while ( node != tail ) {                                            
40009e8c:	b8 00 60 04 	add  %g1, 4, %i4                               
40009e90:	80 a7 40 1c 	cmp  %i5, %i4                                  
40009e94:	02 80 00 09 	be  40009eb8 <_Thread_Dispatch+0x178>          
40009e98:	01 00 00 00 	nop                                            
    const API_extensions_Post_switch_control *post_switch =           
      (const API_extensions_Post_switch_control *) node;              
                                                                      
    (*post_switch->hook)( executing );                                
40009e9c:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
40009ea0:	9f c0 40 00 	call  %g1                                      
40009ea4:	90 10 00 1b 	mov  %i3, %o0                                  
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_next(         
  const Chain_Node *the_node                                          
)                                                                     
{                                                                     
  return the_node->next;                                              
40009ea8:	fa 07 40 00 	ld  [ %i5 ], %i5                               
{                                                                     
  const Chain_Control *chain = &_API_extensions_Post_switch_list;     
  const Chain_Node    *tail = _Chain_Immutable_tail( chain );         
  const Chain_Node    *node = _Chain_Immutable_first( chain );        
                                                                      
  while ( node != tail ) {                                            
40009eac:	80 a7 40 1c 	cmp  %i5, %i4                                  
40009eb0:	32 bf ff fc 	bne,a   40009ea0 <_Thread_Dispatch+0x160>      <== NEVER TAKEN
40009eb4:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           <== NOT EXECUTED
40009eb8:	81 c7 e0 08 	ret                                            
40009ebc:	81 e8 00 00 	restore                                        
#if __RTEMS_ADA__                                                     
    executing->rtems_ada_self = rtems_ada_self;                       
    rtems_ada_self = heir->rtems_ada_self;                            
#endif                                                                
    if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE )
      heir->cpu_time_budget = _Thread_Ticks_per_timeslice;            
40009ec0:	10 bf ff bd 	b  40009db4 <_Thread_Dispatch+0x74>            
40009ec4:	c2 26 a0 74 	st  %g1, [ %i2 + 0x74 ]                        
                                                                      

4000f504 <_Thread_Handler>: #define INIT_NAME __main #define EXECUTE_GLOBAL_CONSTRUCTORS #endif void _Thread_Handler( void ) {
4000f504:	9d e3 bf a0 	save  %sp, -96, %sp                            
  #if defined(EXECUTE_GLOBAL_CONSTRUCTORS)                            
    static bool doneConstructors;                                     
    bool doCons;                                                      
  #endif                                                              
                                                                      
  executing = _Thread_Executing;                                      
4000f508:	03 10 00 7c 	sethi  %hi(0x4001f000), %g1                    
4000f50c:	fa 00 63 e0 	ld  [ %g1 + 0x3e0 ], %i5	! 4001f3e0 <_Per_CPU_Information+0x10>
  /*                                                                  
   * Some CPUs need to tinker with the call frame or registers when the
   * thread actually begins to execute for the first time.  This is a 
   * hook point where the port gets a shot at doing whatever it requires.
   */                                                                 
  _Context_Initialization_at_thread_begin();                          
4000f510:	3f 10 00 3d 	sethi  %hi(0x4000f400), %i7                    
4000f514:	be 17 e1 04 	or  %i7, 0x104, %i7	! 4000f504 <_Thread_Handler>
                                                                      
  /*                                                                  
   * have to put level into a register for those cpu's that use       
   * inline asm here                                                  
   */                                                                 
  level = executing->Start.isr_level;                                 
4000f518:	d0 07 60 a8 	ld  [ %i5 + 0xa8 ], %o0                        
  _ISR_Set_level(level);                                              
4000f51c:	7f ff ca e6 	call  400020b4 <sparc_enable_interrupts>       
4000f520:	91 2a 20 08 	sll  %o0, 8, %o0                               
      doCons = !doneConstructors                                      
        && _Objects_Get_API( executing->Object.id ) != OBJECTS_INTERNAL_API;
      if (doCons)                                                     
        doneConstructors = true;                                      
    #else                                                             
      doCons = !doneConstructors;                                     
4000f524:	03 10 00 7a 	sethi  %hi(0x4001e800), %g1                    
      doneConstructors = true;                                        
4000f528:	84 10 20 01 	mov  1, %g2                                    
      doCons = !doneConstructors                                      
        && _Objects_Get_API( executing->Object.id ) != OBJECTS_INTERNAL_API;
      if (doCons)                                                     
        doneConstructors = true;                                      
    #else                                                             
      doCons = !doneConstructors;                                     
4000f52c:	f8 08 63 b8 	ldub  [ %g1 + 0x3b8 ], %i4                     
  );                                                                  
}                                                                     
                                                                      
static inline void _User_extensions_Thread_begin( Thread_Control *executing )
{                                                                     
  _User_extensions_Iterate(                                           
4000f530:	90 10 00 1d 	mov  %i5, %o0                                  
4000f534:	13 10 00 2a 	sethi  %hi(0x4000a800), %o1                    
4000f538:	92 12 62 34 	or  %o1, 0x234, %o1	! 4000aa34 <_User_extensions_Thread_begin_visitor>
4000f53c:	7f ff ed 5b 	call  4000aaa8 <_User_extensions_Iterate>      
4000f540:	c4 28 63 b8 	stb  %g2, [ %g1 + 0x3b8 ]                      
  _User_extensions_Thread_begin( executing );                         
                                                                      
  /*                                                                  
   *  At this point, the dispatch disable level BETTER be 1.          
   */                                                                 
  _Thread_Enable_dispatch();                                          
4000f544:	7f ff ea 61 	call  40009ec8 <_Thread_Enable_dispatch>       
4000f548:	01 00 00 00 	nop                                            
    /*                                                                
     *  _init could be a weak symbol and we SHOULD test it but it isn't
     *  in any configuration I know of and it generates a warning on every
     *  RTEMS target configuration.  --joel (12 May 2007)             
     */                                                               
    if (doCons) /* && (volatile void *)_init) */ {                    
4000f54c:	80 8f 20 ff 	btst  0xff, %i4                                
4000f550:	02 80 00 10 	be  4000f590 <_Thread_Handler+0x8c>            
4000f554:	01 00 00 00 	nop                                            
        _Thread_Enable_dispatch();                                    
      #endif                                                          
    }                                                                 
 #endif                                                               
                                                                      
  if ( executing->Start.prototype == THREAD_START_NUMERIC ) {         
4000f558:	c2 07 60 90 	ld  [ %i5 + 0x90 ], %g1                        
4000f55c:	80 a0 60 00 	cmp  %g1, 0                                    
4000f560:	02 80 00 10 	be  4000f5a0 <_Thread_Handler+0x9c>            
4000f564:	80 a0 60 01 	cmp  %g1, 1                                    
      (*(Thread_Entry_numeric) executing->Start.entry_point)(         
        executing->Start.numeric_argument                             
      );                                                              
  }                                                                   
  #if defined(RTEMS_POSIX_API)                                        
    else if ( executing->Start.prototype == THREAD_START_POINTER ) {  
4000f568:	22 80 00 13 	be,a   4000f5b4 <_Thread_Handler+0xb0>         <== ALWAYS TAKEN
4000f56c:	c2 07 60 8c 	ld  [ %i5 + 0x8c ], %g1                        
  }                                                                   
}                                                                     
                                                                      
static inline void _User_extensions_Thread_exitted( Thread_Control *executing )
{                                                                     
  _User_extensions_Iterate(                                           
4000f570:	90 10 00 1d 	mov  %i5, %o0                                  
4000f574:	13 10 00 2a 	sethi  %hi(0x4000a800), %o1                    
4000f578:	7f ff ed 4c 	call  4000aaa8 <_User_extensions_Iterate>      
4000f57c:	92 12 62 58 	or  %o1, 0x258, %o1	! 4000aa58 <_User_extensions_Thread_exitted_visitor>
   *  able to fit in a (void *).                                      
   */                                                                 
                                                                      
  _User_extensions_Thread_exitted( executing );                       
                                                                      
  _Internal_error_Occurred(                                           
4000f580:	90 10 20 00 	clr  %o0                                       
4000f584:	92 10 20 01 	mov  1, %o1                                    
4000f588:	7f ff e4 e1 	call  4000890c <_Internal_error_Occurred>      
4000f58c:	94 10 20 05 	mov  5, %o2                                    
     *  _init could be a weak symbol and we SHOULD test it but it isn't
     *  in any configuration I know of and it generates a warning on every
     *  RTEMS target configuration.  --joel (12 May 2007)             
     */                                                               
    if (doCons) /* && (volatile void *)_init) */ {                    
      INIT_NAME ();                                                   
4000f590:	40 00 3b 42 	call  4001e298 <_init>                         
4000f594:	01 00 00 00 	nop                                            
        _Thread_Enable_dispatch();                                    
      #endif                                                          
    }                                                                 
 #endif                                                               
                                                                      
  if ( executing->Start.prototype == THREAD_START_NUMERIC ) {         
4000f598:	10 bf ff f1 	b  4000f55c <_Thread_Handler+0x58>             
4000f59c:	c2 07 60 90 	ld  [ %i5 + 0x90 ], %g1                        
    executing->Wait.return_argument =                                 
      (*(Thread_Entry_numeric) executing->Start.entry_point)(         
4000f5a0:	c2 07 60 8c 	ld  [ %i5 + 0x8c ], %g1                        
4000f5a4:	9f c0 40 00 	call  %g1                                      
4000f5a8:	d0 07 60 98 	ld  [ %i5 + 0x98 ], %o0                        
      #endif                                                          
    }                                                                 
 #endif                                                               
                                                                      
  if ( executing->Start.prototype == THREAD_START_NUMERIC ) {         
    executing->Wait.return_argument =                                 
4000f5ac:	10 bf ff f1 	b  4000f570 <_Thread_Handler+0x6c>             
4000f5b0:	d0 27 60 28 	st  %o0, [ %i5 + 0x28 ]                        
      );                                                              
  }                                                                   
  #if defined(RTEMS_POSIX_API)                                        
    else if ( executing->Start.prototype == THREAD_START_POINTER ) {  
      executing->Wait.return_argument =                               
        (*(Thread_Entry_pointer) executing->Start.entry_point)(       
4000f5b4:	9f c0 40 00 	call  %g1                                      
4000f5b8:	d0 07 60 94 	ld  [ %i5 + 0x94 ], %o0                        
        executing->Start.numeric_argument                             
      );                                                              
  }                                                                   
  #if defined(RTEMS_POSIX_API)                                        
    else if ( executing->Start.prototype == THREAD_START_POINTER ) {  
      executing->Wait.return_argument =                               
4000f5bc:	10 bf ff ed 	b  4000f570 <_Thread_Handler+0x6c>             
4000f5c0:	d0 27 60 28 	st  %o0, [ %i5 + 0x28 ]                        
                                                                      

4000a180 <_Thread_Handler_initialization>: #if defined(RTEMS_SMP) #include <rtems/bspsmp.h> #endif void _Thread_Handler_initialization(void) {
4000a180:	9d e3 bf 98 	save  %sp, -104, %sp                           
  uint32_t ticks_per_timeslice =                                      
4000a184:	03 10 00 71 	sethi  %hi(0x4001c400), %g1                    
4000a188:	82 10 60 18 	or  %g1, 0x18, %g1	! 4001c418 <Configuration>  
  #if defined(RTEMS_MULTIPROCESSING)                                  
    uint32_t maximum_proxies =                                        
      _Configuration_MP_table->maximum_proxies;                       
  #endif                                                              
                                                                      
  if ( rtems_configuration_get_stack_allocate_hook() == NULL ||       
4000a18c:	c6 00 60 28 	ld  [ %g1 + 0x28 ], %g3                        
  #include <rtems/bspsmp.h>                                           
#endif                                                                
                                                                      
void _Thread_Handler_initialization(void)                             
{                                                                     
  uint32_t ticks_per_timeslice =                                      
4000a190:	fa 00 60 14 	ld  [ %g1 + 0x14 ], %i5                        
    rtems_configuration_get_ticks_per_timeslice();                    
  uint32_t maximum_extensions =                                       
4000a194:	f8 00 60 08 	ld  [ %g1 + 8 ], %i4                           
  #if defined(RTEMS_MULTIPROCESSING)                                  
    uint32_t maximum_proxies =                                        
      _Configuration_MP_table->maximum_proxies;                       
  #endif                                                              
                                                                      
  if ( rtems_configuration_get_stack_allocate_hook() == NULL ||       
4000a198:	80 a0 e0 00 	cmp  %g3, 0                                    
4000a19c:	02 80 00 1f 	be  4000a218 <_Thread_Handler_initialization+0x98><== NEVER TAKEN
4000a1a0:	c4 00 60 24 	ld  [ %g1 + 0x24 ], %g2                        
4000a1a4:	c6 00 60 2c 	ld  [ %g1 + 0x2c ], %g3                        
4000a1a8:	80 a0 e0 00 	cmp  %g3, 0                                    
4000a1ac:	02 80 00 1b 	be  4000a218 <_Thread_Handler_initialization+0x98>
4000a1b0:	80 a0 a0 00 	cmp  %g2, 0                                    
      INTERNAL_ERROR_CORE,                                            
      true,                                                           
      INTERNAL_ERROR_BAD_STACK_HOOK                                   
    );                                                                
                                                                      
  if ( stack_allocate_init_hook != NULL )                             
4000a1b4:	22 80 00 05 	be,a   4000a1c8 <_Thread_Handler_initialization+0x48>
4000a1b8:	03 10 00 7c 	sethi  %hi(0x4001f000), %g1                    
    (*stack_allocate_init_hook)( rtems_configuration_get_stack_space_size() );
4000a1bc:	9f c0 80 00 	call  %g2                                      
4000a1c0:	d0 00 60 04 	ld  [ %g1 + 4 ], %o0	! 4001f004 <_CPU_Null_fp_context+0x14>
                                                                      
  _Thread_Dispatch_necessary = false;                                 
4000a1c4:	03 10 00 7c 	sethi  %hi(0x4001f000), %g1                    
4000a1c8:	82 10 63 d0 	or  %g1, 0x3d0, %g1	! 4001f3d0 <_Per_CPU_Information>
4000a1cc:	c0 28 60 0c 	clrb  [ %g1 + 0xc ]                            
  _Thread_Executing         = NULL;                                   
4000a1d0:	c0 20 60 10 	clr  [ %g1 + 0x10 ]                            
  _Thread_Heir              = NULL;                                   
4000a1d4:	c0 20 60 14 	clr  [ %g1 + 0x14 ]                            
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )        
  _Thread_Allocated_fp      = NULL;                                   
#endif                                                                
                                                                      
  _Thread_Maximum_extensions = maximum_extensions;                    
4000a1d8:	03 10 00 7b 	sethi  %hi(0x4001ec00), %g1                    
4000a1dc:	f8 20 63 3c 	st  %i4, [ %g1 + 0x33c ]	! 4001ef3c <_Thread_Maximum_extensions>
                                                                      
  _Thread_Ticks_per_timeslice  = ticks_per_timeslice;                 
4000a1e0:	03 10 00 7b 	sethi  %hi(0x4001ec00), %g1                    
4000a1e4:	fa 20 62 20 	st  %i5, [ %g1 + 0x220 ]	! 4001ee20 <_Thread_Ticks_per_timeslice>
  #if defined(RTEMS_MULTIPROCESSING)                                  
    if ( _System_state_Is_multiprocessing )                           
      maximum_internal_threads += 1;                                  
  #endif                                                              
                                                                      
  _Objects_Initialize_information(                                    
4000a1e8:	82 10 20 08 	mov  8, %g1                                    
4000a1ec:	11 10 00 7b 	sethi  %hi(0x4001ec00), %o0                    
4000a1f0:	c2 23 a0 5c 	st  %g1, [ %sp + 0x5c ]                        
4000a1f4:	90 12 23 b0 	or  %o0, 0x3b0, %o0                            
4000a1f8:	92 10 20 01 	mov  1, %o1                                    
4000a1fc:	94 10 20 01 	mov  1, %o2                                    
4000a200:	96 10 20 01 	mov  1, %o3                                    
4000a204:	98 10 21 60 	mov  0x160, %o4                                
4000a208:	7f ff fb 6a 	call  40008fb0 <_Objects_Initialize_information>
4000a20c:	9a 10 20 00 	clr  %o5                                       
4000a210:	81 c7 e0 08 	ret                                            
4000a214:	81 e8 00 00 	restore                                        
      _Configuration_MP_table->maximum_proxies;                       
  #endif                                                              
                                                                      
  if ( rtems_configuration_get_stack_allocate_hook() == NULL ||       
       rtems_configuration_get_stack_free_hook() == NULL)             
    _Internal_error_Occurred(                                         
4000a218:	90 10 20 00 	clr  %o0                                       
4000a21c:	92 10 20 01 	mov  1, %o1                                    
4000a220:	7f ff f9 bb 	call  4000890c <_Internal_error_Occurred>      
4000a224:	94 10 20 0e 	mov  0xe, %o2                                  
                                                                      

40009fa4 <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) {
40009fa4:	9d e3 bf 98 	save  %sp, -104, %sp                           
40009fa8:	c2 07 a0 6c 	ld  [ %fp + 0x6c ], %g1                        
                                                                      
  /*                                                                  
   *  Zero out all the allocated memory fields                        
   */                                                                 
  for ( i=0 ; i <= THREAD_API_LAST ; i++ )                            
    the_thread->API_Extensions[i] = NULL;                             
40009fac:	c0 26 61 4c 	clr  [ %i1 + 0x14c ]                           
40009fb0:	c0 26 61 50 	clr  [ %i1 + 0x150 ]                           
                                                                      
  extensions_area = NULL;                                             
  the_thread->libc_reent = NULL;                                      
40009fb4:	c0 26 61 48 	clr  [ %i1 + 0x148 ]                           
  Thread_CPU_budget_algorithms          budget_algorithm,             
  Thread_CPU_budget_algorithm_callout   budget_callout,               
  uint32_t                              isr_level,                    
  Objects_Name                          name                          
)                                                                     
{                                                                     
40009fb8:	f8 07 a0 60 	ld  [ %fp + 0x60 ], %i4                        
40009fbc:	e0 00 40 00 	ld  [ %g1 ], %l0                               
    if ( !actual_stack_size || actual_stack_size < stack_size )       
      return false;                     /* stack allocation failed */ 
                                                                      
    stack = the_thread->Start.stack;                                  
  #else                                                               
    if ( !stack_area ) {                                              
40009fc0:	80 a6 a0 00 	cmp  %i2, 0                                    
40009fc4:	02 80 00 60 	be  4000a144 <_Thread_Initialize+0x1a0>        
40009fc8:	e2 0f a0 5f 	ldub  [ %fp + 0x5f ], %l1                      
      stack = the_thread->Start.stack;                                
      the_thread->Start.core_allocated_stack = true;                  
    } else {                                                          
      stack = stack_area;                                             
      actual_stack_size = stack_size;                                 
      the_thread->Start.core_allocated_stack = false;                 
40009fcc:	c0 2e 60 b0 	clrb  [ %i1 + 0xb0 ]                           
40009fd0:	90 10 00 1b 	mov  %i3, %o0                                  
  #endif                                                              
                                                                      
  /*                                                                  
   *  Allocate the extensions area for this thread                    
   */                                                                 
  if ( _Thread_Maximum_extensions ) {                                 
40009fd4:	37 10 00 7b 	sethi  %hi(0x4001ec00), %i3                    
40009fd8:	c2 06 e3 3c 	ld  [ %i3 + 0x33c ], %g1	! 4001ef3c <_Thread_Maximum_extensions>
  Stack_Control *the_stack,                                           
  void          *starting_address,                                    
  size_t         size                                                 
)                                                                     
{                                                                     
  the_stack->area = starting_address;                                 
40009fdc:	f4 26 60 b8 	st  %i2, [ %i1 + 0xb8 ]                        
  the_stack->size = size;                                             
40009fe0:	d0 26 60 b4 	st  %o0, [ %i1 + 0xb4 ]                        
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
40009fe4:	c0 26 60 50 	clr  [ %i1 + 0x50 ]                            
  the_watchdog->routine   = routine;                                  
40009fe8:	c0 26 60 64 	clr  [ %i1 + 0x64 ]                            
  the_watchdog->id        = id;                                       
40009fec:	c0 26 60 68 	clr  [ %i1 + 0x68 ]                            
40009ff0:	80 a0 60 00 	cmp  %g1, 0                                    
40009ff4:	12 80 00 40 	bne  4000a0f4 <_Thread_Initialize+0x150>       
40009ff8:	c0 26 60 6c 	clr  [ %i1 + 0x6c ]                            
      (_Thread_Maximum_extensions + 1) * sizeof( void * )             
    );                                                                
    if ( !extensions_area )                                           
      goto failed;                                                    
  }                                                                   
  the_thread->extensions = (void **) extensions_area;                 
40009ffc:	c0 26 61 54 	clr  [ %i1 + 0x154 ]                           
   *  Zero out all the allocated memory fields                        
   */                                                                 
  for ( i=0 ; i <= THREAD_API_LAST ; i++ )                            
    the_thread->API_Extensions[i] = NULL;                             
                                                                      
  extensions_area = NULL;                                             
4000a000:	b4 10 20 00 	clr  %i2                                       
   *  General initialization                                          
   */                                                                 
                                                                      
  the_thread->Start.is_preemptible   = is_preemptible;                
  the_thread->Start.budget_algorithm = budget_algorithm;              
  the_thread->Start.budget_callout   = budget_callout;                
4000a004:	c2 07 a0 64 	ld  [ %fp + 0x64 ], %g1                        
                                                                      
  /*                                                                  
   *  General initialization                                          
   */                                                                 
                                                                      
  the_thread->Start.is_preemptible   = is_preemptible;                
4000a008:	e2 2e 60 9c 	stb  %l1, [ %i1 + 0x9c ]                       
  the_thread->Start.budget_algorithm = budget_algorithm;              
4000a00c:	f8 26 60 a0 	st  %i4, [ %i1 + 0xa0 ]                        
  the_thread->Start.budget_callout   = budget_callout;                
                                                                      
  switch ( budget_algorithm ) {                                       
4000a010:	80 a7 20 02 	cmp  %i4, 2                                    
4000a014:	12 80 00 05 	bne  4000a028 <_Thread_Initialize+0x84>        
4000a018:	c2 26 60 a4 	st  %g1, [ %i1 + 0xa4 ]                        
    case THREAD_CPU_BUDGET_ALGORITHM_NONE:                            
    case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE:                 
      break;                                                          
    #if defined(RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE)          
      case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE:             
        the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;    
4000a01c:	03 10 00 7b 	sethi  %hi(0x4001ec00), %g1                    
4000a020:	c2 00 62 20 	ld  [ %g1 + 0x220 ], %g1	! 4001ee20 <_Thread_Ticks_per_timeslice>
4000a024:	c2 26 60 74 	st  %g1, [ %i1 + 0x74 ]                        
      case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:                       
	break;                                                               
    #endif                                                            
  }                                                                   
                                                                      
  the_thread->Start.isr_level         = isr_level;                    
4000a028:	c4 07 a0 68 	ld  [ %fp + 0x68 ], %g2                        
 */                                                                   
RTEMS_INLINE_ROUTINE void* _Scheduler_Allocate(                       
  Thread_Control    *the_thread                                       
)                                                                     
{                                                                     
  return _Scheduler.Operations.allocate( the_thread );                
4000a02c:	03 10 00 78 	sethi  %hi(0x4001e000), %g1                    
4000a030:	c2 00 63 7c 	ld  [ %g1 + 0x37c ], %g1	! 4001e37c <_Scheduler+0x18>
4000a034:	c4 26 60 a8 	st  %g2, [ %i1 + 0xa8 ]                        
                                                                      
  the_thread->current_state           = STATES_DORMANT;               
4000a038:	b6 10 20 01 	mov  1, %i3                                    
  the_thread->Wait.queue              = NULL;                         
4000a03c:	c0 26 60 44 	clr  [ %i1 + 0x44 ]                            
    #endif                                                            
  }                                                                   
                                                                      
  the_thread->Start.isr_level         = isr_level;                    
                                                                      
  the_thread->current_state           = STATES_DORMANT;               
4000a040:	f6 26 60 10 	st  %i3, [ %i1 + 0x10 ]                        
  the_thread->Wait.queue              = NULL;                         
  the_thread->resource_count          = 0;                            
4000a044:	c0 26 60 1c 	clr  [ %i1 + 0x1c ]                            
  the_thread->real_priority           = priority;                     
4000a048:	fa 26 60 18 	st  %i5, [ %i1 + 0x18 ]                        
  the_thread->Start.initial_priority  = priority;                     
4000a04c:	fa 26 60 ac 	st  %i5, [ %i1 + 0xac ]                        
4000a050:	9f c0 40 00 	call  %g1                                      
4000a054:	90 10 00 19 	mov  %i1, %o0                                  
  sched =_Scheduler_Allocate( the_thread );                           
  if ( !sched )                                                       
4000a058:	b8 92 20 00 	orcc  %o0, 0, %i4                              
4000a05c:	22 80 00 17 	be,a   4000a0b8 <_Thread_Initialize+0x114>     
4000a060:	d0 06 61 48 	ld  [ %i1 + 0x148 ], %o0                       
    goto failed;                                                      
  _Thread_Set_priority( the_thread, priority );                       
4000a064:	90 10 00 19 	mov  %i1, %o0                                  
4000a068:	40 00 01 e0 	call  4000a7e8 <_Thread_Set_priority>          
4000a06c:	92 10 00 1d 	mov  %i5, %o1                                  
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
4000a070:	c4 06 20 1c 	ld  [ %i0 + 0x1c ], %g2                        
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
4000a074:	c2 16 60 0a 	lduh  [ %i1 + 0xa ], %g1                       
                                                                      
static inline void _Timestamp64_implementation_Set_to_zero(           
  Timestamp64_Control *_time                                          
)                                                                     
{                                                                     
  *_time = 0;                                                         
4000a078:	c0 26 60 80 	clr  [ %i1 + 0x80 ]                            
4000a07c:	c0 26 60 84 	clr  [ %i1 + 0x84 ]                            
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
4000a080:	83 28 60 02 	sll  %g1, 2, %g1                               
4000a084:	f2 20 80 01 	st  %i1, [ %g2 + %g1 ]                         
    information,                                                      
    _Objects_Get_index( the_object->id ),                             
    the_object                                                        
  );                                                                  
                                                                      
  the_object->name = name;                                            
4000a088:	e0 26 60 0c 	st  %l0, [ %i1 + 0xc ]                         
 * @{                                                                 
 */                                                                   
                                                                      
static inline bool _User_extensions_Thread_create( Thread_Control *created )
{                                                                     
  User_extensions_Thread_create_context ctx = { created, true };      
4000a08c:	f2 27 bf f8 	st  %i1, [ %fp + -8 ]                          
4000a090:	f6 2f bf fc 	stb  %i3, [ %fp + -4 ]                         
                                                                      
  _User_extensions_Iterate( &ctx, _User_extensions_Thread_create_visitor );
4000a094:	90 07 bf f8 	add  %fp, -8, %o0                              
4000a098:	13 10 00 2a 	sethi  %hi(0x4000a800), %o1                    
4000a09c:	40 00 02 83 	call  4000aaa8 <_User_extensions_Iterate>      
4000a0a0:	92 12 61 80 	or  %o1, 0x180, %o1	! 4000a980 <_User_extensions_Thread_create_visitor>
   *  user extensions with dispatching enabled.  The Allocator        
   *  Mutex provides sufficient protection to let the user extensions 
   *  run safely.                                                     
   */                                                                 
  extension_status = _User_extensions_Thread_create( the_thread );    
  if ( extension_status )                                             
4000a0a4:	c2 0f bf fc 	ldub  [ %fp + -4 ], %g1                        
4000a0a8:	80 a0 60 00 	cmp  %g1, 0                                    
4000a0ac:	12 80 00 0f 	bne  4000a0e8 <_Thread_Initialize+0x144>       
4000a0b0:	b0 10 20 01 	mov  1, %i0                                    
    return true;                                                      
                                                                      
failed:                                                               
  _Workspace_Free( the_thread->libc_reent );                          
4000a0b4:	d0 06 61 48 	ld  [ %i1 + 0x148 ], %o0                       
4000a0b8:	40 00 03 dd 	call  4000b02c <_Workspace_Free>               
4000a0bc:	b0 10 20 00 	clr  %i0                                       
                                                                      
  for ( i=0 ; i <= THREAD_API_LAST ; i++ )                            
    _Workspace_Free( the_thread->API_Extensions[i] );                 
4000a0c0:	40 00 03 db 	call  4000b02c <_Workspace_Free>               
4000a0c4:	d0 06 61 4c 	ld  [ %i1 + 0x14c ], %o0                       
4000a0c8:	40 00 03 d9 	call  4000b02c <_Workspace_Free>               
4000a0cc:	d0 06 61 50 	ld  [ %i1 + 0x150 ], %o0                       
                                                                      
  _Workspace_Free( extensions_area );                                 
4000a0d0:	40 00 03 d7 	call  4000b02c <_Workspace_Free>               
4000a0d4:	90 10 00 1a 	mov  %i2, %o0                                  
                                                                      
  #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )      
    _Workspace_Free( fp_area );                                       
  #endif                                                              
                                                                      
   _Workspace_Free( sched );                                          
4000a0d8:	40 00 03 d5 	call  4000b02c <_Workspace_Free>               
4000a0dc:	90 10 00 1c 	mov  %i4, %o0                                  
                                                                      
   _Thread_Stack_Free( the_thread );                                  
4000a0e0:	40 00 01 fb 	call  4000a8cc <_Thread_Stack_Free>            
4000a0e4:	90 10 00 19 	mov  %i1, %o0                                  
4000a0e8:	b0 0e 20 ff 	and  %i0, 0xff, %i0                            
4000a0ec:	81 c7 e0 08 	ret                                            
4000a0f0:	81 e8 00 00 	restore                                        
                                                                      
  /*                                                                  
   *  Allocate the extensions area for this thread                    
   */                                                                 
  if ( _Thread_Maximum_extensions ) {                                 
    extensions_area = _Workspace_Allocate(                            
4000a0f4:	90 00 60 01 	add  %g1, 1, %o0                               
4000a0f8:	40 00 03 c5 	call  4000b00c <_Workspace_Allocate>           
4000a0fc:	91 2a 20 02 	sll  %o0, 2, %o0                               
      (_Thread_Maximum_extensions + 1) * sizeof( void * )             
    );                                                                
    if ( !extensions_area )                                           
4000a100:	b4 92 20 00 	orcc  %o0, 0, %i2                              
4000a104:	02 80 00 1d 	be  4000a178 <_Thread_Initialize+0x1d4>        
4000a108:	86 10 00 1a 	mov  %i2, %g3                                  
      goto failed;                                                    
  }                                                                   
  the_thread->extensions = (void **) extensions_area;                 
4000a10c:	f4 26 61 54 	st  %i2, [ %i1 + 0x154 ]                       
4000a110:	c8 06 e3 3c 	ld  [ %i3 + 0x33c ], %g4                       
   * create the extension long after tasks have been created          
   * so they cannot rely on the thread create user extension          
   * call.                                                            
   */                                                                 
  if ( the_thread->extensions ) {                                     
    for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )              
4000a114:	84 10 20 00 	clr  %g2                                       
      (_Thread_Maximum_extensions + 1) * sizeof( void * )             
    );                                                                
    if ( !extensions_area )                                           
      goto failed;                                                    
  }                                                                   
  the_thread->extensions = (void **) extensions_area;                 
4000a118:	10 80 00 03 	b  4000a124 <_Thread_Initialize+0x180>         
4000a11c:	82 10 20 00 	clr  %g1                                       
4000a120:	c6 06 61 54 	ld  [ %i1 + 0x154 ], %g3                       
   * so they cannot rely on the thread create user extension          
   * call.                                                            
   */                                                                 
  if ( the_thread->extensions ) {                                     
    for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )              
      the_thread->extensions[i] = NULL;                               
4000a124:	85 28 a0 02 	sll  %g2, 2, %g2                               
4000a128:	c0 20 c0 02 	clr  [ %g3 + %g2 ]                             
   * create the extension long after tasks have been created          
   * so they cannot rely on the thread create user extension          
   * call.                                                            
   */                                                                 
  if ( the_thread->extensions ) {                                     
    for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )              
4000a12c:	82 00 60 01 	inc  %g1                                       
4000a130:	80 a0 40 04 	cmp  %g1, %g4                                  
4000a134:	08 bf ff fb 	bleu  4000a120 <_Thread_Initialize+0x17c>      
4000a138:	84 10 00 01 	mov  %g1, %g2                                  
   *  General initialization                                          
   */                                                                 
                                                                      
  the_thread->Start.is_preemptible   = is_preemptible;                
  the_thread->Start.budget_algorithm = budget_algorithm;              
  the_thread->Start.budget_callout   = budget_callout;                
4000a13c:	10 bf ff b3 	b  4000a008 <_Thread_Initialize+0x64>          
4000a140:	c2 07 a0 64 	ld  [ %fp + 0x64 ], %g1                        
      return false;                     /* stack allocation failed */ 
                                                                      
    stack = the_thread->Start.stack;                                  
  #else                                                               
    if ( !stack_area ) {                                              
      actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
4000a144:	90 10 00 19 	mov  %i1, %o0                                  
4000a148:	40 00 01 d1 	call  4000a88c <_Thread_Stack_Allocate>        
4000a14c:	92 10 00 1b 	mov  %i3, %o1                                  
      if ( !actual_stack_size || actual_stack_size < stack_size )     
4000a150:	80 a2 00 1b 	cmp  %o0, %i3                                  
4000a154:	0a 80 00 07 	bcs  4000a170 <_Thread_Initialize+0x1cc>       
4000a158:	80 a2 20 00 	cmp  %o0, 0                                    
4000a15c:	02 80 00 05 	be  4000a170 <_Thread_Initialize+0x1cc>        <== NEVER TAKEN
4000a160:	82 10 20 01 	mov  1, %g1                                    
        return false;                     /* stack allocation failed */
                                                                      
      stack = the_thread->Start.stack;                                
4000a164:	f4 06 60 bc 	ld  [ %i1 + 0xbc ], %i2                        
      the_thread->Start.core_allocated_stack = true;                  
4000a168:	10 bf ff 9b 	b  40009fd4 <_Thread_Initialize+0x30>          
4000a16c:	c2 2e 60 b0 	stb  %g1, [ %i1 + 0xb0 ]                       
    stack = the_thread->Start.stack;                                  
  #else                                                               
    if ( !stack_area ) {                                              
      actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
      if ( !actual_stack_size || actual_stack_size < stack_size )     
        return false;                     /* stack allocation failed */
4000a170:	10 bf ff de 	b  4000a0e8 <_Thread_Initialize+0x144>         
4000a174:	b0 10 20 00 	clr  %i0                                       
  size_t               actual_stack_size = 0;                         
  void                *stack = NULL;                                  
  #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )      
    void              *fp_area;                                       
  #endif                                                              
  void                *sched = NULL;                                  
4000a178:	10 bf ff cf 	b  4000a0b4 <_Thread_Initialize+0x110>         
4000a17c:	b8 10 20 00 	clr  %i4                                       
                                                                      

4000a8cc <_Thread_Stack_Free>: #include <rtems/config.h> void _Thread_Stack_Free( Thread_Control *the_thread ) {
4000a8cc:	9d e3 bf a0 	save  %sp, -96, %sp                            
                                                                      
  #if defined(RTEMS_SCORE_THREAD_ENABLE_USER_PROVIDED_STACK_VIA_API)  
    /*                                                                
     *  If the API provided the stack space, then don't free it.      
     */                                                               
    if ( !the_thread->Start.core_allocated_stack )                    
4000a8d0:	c2 0e 20 b0 	ldub  [ %i0 + 0xb0 ], %g1                      
4000a8d4:	80 a0 60 00 	cmp  %g1, 0                                    
                                                                      
void _Thread_Stack_Free(                                              
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
  rtems_stack_free_hook stack_free_hook =                             
4000a8d8:	03 10 00 71 	sethi  %hi(0x4001c400), %g1                    
                                                                      
  #if defined(RTEMS_SCORE_THREAD_ENABLE_USER_PROVIDED_STACK_VIA_API)  
    /*                                                                
     *  If the API provided the stack space, then don't free it.      
     */                                                               
    if ( !the_thread->Start.core_allocated_stack )                    
4000a8dc:	02 80 00 04 	be  4000a8ec <_Thread_Stack_Free+0x20>         <== NEVER TAKEN
4000a8e0:	c2 00 60 44 	ld  [ %g1 + 0x44 ], %g1	! 4001c444 <Configuration+0x2c>
   * Call ONLY the CPU table stack free hook, or the                  
   * the RTEMS workspace free.  This is so the free                   
   * routine properly matches the allocation of the stack.            
   */                                                                 
                                                                      
  (*stack_free_hook)( the_thread->Start.Initial_stack.area );         
4000a8e4:	9f c0 40 00 	call  %g1                                      
4000a8e8:	d0 06 20 b8 	ld  [ %i0 + 0xb8 ], %o0                        
4000a8ec:	81 c7 e0 08 	ret                                            
4000a8f0:	81 e8 00 00 	restore                                        
                                                                      

4000f5c4 <_Thread_queue_Extract_fifo>: void _Thread_queue_Extract_fifo( Thread_queue_Control *the_thread_queue __attribute__((unused)), Thread_Control *the_thread ) {
4000f5c4:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
  ISR_Level level;                                                    
                                                                      
  _ISR_Disable( level );                                              
4000f5c8:	7f ff ca b7 	call  400020a4 <sparc_disable_interrupts>      <== NOT EXECUTED
4000f5cc:	01 00 00 00 	nop                                            <== NOT EXECUTED
4000f5d0:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
4000f5d4:	c4 06 60 10 	ld  [ %i1 + 0x10 ], %g2                        <== NOT EXECUTED
4000f5d8:	03 00 00 ef 	sethi  %hi(0x3bc00), %g1                       <== NOT EXECUTED
4000f5dc:	82 10 62 e0 	or  %g1, 0x2e0, %g1	! 3bee0 <PROM_START+0x3bee0><== NOT EXECUTED
                                                                      
  if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
4000f5e0:	80 88 80 01 	btst  %g2, %g1                                 <== NOT EXECUTED
4000f5e4:	02 80 00 1a 	be  4000f64c <_Thread_queue_Extract_fifo+0x88> <== NOT EXECUTED
4000f5e8:	01 00 00 00 	nop                                            <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
4000f5ec:	c4 06 40 00 	ld  [ %i1 ], %g2                               <== NOT EXECUTED
  previous       = the_node->previous;                                
4000f5f0:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           <== NOT EXECUTED
                                                                      
  _Chain_Extract_unprotected( &the_thread->Object.Node );             
                                                                      
  the_thread->Wait.queue = NULL;                                      
                                                                      
  if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {                 
4000f5f4:	c6 06 60 50 	ld  [ %i1 + 0x50 ], %g3                        <== NOT EXECUTED
  next->previous = previous;                                          
4000f5f8:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]                           <== NOT EXECUTED
  previous->next = next;                                              
4000f5fc:	c4 20 40 00 	st  %g2, [ %g1 ]                               <== NOT EXECUTED
4000f600:	80 a0 e0 02 	cmp  %g3, 2                                    <== NOT EXECUTED
4000f604:	02 80 00 08 	be  4000f624 <_Thread_queue_Extract_fifo+0x60> <== NOT EXECUTED
4000f608:	c0 26 60 44 	clr  [ %i1 + 0x44 ]                            <== NOT EXECUTED
    _ISR_Enable( level );                                             
4000f60c:	7f ff ca aa 	call  400020b4 <sparc_enable_interrupts>       <== NOT EXECUTED
4000f610:	b0 10 00 19 	mov  %i1, %i0                                  <== NOT EXECUTED
4000f614:	33 04 01 ff 	sethi  %hi(0x1007fc00), %i1                    <== NOT EXECUTED
4000f618:	b2 16 63 f8 	or  %i1, 0x3f8, %i1	! 1007fff8 <RAM_SIZE+0xfc7fff8><== NOT EXECUTED
4000f61c:	7f ff e9 3e 	call  40009b14 <_Thread_Clear_state>           <== NOT EXECUTED
4000f620:	81 e8 00 00 	restore                                        <== NOT EXECUTED
4000f624:	82 10 20 03 	mov  3, %g1                                    <== NOT EXECUTED
4000f628:	c2 26 60 50 	st  %g1, [ %i1 + 0x50 ]                        <== NOT EXECUTED
  } else {                                                            
    _Watchdog_Deactivate( &the_thread->Timer );                       
    _ISR_Enable( level );                                             
4000f62c:	7f ff ca a2 	call  400020b4 <sparc_enable_interrupts>       <== NOT EXECUTED
4000f630:	b0 10 00 19 	mov  %i1, %i0                                  <== NOT EXECUTED
    (void) _Watchdog_Remove( &the_thread->Timer );                    
4000f634:	7f ff ed c0 	call  4000ad34 <_Watchdog_Remove>              <== NOT EXECUTED
4000f638:	90 06 60 48 	add  %i1, 0x48, %o0                            <== NOT EXECUTED
4000f63c:	33 04 01 ff 	sethi  %hi(0x1007fc00), %i1                    <== NOT EXECUTED
4000f640:	b2 16 63 f8 	or  %i1, 0x3f8, %i1	! 1007fff8 <RAM_SIZE+0xfc7fff8><== NOT EXECUTED
4000f644:	7f ff e9 34 	call  40009b14 <_Thread_Clear_state>           <== NOT EXECUTED
4000f648:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  ISR_Level level;                                                    
                                                                      
  _ISR_Disable( level );                                              
                                                                      
  if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
    _ISR_Enable( level );                                             
4000f64c:	7f ff ca 9a 	call  400020b4 <sparc_enable_interrupts>       <== NOT EXECUTED
4000f650:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4000a728 <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) {
4000a728:	9d e3 bf 98 	save  %sp, -104, %sp                           
  /*                                                                  
   * Just in case the thread really wasn't blocked on a thread queue  
   * when we get here.                                                
   */                                                                 
  if ( !the_thread_queue )                                            
4000a72c:	80 a6 20 00 	cmp  %i0, 0                                    
4000a730:	02 80 00 13 	be  4000a77c <_Thread_queue_Requeue+0x54>      <== NEVER TAKEN
4000a734:	01 00 00 00 	nop                                            
                                                                      
  /*                                                                  
   * If queueing by FIFO, there is nothing to do. This only applies to
   * priority blocking discipline.                                    
   */                                                                 
  if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) {
4000a738:	fa 06 20 34 	ld  [ %i0 + 0x34 ], %i5                        
4000a73c:	80 a7 60 01 	cmp  %i5, 1                                    
4000a740:	02 80 00 04 	be  4000a750 <_Thread_queue_Requeue+0x28>      <== ALWAYS TAKEN
4000a744:	01 00 00 00 	nop                                            
4000a748:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000a74c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    Thread_queue_Control *tq = the_thread_queue;                      
    ISR_Level             level;                                      
    ISR_Level             level_ignored;                              
                                                                      
    _ISR_Disable( level );                                            
4000a750:	7f ff de 55 	call  400020a4 <sparc_disable_interrupts>      
4000a754:	01 00 00 00 	nop                                            
4000a758:	b8 10 00 08 	mov  %o0, %i4                                  
4000a75c:	c4 06 60 10 	ld  [ %i1 + 0x10 ], %g2                        
4000a760:	03 00 00 ef 	sethi  %hi(0x3bc00), %g1                       
4000a764:	82 10 62 e0 	or  %g1, 0x2e0, %g1	! 3bee0 <PROM_START+0x3bee0>
    if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
4000a768:	80 88 80 01 	btst  %g2, %g1                                 
4000a76c:	12 80 00 06 	bne  4000a784 <_Thread_queue_Requeue+0x5c>     <== ALWAYS TAKEN
4000a770:	90 10 00 18 	mov  %i0, %o0                                  
      _Thread_queue_Enter_critical_section( tq );                     
      _Thread_queue_Extract_priority_helper( tq, the_thread, true );  
      (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
    }                                                                 
    _ISR_Enable( level );                                             
4000a774:	7f ff de 50 	call  400020b4 <sparc_enable_interrupts>       
4000a778:	90 10 00 1c 	mov  %i4, %o0                                  
4000a77c:	81 c7 e0 08 	ret                                            
4000a780:	81 e8 00 00 	restore                                        
    ISR_Level             level_ignored;                              
                                                                      
    _ISR_Disable( level );                                            
    if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
      _Thread_queue_Enter_critical_section( tq );                     
      _Thread_queue_Extract_priority_helper( tq, the_thread, true );  
4000a784:	92 10 00 19 	mov  %i1, %o1                                  
4000a788:	94 10 20 01 	mov  1, %o2                                    
4000a78c:	40 00 0c 98 	call  4000d9ec <_Thread_queue_Extract_priority_helper>
4000a790:	fa 26 20 30 	st  %i5, [ %i0 + 0x30 ]                        
      (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
4000a794:	90 10 00 18 	mov  %i0, %o0                                  
4000a798:	92 10 00 19 	mov  %i1, %o1                                  
4000a79c:	7f ff ff 35 	call  4000a470 <_Thread_queue_Enqueue_priority>
4000a7a0:	94 07 bf fc 	add  %fp, -4, %o2                              
4000a7a4:	30 bf ff f4 	b,a   4000a774 <_Thread_queue_Requeue+0x4c>    
                                                                      

4000a7a8 <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored __attribute__((unused)) ) {
4000a7a8:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Thread_Control       *the_thread;                                   
  Objects_Locations     location;                                     
                                                                      
  the_thread = _Thread_Get( id, &location );                          
4000a7ac:	90 10 00 18 	mov  %i0, %o0                                  
4000a7b0:	7f ff fd d2 	call  40009ef8 <_Thread_Get>                   
4000a7b4:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
4000a7b8:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4000a7bc:	80 a0 60 00 	cmp  %g1, 0                                    
4000a7c0:	12 80 00 08 	bne  4000a7e0 <_Thread_queue_Timeout+0x38>     <== NEVER TAKEN
4000a7c4:	01 00 00 00 	nop                                            
#if defined(RTEMS_MULTIPROCESSING)                                    
    case OBJECTS_REMOTE:  /* impossible */                            
#endif                                                                
      break;                                                          
    case OBJECTS_LOCAL:                                               
      _Thread_queue_Process_timeout( the_thread );                    
4000a7c8:	40 00 0c c2 	call  4000dad0 <_Thread_queue_Process_timeout> 
4000a7cc:	01 00 00 00 	nop                                            
   *                                                                  
   * This routine decrements the thread dispatch level.               
   */                                                                 
  RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
  {                                                                   
    uint32_t level = _Thread_Dispatch_disable_level;                  
4000a7d0:	03 10 00 7b 	sethi  %hi(0x4001ec00), %g1                    
4000a7d4:	c4 00 62 c0 	ld  [ %g1 + 0x2c0 ], %g2	! 4001eec0 <_Thread_Dispatch_disable_level>
                                                                      
    --level;                                                          
4000a7d8:	84 00 bf ff 	add  %g2, -1, %g2                              
    _Thread_Dispatch_disable_level = level;                           
4000a7dc:	c4 20 62 c0 	st  %g2, [ %g1 + 0x2c0 ]                       
4000a7e0:	81 c7 e0 08 	ret                                            
4000a7e4:	81 e8 00 00 	restore                                        
                                                                      

400178f0 <_Timer_server_Body>: * @a arg points to the corresponding timer server control block. */ static rtems_task _Timer_server_Body( rtems_task_argument arg ) {
400178f0:	9d e3 bf 88 	save  %sp, -120, %sp                           
400178f4:	21 10 00 f5 	sethi  %hi(0x4003d400), %l0                    
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
400178f8:	a4 07 bf e8 	add  %fp, -24, %l2                             
400178fc:	b4 07 bf ec 	add  %fp, -20, %i2                             
40017900:	b8 07 bf f4 	add  %fp, -12, %i4                             
40017904:	a2 07 bf f8 	add  %fp, -8, %l1                              
40017908:	33 10 00 f4 	sethi  %hi(0x4003d000), %i1                    
4001790c:	27 10 00 f5 	sethi  %hi(0x4003d400), %l3                    
40017910:	f4 27 bf e8 	st  %i2, [ %fp + -24 ]                         
  head->previous = NULL;                                              
40017914:	c0 27 bf ec 	clr  [ %fp + -20 ]                             
  tail->previous = head;                                              
40017918:	e4 27 bf f0 	st  %l2, [ %fp + -16 ]                         
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
4001791c:	e2 27 bf f4 	st  %l1, [ %fp + -12 ]                         
  head->previous = NULL;                                              
40017920:	c0 27 bf f8 	clr  [ %fp + -8 ]                              
  tail->previous = head;                                              
40017924:	f8 27 bf fc 	st  %i4, [ %fp + -4 ]                          
40017928:	a0 14 21 58 	or  %l0, 0x158, %l0                            
4001792c:	b6 06 20 30 	add  %i0, 0x30, %i3                            
40017930:	b2 16 63 b8 	or  %i1, 0x3b8, %i1                            
40017934:	ba 06 20 68 	add  %i0, 0x68, %i5                            
40017938:	a6 14 e0 70 	or  %l3, 0x70, %l3                             
4001793c:	ac 06 20 08 	add  %i0, 8, %l6                               
40017940:	aa 06 20 40 	add  %i0, 0x40, %l5                            
        _Thread_Set_state( ts->thread, STATES_DELAYING );             
        _Timer_server_Reset_interval_system_watchdog( ts );           
        _Timer_server_Reset_tod_system_watchdog( ts );                
      _Thread_Enable_dispatch();                                      
                                                                      
      ts->active = true;                                              
40017944:	a8 10 20 01 	mov  1, %l4                                    
{                                                                     
  /*                                                                  
   *  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;                                    
40017948:	e4 26 20 78 	st  %l2, [ %i0 + 0x78 ]                        
static void _Timer_server_Process_interval_watchdogs(                 
  Timer_server_Watchdogs *watchdogs,                                  
  Chain_Control *fire_chain                                           
)                                                                     
{                                                                     
  Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;            
4001794c:	c2 04 00 00 	ld  [ %l0 ], %g1                               
                                                                      
  /*                                                                  
   *  We assume adequate unsigned arithmetic here.                    
   */                                                                 
  Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;      
40017950:	d2 06 20 3c 	ld  [ %i0 + 0x3c ], %o1                        
                                                                      
  watchdogs->last_snapshot = snapshot;                                
                                                                      
  _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );  
40017954:	90 10 00 1b 	mov  %i3, %o0                                  
40017958:	92 20 40 09 	sub  %g1, %o1, %o1                             
4001795c:	94 10 00 1c 	mov  %i4, %o2                                  
  /*                                                                  
   *  We assume adequate unsigned arithmetic here.                    
   */                                                                 
  Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;      
                                                                      
  watchdogs->last_snapshot = snapshot;                                
40017960:	c2 26 20 3c 	st  %g1, [ %i0 + 0x3c ]                        
                                                                      
  _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );  
40017964:	40 00 12 35 	call  4001c238 <_Watchdog_Adjust_to_chain>     
40017968:	01 00 00 00 	nop                                            
4001796c:	d0 1e 40 00 	ldd  [ %i1 ], %o0                              
40017970:	94 10 20 00 	clr  %o2                                       
40017974:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
40017978:	40 00 51 6b 	call  4002bf24 <__divdi3>                      
4001797c:	96 12 e2 00 	or  %o3, 0x200, %o3	! 3b9aca00 <RAM_SIZE+0x3b5aca00>
  Timer_server_Watchdogs *watchdogs,                                  
  Chain_Control *fire_chain                                           
)                                                                     
{                                                                     
  Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
  Watchdog_Interval last_snapshot = watchdogs->last_snapshot;         
40017980:	d4 06 20 74 	ld  [ %i0 + 0x74 ], %o2                        
  /*                                                                  
   *  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 ) {                                   
40017984:	80 a2 40 0a 	cmp  %o1, %o2                                  
40017988:	18 80 00 2b 	bgu  40017a34 <_Timer_server_Body+0x144>       
4001798c:	ae 10 00 09 	mov  %o1, %l7                                  
     *  TOD has been set forward.                                     
     */                                                               
    delta = snapshot - last_snapshot;                                 
    _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
                                                                      
  } else if ( snapshot < last_snapshot ) {                            
40017990:	80 a2 40 0a 	cmp  %o1, %o2                                  
40017994:	0a 80 00 20 	bcs  40017a14 <_Timer_server_Body+0x124>       
40017998:	90 10 00 1d 	mov  %i5, %o0                                  
      */                                                              
     delta = last_snapshot - snapshot;                                
     _Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta ); 
  }                                                                   
                                                                      
  watchdogs->last_snapshot = snapshot;                                
4001799c:	ee 26 20 74 	st  %l7, [ %i0 + 0x74 ]                        
}                                                                     
                                                                      
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{                                                                     
  while ( true ) {                                                    
    Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
400179a0:	d0 06 20 78 	ld  [ %i0 + 0x78 ], %o0                        
400179a4:	40 00 02 c2 	call  400184ac <_Chain_Get>                    
400179a8:	01 00 00 00 	nop                                            
                                                                      
    if ( timer == NULL ) {                                            
400179ac:	92 92 20 00 	orcc  %o0, 0, %o1                              
400179b0:	02 80 00 10 	be  400179f0 <_Timer_server_Body+0x100>        
400179b4:	01 00 00 00 	nop                                            
static void _Timer_server_Insert_timer(                               
  Timer_server_Control *ts,                                           
  Timer_Control *timer                                                
)                                                                     
{                                                                     
  if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {                 
400179b8:	c2 02 60 38 	ld  [ %o1 + 0x38 ], %g1                        
400179bc:	80 a0 60 01 	cmp  %g1, 1                                    
400179c0:	02 80 00 19 	be  40017a24 <_Timer_server_Body+0x134>        
400179c4:	80 a0 60 03 	cmp  %g1, 3                                    
    _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
  } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {       
400179c8:	12 bf ff f6 	bne  400179a0 <_Timer_server_Body+0xb0>        <== NEVER TAKEN
400179cc:	92 02 60 10 	add  %o1, 0x10, %o1                            
    _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );     
400179d0:	40 00 12 46 	call  4001c2e8 <_Watchdog_Insert>              
400179d4:	90 10 00 1d 	mov  %i5, %o0                                  
}                                                                     
                                                                      
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{                                                                     
  while ( true ) {                                                    
    Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
400179d8:	d0 06 20 78 	ld  [ %i0 + 0x78 ], %o0                        
400179dc:	40 00 02 b4 	call  400184ac <_Chain_Get>                    
400179e0:	01 00 00 00 	nop                                            
                                                                      
    if ( timer == NULL ) {                                            
400179e4:	92 92 20 00 	orcc  %o0, 0, %o1                              
400179e8:	32 bf ff f5 	bne,a   400179bc <_Timer_server_Body+0xcc>     <== NEVER TAKEN
400179ec:	c2 02 60 38 	ld  [ %o1 + 0x38 ], %g1                        <== NOT EXECUTED
     *  of zero it will be processed in the next iteration of the timer server
     *  body loop.                                                    
     */                                                               
    _Timer_server_Process_insertions( ts );                           
                                                                      
    _ISR_Disable( level );                                            
400179f0:	7f ff dd e8 	call  4000f190 <sparc_disable_interrupts>      
400179f4:	01 00 00 00 	nop                                            
    if ( _Chain_Is_empty( insert_chain ) ) {                          
400179f8:	c2 07 bf e8 	ld  [ %fp + -24 ], %g1                         
400179fc:	80 a0 40 1a 	cmp  %g1, %i2                                  
40017a00:	02 80 00 12 	be  40017a48 <_Timer_server_Body+0x158>        <== ALWAYS TAKEN
40017a04:	01 00 00 00 	nop                                            
      ts->insert_chain = NULL;                                        
      _ISR_Enable( level );                                           
                                                                      
      break;                                                          
    } else {                                                          
      _ISR_Enable( level );                                           
40017a08:	7f ff dd e6 	call  4000f1a0 <sparc_enable_interrupts>       <== NOT EXECUTED
40017a0c:	01 00 00 00 	nop                                            <== NOT EXECUTED
40017a10:	30 bf ff cf 	b,a   4001794c <_Timer_server_Body+0x5c>       <== NOT EXECUTED
     /*                                                               
      *  The current TOD is before the last TOD which indicates that  
      *  TOD has been set backwards.                                  
      */                                                              
     delta = last_snapshot - snapshot;                                
     _Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta ); 
40017a14:	92 10 20 01 	mov  1, %o1	! 1 <PROM_START+0x1>               
40017a18:	40 00 11 d8 	call  4001c178 <_Watchdog_Adjust>              
40017a1c:	94 22 80 17 	sub  %o2, %l7, %o2                             
40017a20:	30 bf ff df 	b,a   4001799c <_Timer_server_Body+0xac>       
  Timer_server_Control *ts,                                           
  Timer_Control *timer                                                
)                                                                     
{                                                                     
  if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {                 
    _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
40017a24:	90 10 00 1b 	mov  %i3, %o0                                  
40017a28:	40 00 12 30 	call  4001c2e8 <_Watchdog_Insert>              
40017a2c:	92 02 60 10 	add  %o1, 0x10, %o1                            
40017a30:	30 bf ff dc 	b,a   400179a0 <_Timer_server_Body+0xb0>       
    /*                                                                
     *  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 );
40017a34:	92 22 40 0a 	sub  %o1, %o2, %o1                             
40017a38:	90 10 00 1d 	mov  %i5, %o0                                  
40017a3c:	40 00 11 ff 	call  4001c238 <_Watchdog_Adjust_to_chain>     
40017a40:	94 10 00 1c 	mov  %i4, %o2                                  
40017a44:	30 bf ff d6 	b,a   4001799c <_Timer_server_Body+0xac>       
     */                                                               
    _Timer_server_Process_insertions( ts );                           
                                                                      
    _ISR_Disable( level );                                            
    if ( _Chain_Is_empty( insert_chain ) ) {                          
      ts->insert_chain = NULL;                                        
40017a48:	c0 26 20 78 	clr  [ %i0 + 0x78 ]                            
      _ISR_Enable( level );                                           
40017a4c:	7f ff dd d5 	call  4000f1a0 <sparc_enable_interrupts>       
40017a50:	01 00 00 00 	nop                                            
  _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 ) ) {                          
40017a54:	c2 07 bf f4 	ld  [ %fp + -12 ], %g1                         
40017a58:	80 a0 40 11 	cmp  %g1, %l1                                  
40017a5c:	12 80 00 0c 	bne  40017a8c <_Timer_server_Body+0x19c>       
40017a60:	01 00 00 00 	nop                                            
40017a64:	30 80 00 13 	b,a   40017ab0 <_Timer_server_Body+0x1c0>      
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *old_first = head->next;                                 
  Chain_Node *new_first = old_first->next;                            
                                                                      
  head->next = new_first;                                             
  new_first->previous = head;                                         
40017a68:	f8 20 60 04 	st  %i4, [ %g1 + 4 ]                           
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *old_first = head->next;                                 
  Chain_Node *new_first = old_first->next;                            
                                                                      
  head->next = new_first;                                             
40017a6c:	c2 27 bf f4 	st  %g1, [ %fp + -12 ]                         
         *  service routine may remove a watchdog from the chain.     
         */                                                           
        _ISR_Disable( level );                                        
        watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
        if ( watchdog != NULL ) {                                     
          watchdog->state = WATCHDOG_INACTIVE;                        
40017a70:	c0 25 e0 08 	clr  [ %l7 + 8 ]                               
          _ISR_Enable( level );                                       
40017a74:	7f ff dd cb 	call  4000f1a0 <sparc_enable_interrupts>       
40017a78:	01 00 00 00 	nop                                            
        /*                                                            
         *  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 );    
40017a7c:	d0 05 e0 20 	ld  [ %l7 + 0x20 ], %o0                        
40017a80:	c2 05 e0 1c 	ld  [ %l7 + 0x1c ], %g1                        
40017a84:	9f c0 40 00 	call  %g1                                      
40017a88:	d2 05 e0 24 	ld  [ %l7 + 0x24 ], %o1                        
                                                                      
        /*                                                            
         *  It is essential that interrupts are disable here since an interrupt
         *  service routine may remove a watchdog from the chain.     
         */                                                           
        _ISR_Disable( level );                                        
40017a8c:	7f ff dd c1 	call  4000f190 <sparc_disable_interrupts>      
40017a90:	01 00 00 00 	nop                                            
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(        
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_head( the_chain )->next;                    
40017a94:	ee 07 bf f4 	ld  [ %fp + -12 ], %l7                         
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(              
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  if ( !_Chain_Is_empty(the_chain))                                   
40017a98:	80 a5 c0 11 	cmp  %l7, %l1                                  
40017a9c:	32 bf ff f3 	bne,a   40017a68 <_Timer_server_Body+0x178>    
40017aa0:	c2 05 c0 00 	ld  [ %l7 ], %g1                               
        watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
        if ( watchdog != NULL ) {                                     
          watchdog->state = WATCHDOG_INACTIVE;                        
          _ISR_Enable( level );                                       
        } else {                                                      
          _ISR_Enable( level );                                       
40017aa4:	7f ff dd bf 	call  4000f1a0 <sparc_enable_interrupts>       
40017aa8:	01 00 00 00 	nop                                            
40017aac:	30 bf ff a7 	b,a   40017948 <_Timer_server_Body+0x58>       
         *  the active flag of the timer server is true.              
         */                                                           
        (*watchdog->routine)( watchdog->id, watchdog->user_data );    
      }                                                               
    } else {                                                          
      ts->active = false;                                             
40017ab0:	c0 2e 20 7c 	clrb  [ %i0 + 0x7c ]                           
   *                                                                  
   * This rountine increments the thread dispatch level               
   */                                                                 
  RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
  {                                                                   
    uint32_t level = _Thread_Dispatch_disable_level;                  
40017ab4:	c2 04 c0 00 	ld  [ %l3 ], %g1                               
                                                                      
    ++level;                                                          
40017ab8:	82 00 60 01 	inc  %g1                                       
    _Thread_Dispatch_disable_level = level;                           
40017abc:	c2 24 c0 00 	st  %g1, [ %l3 ]                               
                                                                      
      /*                                                              
       *  Block until there is something to do.                       
       */                                                             
      _Thread_Disable_dispatch();                                     
        _Thread_Set_state( ts->thread, STATES_DELAYING );             
40017ac0:	d0 06 00 00 	ld  [ %i0 ], %o0                               
40017ac4:	40 00 10 c1 	call  4001bdc8 <_Thread_Set_state>             
40017ac8:	92 10 20 08 	mov  8, %o1                                    
        _Timer_server_Reset_interval_system_watchdog( ts );           
40017acc:	7f ff ff 07 	call  400176e8 <_Timer_server_Reset_interval_system_watchdog>
40017ad0:	90 10 00 18 	mov  %i0, %o0                                  
        _Timer_server_Reset_tod_system_watchdog( ts );                
40017ad4:	7f ff ff 19 	call  40017738 <_Timer_server_Reset_tod_system_watchdog>
40017ad8:	90 10 00 18 	mov  %i0, %o0                                  
      _Thread_Enable_dispatch();                                      
40017adc:	40 00 0e 4d 	call  4001b410 <_Thread_Enable_dispatch>       
40017ae0:	01 00 00 00 	nop                                            
                                                                      
static void _Timer_server_Stop_interval_system_watchdog(              
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );        
40017ae4:	90 10 00 16 	mov  %l6, %o0                                  
        _Thread_Set_state( ts->thread, STATES_DELAYING );             
        _Timer_server_Reset_interval_system_watchdog( ts );           
        _Timer_server_Reset_tod_system_watchdog( ts );                
      _Thread_Enable_dispatch();                                      
                                                                      
      ts->active = true;                                              
40017ae8:	e8 2e 20 7c 	stb  %l4, [ %i0 + 0x7c ]                       
                                                                      
static void _Timer_server_Stop_interval_system_watchdog(              
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );        
40017aec:	40 00 12 5e 	call  4001c464 <_Watchdog_Remove>              
40017af0:	01 00 00 00 	nop                                            
                                                                      
static void _Timer_server_Stop_tod_system_watchdog(                   
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );             
40017af4:	40 00 12 5c 	call  4001c464 <_Watchdog_Remove>              
40017af8:	90 10 00 15 	mov  %l5, %o0                                  
40017afc:	30 bf ff 93 	b,a   40017948 <_Timer_server_Body+0x58>       
                                                                      

40017788 <_Timer_server_Schedule_operation_method>: static void _Timer_server_Schedule_operation_method( Timer_server_Control *ts, Timer_Control *timer ) {
40017788:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if ( ts->insert_chain == NULL ) {                                   
4001778c:	c2 06 20 78 	ld  [ %i0 + 0x78 ], %g1                        
40017790:	80 a0 60 00 	cmp  %g1, 0                                    
40017794:	02 80 00 05 	be  400177a8 <_Timer_server_Schedule_operation_method+0x20>
40017798:	ba 10 00 19 	mov  %i1, %i5                                  
     *  server is not preemptible, so we must be in interrupt context here.  No
     *  thread dispatch will happen until the timer server finishes its
     *  critical section.  We have to use the protected chain methods because
     *  we may be interrupted by a higher priority interrupt.         
     */                                                               
    _Chain_Append( ts->insert_chain, &timer->Object.Node );           
4001779c:	f0 06 20 78 	ld  [ %i0 + 0x78 ], %i0                        
400177a0:	40 00 03 38 	call  40018480 <_Chain_Append>                 
400177a4:	81 e8 00 00 	restore                                        
   *                                                                  
   * This rountine increments the thread dispatch level               
   */                                                                 
  RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
  {                                                                   
    uint32_t level = _Thread_Dispatch_disable_level;                  
400177a8:	03 10 00 f5 	sethi  %hi(0x4003d400), %g1                    
400177ac:	c4 00 60 70 	ld  [ %g1 + 0x70 ], %g2	! 4003d470 <_Thread_Dispatch_disable_level>
                                                                      
    ++level;                                                          
400177b0:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
400177b4:	c4 20 60 70 	st  %g2, [ %g1 + 0x70 ]                        
   *  being inserted.  This could result in an integer overflow.      
   */                                                                 
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {                 
400177b8:	c2 06 60 38 	ld  [ %i1 + 0x38 ], %g1                        
400177bc:	80 a0 60 01 	cmp  %g1, 1                                    
400177c0:	02 80 00 2b 	be  4001786c <_Timer_server_Schedule_operation_method+0xe4>
400177c4:	80 a0 60 03 	cmp  %g1, 3                                    
    _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
                                                                      
    if ( !ts->active ) {                                              
      _Timer_server_Reset_interval_system_watchdog( ts );             
    }                                                                 
  } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {       
400177c8:	02 80 00 04 	be  400177d8 <_Timer_server_Schedule_operation_method+0x50>
400177cc:	01 00 00 00 	nop                                            
    if ( !ts->active ) {                                              
      _Timer_server_Reset_tod_system_watchdog( ts );                  
    }                                                                 
  }                                                                   
                                                                      
  _Thread_Enable_dispatch();                                          
400177d0:	40 00 0f 10 	call  4001b410 <_Thread_Enable_dispatch>       
400177d4:	81 e8 00 00 	restore                                        
  } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {       
    /*                                                                
     *  We have to advance the last known seconds value of the server and update
     *  the watchdog chain accordingly.                               
     */                                                               
    _ISR_Disable( level );                                            
400177d8:	7f ff de 6e 	call  4000f190 <sparc_disable_interrupts>      
400177dc:	01 00 00 00 	nop                                            
400177e0:	b8 10 00 08 	mov  %o0, %i4                                  
    snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();        
400177e4:	03 10 00 f4 	sethi  %hi(0x4003d000), %g1                    
400177e8:	d0 18 63 b8 	ldd  [ %g1 + 0x3b8 ], %o0	! 4003d3b8 <_TOD>    
400177ec:	94 10 20 00 	clr  %o2                                       
400177f0:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
400177f4:	40 00 51 cc 	call  4002bf24 <__divdi3>                      
400177f8:	96 12 e2 00 	or  %o3, 0x200, %o3	! 3b9aca00 <RAM_SIZE+0x3b5aca00>
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(        
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_head( the_chain )->next;                    
400177fc:	c2 06 20 68 	ld  [ %i0 + 0x68 ], %g1                        
    last_snapshot = ts->TOD_watchdogs.last_snapshot;                  
40017800:	c4 06 20 74 	ld  [ %i0 + 0x74 ], %g2                        
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
40017804:	86 06 20 6c 	add  %i0, 0x6c, %g3                            
    if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {             
40017808:	80 a0 40 03 	cmp  %g1, %g3                                  
4001780c:	02 80 00 0a 	be  40017834 <_Timer_server_Schedule_operation_method+0xac>
40017810:	80 a2 40 02 	cmp  %o1, %g2                                  
      first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );   
      delta_interval = first_watchdog->delta_interval;                
      if ( snapshot > last_snapshot ) {                               
40017814:	08 80 00 34 	bleu  400178e4 <_Timer_server_Schedule_operation_method+0x15c>
40017818:	c8 00 60 10 	ld  [ %g1 + 0x10 ], %g4                        
        /*                                                            
         *  We advanced in time.                                      
         */                                                           
        delta = snapshot - last_snapshot;                             
4001781c:	84 22 40 02 	sub  %o1, %g2, %g2                             
        if (delta_interval > delta) {                                 
40017820:	80 a1 00 02 	cmp  %g4, %g2                                  
40017824:	08 80 00 03 	bleu  40017830 <_Timer_server_Schedule_operation_method+0xa8><== NEVER TAKEN
40017828:	86 10 20 00 	clr  %g3                                       
          delta_interval -= delta;                                    
4001782c:	86 21 00 02 	sub  %g4, %g2, %g3                             
         *  Someone put us in the past.                               
         */                                                           
        delta = last_snapshot - snapshot;                             
        delta_interval += delta;                                      
      }                                                               
      first_watchdog->delta_interval = delta_interval;                
40017830:	c6 20 60 10 	st  %g3, [ %g1 + 0x10 ]                        
    }                                                                 
    ts->TOD_watchdogs.last_snapshot = snapshot;                       
40017834:	d2 26 20 74 	st  %o1, [ %i0 + 0x74 ]                        
    _ISR_Enable( level );                                             
40017838:	7f ff de 5a 	call  4000f1a0 <sparc_enable_interrupts>       
4001783c:	90 10 00 1c 	mov  %i4, %o0                                  
                                                                      
    _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );     
40017840:	90 06 20 68 	add  %i0, 0x68, %o0                            
40017844:	40 00 12 a9 	call  4001c2e8 <_Watchdog_Insert>              
40017848:	92 07 60 10 	add  %i5, 0x10, %o1                            
                                                                      
    if ( !ts->active ) {                                              
4001784c:	c2 0e 20 7c 	ldub  [ %i0 + 0x7c ], %g1                      
40017850:	80 a0 60 00 	cmp  %g1, 0                                    
40017854:	12 bf ff df 	bne  400177d0 <_Timer_server_Schedule_operation_method+0x48>
40017858:	01 00 00 00 	nop                                            
      _Timer_server_Reset_tod_system_watchdog( ts );                  
4001785c:	7f ff ff b7 	call  40017738 <_Timer_server_Reset_tod_system_watchdog>
40017860:	90 10 00 18 	mov  %i0, %o0                                  
    }                                                                 
  }                                                                   
                                                                      
  _Thread_Enable_dispatch();                                          
40017864:	40 00 0e eb 	call  4001b410 <_Thread_Enable_dispatch>       
40017868:	81 e8 00 00 	restore                                        
  if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {                 
    /*                                                                
     *  We have to advance the last known ticks value of the server and update
     *  the watchdog chain accordingly.                               
     */                                                               
    _ISR_Disable( level );                                            
4001786c:	7f ff de 49 	call  4000f190 <sparc_disable_interrupts>      
40017870:	01 00 00 00 	nop                                            
    snapshot = _Watchdog_Ticks_since_boot;                            
40017874:	05 10 00 f5 	sethi  %hi(0x4003d400), %g2                    
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(        
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_head( the_chain )->next;                    
40017878:	c2 06 20 30 	ld  [ %i0 + 0x30 ], %g1                        
4001787c:	c4 00 a1 58 	ld  [ %g2 + 0x158 ], %g2                       
    last_snapshot = ts->Interval_watchdogs.last_snapshot;             
40017880:	c8 06 20 3c 	ld  [ %i0 + 0x3c ], %g4                        
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
40017884:	86 06 20 34 	add  %i0, 0x34, %g3                            
    if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {        
40017888:	80 a0 40 03 	cmp  %g1, %g3                                  
4001788c:	02 80 00 08 	be  400178ac <_Timer_server_Schedule_operation_method+0x124>
40017890:	88 20 80 04 	sub  %g2, %g4, %g4                             
      /*                                                              
       *  We assume adequate unsigned arithmetic here.                
       */                                                             
      delta = snapshot - last_snapshot;                               
                                                                      
      delta_interval = first_watchdog->delta_interval;                
40017894:	f8 00 60 10 	ld  [ %g1 + 0x10 ], %i4                        
      if (delta_interval > delta) {                                   
40017898:	80 a1 00 1c 	cmp  %g4, %i4                                  
4001789c:	1a 80 00 03 	bcc  400178a8 <_Timer_server_Schedule_operation_method+0x120>
400178a0:	86 10 20 00 	clr  %g3                                       
        delta_interval -= delta;                                      
400178a4:	86 27 00 04 	sub  %i4, %g4, %g3                             
      } else {                                                        
        delta_interval = 0;                                           
      }                                                               
      first_watchdog->delta_interval = delta_interval;                
400178a8:	c6 20 60 10 	st  %g3, [ %g1 + 0x10 ]                        
    }                                                                 
    ts->Interval_watchdogs.last_snapshot = snapshot;                  
400178ac:	c4 26 20 3c 	st  %g2, [ %i0 + 0x3c ]                        
    _ISR_Enable( level );                                             
400178b0:	7f ff de 3c 	call  4000f1a0 <sparc_enable_interrupts>       
400178b4:	01 00 00 00 	nop                                            
                                                                      
    _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
400178b8:	90 06 20 30 	add  %i0, 0x30, %o0                            
400178bc:	40 00 12 8b 	call  4001c2e8 <_Watchdog_Insert>              
400178c0:	92 07 60 10 	add  %i5, 0x10, %o1                            
                                                                      
    if ( !ts->active ) {                                              
400178c4:	c2 0e 20 7c 	ldub  [ %i0 + 0x7c ], %g1                      
400178c8:	80 a0 60 00 	cmp  %g1, 0                                    
400178cc:	12 bf ff c1 	bne  400177d0 <_Timer_server_Schedule_operation_method+0x48>
400178d0:	01 00 00 00 	nop                                            
      _Timer_server_Reset_interval_system_watchdog( ts );             
400178d4:	7f ff ff 85 	call  400176e8 <_Timer_server_Reset_interval_system_watchdog>
400178d8:	90 10 00 18 	mov  %i0, %o0                                  
    if ( !ts->active ) {                                              
      _Timer_server_Reset_tod_system_watchdog( ts );                  
    }                                                                 
  }                                                                   
                                                                      
  _Thread_Enable_dispatch();                                          
400178dc:	40 00 0e cd 	call  4001b410 <_Thread_Enable_dispatch>       
400178e0:	81 e8 00 00 	restore                                        
        }                                                             
      } else {                                                        
        /*                                                            
         *  Someone put us in the past.                               
         */                                                           
        delta = last_snapshot - snapshot;                             
400178e4:	84 01 00 02 	add  %g4, %g2, %g2                             
        delta_interval += delta;                                      
400178e8:	10 bf ff d2 	b  40017830 <_Timer_server_Schedule_operation_method+0xa8>
400178ec:	86 20 80 09 	sub  %g2, %o1, %g3                             
                                                                      

4000c498 <_Timespec_Add_to>: ) { uint32_t seconds = add->tv_sec; /* Add the basics */ time->tv_sec += add->tv_sec;
4000c498:	d8 02 00 00 	ld  [ %o0 ], %o4                               
uint32_t _Timespec_Add_to(                                            
  struct timespec       *time,                                        
  const struct timespec *add                                          
)                                                                     
{                                                                     
  uint32_t seconds = add->tv_sec;                                     
4000c49c:	c4 02 40 00 	ld  [ %o1 ], %g2                               
                                                                      
  /* Add the basics */                                                
  time->tv_sec += add->tv_sec;                                        
  time->tv_nsec += add->tv_nsec;                                      
4000c4a0:	c6 02 20 04 	ld  [ %o0 + 4 ], %g3                           
4000c4a4:	c2 02 60 04 	ld  [ %o1 + 4 ], %g1                           
)                                                                     
{                                                                     
  uint32_t seconds = add->tv_sec;                                     
                                                                      
  /* Add the basics */                                                
  time->tv_sec += add->tv_sec;                                        
4000c4a8:	98 03 00 02 	add  %o4, %g2, %o4                             
  time->tv_nsec += add->tv_nsec;                                      
4000c4ac:	82 00 c0 01 	add  %g3, %g1, %g1                             
)                                                                     
{                                                                     
  uint32_t seconds = add->tv_sec;                                     
                                                                      
  /* Add the basics */                                                
  time->tv_sec += add->tv_sec;                                        
4000c4b0:	d8 22 00 00 	st  %o4, [ %o0 ]                               
  time->tv_nsec += add->tv_nsec;                                      
                                                                      
  /* Now adjust it so nanoseconds is in range */                      
  while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {             
4000c4b4:	09 0e e6 b2 	sethi  %hi(0x3b9ac800), %g4                    
4000c4b8:	88 11 21 ff 	or  %g4, 0x1ff, %g4	! 3b9ac9ff <RAM_SIZE+0x3b5ac9ff>
4000c4bc:	80 a0 40 04 	cmp  %g1, %g4                                  
4000c4c0:	08 80 00 0d 	bleu  4000c4f4 <_Timespec_Add_to+0x5c>         
4000c4c4:	c2 22 20 04 	st  %g1, [ %o0 + 4 ]                           
4000c4c8:	98 03 20 01 	inc  %o4                                       
    time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;                      
4000c4cc:	1b 31 19 4d 	sethi  %hi(0xc4653400), %o5                    
#include <sys/types.h>                                                
#include <rtems/score/timespec.h>                                     
#include <rtems/score/tod.h>                                          
#include <rtems/score/watchdog.h>                                     
                                                                      
uint32_t _Timespec_Add_to(                                            
4000c4d0:	98 23 00 02 	sub  %o4, %g2, %o4                             
  time->tv_sec += add->tv_sec;                                        
  time->tv_nsec += add->tv_nsec;                                      
                                                                      
  /* Now adjust it so nanoseconds is in range */                      
  while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {             
    time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;                      
4000c4d4:	9a 13 62 00 	or  %o5, 0x200, %o5                            
4000c4d8:	82 00 40 0d 	add  %g1, %o5, %g1                             
#include <sys/types.h>                                                
#include <rtems/score/timespec.h>                                     
#include <rtems/score/tod.h>                                          
#include <rtems/score/watchdog.h>                                     
                                                                      
uint32_t _Timespec_Add_to(                                            
4000c4dc:	86 03 00 02 	add  %o4, %g2, %g3                             
  /* Add the basics */                                                
  time->tv_sec += add->tv_sec;                                        
  time->tv_nsec += add->tv_nsec;                                      
                                                                      
  /* Now adjust it so nanoseconds is in range */                      
  while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {             
4000c4e0:	80 a0 40 04 	cmp  %g1, %g4                                  
4000c4e4:	18 bf ff fd 	bgu  4000c4d8 <_Timespec_Add_to+0x40>          <== NEVER TAKEN
4000c4e8:	84 00 a0 01 	inc  %g2                                       
4000c4ec:	c2 22 20 04 	st  %g1, [ %o0 + 4 ]                           
4000c4f0:	c6 22 00 00 	st  %g3, [ %o0 ]                               
    time->tv_sec++;                                                   
    seconds++;                                                        
  }                                                                   
                                                                      
  return seconds;                                                     
}                                                                     
4000c4f4:	81 c3 e0 08 	retl                                           
4000c4f8:	90 10 00 02 	mov  %g2, %o0                                  
                                                                      

4000c230 <_Timestamp64_Divide>: const Timestamp64_Control *_lhs, const Timestamp64_Control *_rhs, uint32_t *_ival_percentage, uint32_t *_fval_percentage ) {
4000c230:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Timestamp64_Control answer;                                         
                                                                      
  if ( *_rhs == 0 ) {                                                 
4000c234:	d4 1e 40 00 	ldd  [ %i1 ], %o2                              
4000c238:	80 92 80 0b 	orcc  %o2, %o3, %g0                            
4000c23c:	22 80 00 2f 	be,a   4000c2f8 <_Timestamp64_Divide+0xc8>     <== NEVER TAKEN
4000c240:	c0 26 80 00 	clr  [ %i2 ]                                   <== NOT EXECUTED
   *  This looks odd but gives the results the proper precision.      
   *                                                                  
   *  TODO: Rounding on the last digit of the fval.                   
   */                                                                 
                                                                      
  answer = (*_lhs * 100000) / *_rhs;                                  
4000c244:	e0 1e 00 00 	ldd  [ %i0 ], %l0                              
4000c248:	83 2c 20 02 	sll  %l0, 2, %g1                               
4000c24c:	89 34 60 1e 	srl  %l1, 0x1e, %g4                            
4000c250:	87 2c 60 02 	sll  %l1, 2, %g3                               
4000c254:	84 11 00 01 	or  %g4, %g1, %g2                              
4000c258:	83 30 e0 1b 	srl  %g3, 0x1b, %g1                            
4000c25c:	9b 28 e0 05 	sll  %g3, 5, %o5                               
4000c260:	99 28 a0 05 	sll  %g2, 5, %o4                               
4000c264:	86 a3 40 03 	subcc  %o5, %g3, %g3                           
4000c268:	98 10 40 0c 	or  %g1, %o4, %o4                              
4000c26c:	84 63 00 02 	subx  %o4, %g2, %g2                            
4000c270:	92 80 c0 11 	addcc  %g3, %l1, %o1                           
4000c274:	83 32 60 1e 	srl  %o1, 0x1e, %g1                            
4000c278:	90 40 80 10 	addx  %g2, %l0, %o0                            
4000c27c:	b3 2a 60 02 	sll  %o1, 2, %i1                               
4000c280:	b1 2a 20 02 	sll  %o0, 2, %i0                               
4000c284:	86 82 40 19 	addcc  %o1, %i1, %g3                           
4000c288:	b0 10 40 18 	or  %g1, %i0, %i0                              
4000c28c:	83 30 e0 1e 	srl  %g3, 0x1e, %g1                            
4000c290:	84 42 00 18 	addx  %o0, %i0, %g2                            
4000c294:	bb 28 e0 02 	sll  %g3, 2, %i5                               
4000c298:	b9 28 a0 02 	sll  %g2, 2, %i4                               
4000c29c:	92 80 c0 1d 	addcc  %g3, %i5, %o1                           
4000c2a0:	b8 10 40 1c 	or  %g1, %i4, %i4                              
4000c2a4:	87 32 60 1b 	srl  %o1, 0x1b, %g3                            
4000c2a8:	90 40 80 1c 	addx  %g2, %i4, %o0                            
4000c2ac:	83 2a 60 05 	sll  %o1, 5, %g1                               
4000c2b0:	85 2a 20 05 	sll  %o0, 5, %g2                               
4000c2b4:	92 10 00 01 	mov  %g1, %o1                                  
4000c2b8:	40 00 3b 32 	call  4001af80 <__divdi3>                      
4000c2bc:	90 10 c0 02 	or  %g3, %g2, %o0                              
                                                                      
  *_ival_percentage = answer / 1000;                                  
4000c2c0:	94 10 20 00 	clr  %o2                                       
   *  This looks odd but gives the results the proper precision.      
   *                                                                  
   *  TODO: Rounding on the last digit of the fval.                   
   */                                                                 
                                                                      
  answer = (*_lhs * 100000) / *_rhs;                                  
4000c2c4:	b8 10 00 08 	mov  %o0, %i4                                  
4000c2c8:	ba 10 00 09 	mov  %o1, %i5                                  
                                                                      
  *_ival_percentage = answer / 1000;                                  
4000c2cc:	40 00 3b 2d 	call  4001af80 <__divdi3>                      
4000c2d0:	96 10 23 e8 	mov  0x3e8, %o3                                
  *_fval_percentage = answer % 1000;                                  
4000c2d4:	90 10 00 1c 	mov  %i4, %o0                                  
   *  TODO: Rounding on the last digit of the fval.                   
   */                                                                 
                                                                      
  answer = (*_lhs * 100000) / *_rhs;                                  
                                                                      
  *_ival_percentage = answer / 1000;                                  
4000c2d8:	d2 26 80 00 	st  %o1, [ %i2 ]                               
  *_fval_percentage = answer % 1000;                                  
4000c2dc:	94 10 20 00 	clr  %o2                                       
4000c2e0:	96 10 23 e8 	mov  0x3e8, %o3                                
4000c2e4:	40 00 3c 12 	call  4001b32c <__moddi3>                      
4000c2e8:	92 10 00 1d 	mov  %i5, %o1                                  
4000c2ec:	d2 26 c0 00 	st  %o1, [ %i3 ]                               
4000c2f0:	81 c7 e0 08 	ret                                            
4000c2f4:	81 e8 00 00 	restore                                        
{                                                                     
  Timestamp64_Control answer;                                         
                                                                      
  if ( *_rhs == 0 ) {                                                 
    *_ival_percentage = 0;                                            
    *_fval_percentage = 0;                                            
4000c2f8:	c0 26 c0 00 	clr  [ %i3 ]                                   <== NOT EXECUTED
    return;                                                           
4000c2fc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000c300:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4000ab78 <_User_extensions_Handler_initialization>: } } void _User_extensions_Handler_initialization(void) {
4000ab78:	9d e3 bf 98 	save  %sp, -104, %sp                           
  uint32_t number_of_initial_extensions =                             
4000ab7c:	03 10 00 71 	sethi  %hi(0x4001c400), %g1                    
4000ab80:	c2 00 60 58 	ld  [ %g1 + 0x58 ], %g1	! 4001c458 <Configuration+0x40>
    rtems_configuration_get_number_of_initial_extensions();           
                                                                      
  if ( number_of_initial_extensions > 0 ) {                           
4000ab84:	80 a0 60 00 	cmp  %g1, 0                                    
4000ab88:	02 80 00 0a 	be  4000abb0 <_User_extensions_Handler_initialization+0x38><== NEVER TAKEN
4000ab8c:	91 28 60 02 	sll  %g1, 2, %o0                               
    User_extensions_Switch_control *initial_extension_switch_controls =
      _Workspace_Allocate_or_fatal_error(                             
        number_of_initial_extensions                                  
          * sizeof( *initial_extension_switch_controls )              
4000ab90:	83 28 60 04 	sll  %g1, 4, %g1                               
{                                                                     
  uint32_t number_of_initial_extensions =                             
    rtems_configuration_get_number_of_initial_extensions();           
                                                                      
  if ( number_of_initial_extensions > 0 ) {                           
    User_extensions_Switch_control *initial_extension_switch_controls =
4000ab94:	40 00 01 2c 	call  4000b044 <_Workspace_Allocate_or_fatal_error>
4000ab98:	90 20 40 08 	sub  %g1, %o0, %o0                             
        number_of_initial_extensions                                  
          * sizeof( *initial_extension_switch_controls )              
      );                                                              
    User_extensions_Switch_context ctx = { initial_extension_switch_controls };
                                                                      
    _User_extensions_Iterate( &ctx, _User_extensions_Switch_visitor );
4000ab9c:	13 10 00 2a 	sethi  %hi(0x4000a800), %o1                    
    User_extensions_Switch_control *initial_extension_switch_controls =
      _Workspace_Allocate_or_fatal_error(                             
        number_of_initial_extensions                                  
          * sizeof( *initial_extension_switch_controls )              
      );                                                              
    User_extensions_Switch_context ctx = { initial_extension_switch_controls };
4000aba0:	d0 27 bf fc 	st  %o0, [ %fp + -4 ]                          
                                                                      
    _User_extensions_Iterate( &ctx, _User_extensions_Switch_visitor );
4000aba4:	92 12 63 34 	or  %o1, 0x334, %o1                            
4000aba8:	7f ff ff c0 	call  4000aaa8 <_User_extensions_Iterate>      
4000abac:	90 07 bf fc 	add  %fp, -4, %o0                              
4000abb0:	81 c7 e0 08 	ret                                            
4000abb4:	81 e8 00 00 	restore                                        
                                                                      

4000aaa8 <_User_extensions_Iterate>: void _User_extensions_Iterate( void *arg, User_extensions_Visitor visitor ) {
4000aaa8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Thread_Control   *executing = _Thread_Executing;                    
  const User_extensions_Table *callouts_current =                     
4000aaac:	03 10 00 71 	sethi  %hi(0x4001c400), %g1                    
4000aab0:	82 10 60 18 	or  %g1, 0x18, %g1	! 4001c418 <Configuration>  
4000aab4:	fa 00 60 44 	ld  [ %g1 + 0x44 ], %i5                        
    rtems_configuration_get_user_extension_table();                   
  const User_extensions_Table *callouts_end =                         
    callouts_current + rtems_configuration_get_number_of_initial_extensions();
4000aab8:	f6 00 60 40 	ld  [ %g1 + 0x40 ], %i3                        
void _User_extensions_Iterate(                                        
  void                    *arg,                                       
  User_extensions_Visitor  visitor                                    
)                                                                     
{                                                                     
  Thread_Control   *executing = _Thread_Executing;                    
4000aabc:	03 10 00 7c 	sethi  %hi(0x4001f000), %g1                    
  const User_extensions_Table *callouts_current =                     
    rtems_configuration_get_user_extension_table();                   
  const User_extensions_Table *callouts_end =                         
    callouts_current + rtems_configuration_get_number_of_initial_extensions();
4000aac0:	b7 2e e0 05 	sll  %i3, 5, %i3                               
)                                                                     
{                                                                     
  Thread_Control   *executing = _Thread_Executing;                    
  const User_extensions_Table *callouts_current =                     
    rtems_configuration_get_user_extension_table();                   
  const User_extensions_Table *callouts_end =                         
4000aac4:	b6 07 40 1b 	add  %i5, %i3, %i3                             
    callouts_current + rtems_configuration_get_number_of_initial_extensions();
  const Chain_Node *node;                                             
  const Chain_Node *tail;                                             
                                                                      
  while ( callouts_current != callouts_end ) {                        
4000aac8:	80 a7 40 1b 	cmp  %i5, %i3                                  
4000aacc:	02 80 00 0a 	be  4000aaf4 <_User_extensions_Iterate+0x4c>   <== NEVER TAKEN
4000aad0:	f8 00 63 e0 	ld  [ %g1 + 0x3e0 ], %i4                       
    (*visitor)( executing, arg, callouts_current );                   
4000aad4:	94 10 00 1d 	mov  %i5, %o2                                  
4000aad8:	90 10 00 1c 	mov  %i4, %o0                                  
4000aadc:	9f c6 40 00 	call  %i1                                      
4000aae0:	92 10 00 18 	mov  %i0, %o1                                  
                                                                      
    ++callouts_current;                                               
4000aae4:	ba 07 60 20 	add  %i5, 0x20, %i5                            
  const User_extensions_Table *callouts_end =                         
    callouts_current + rtems_configuration_get_number_of_initial_extensions();
  const Chain_Node *node;                                             
  const Chain_Node *tail;                                             
                                                                      
  while ( callouts_current != callouts_end ) {                        
4000aae8:	80 a6 c0 1d 	cmp  %i3, %i5                                  
4000aaec:	12 bf ff fb 	bne  4000aad8 <_User_extensions_Iterate+0x30>  
4000aaf0:	94 10 00 1d 	mov  %i5, %o2                                  
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(        
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_head( the_chain )->next;                    
4000aaf4:	37 10 00 79 	sethi  %hi(0x4001e400), %i3                    
4000aaf8:	fa 06 e0 80 	ld  [ %i3 + 0x80 ], %i5	! 4001e480 <_User_extensions_List>
4000aafc:	b6 16 e0 80 	or  %i3, 0x80, %i3                             
    ++callouts_current;                                               
  }                                                                   
                                                                      
  node = _Chain_Immutable_first( &_User_extensions_List );            
  tail = _Chain_Immutable_tail( &_User_extensions_List );             
  while ( node != tail ) {                                            
4000ab00:	b6 06 e0 04 	add  %i3, 4, %i3                               
4000ab04:	80 a7 40 1b 	cmp  %i5, %i3                                  
4000ab08:	02 80 00 09 	be  4000ab2c <_User_extensions_Iterate+0x84>   
4000ab0c:	94 07 60 14 	add  %i5, 0x14, %o2                            
    const User_extensions_Control *extension =                        
      (const User_extensions_Control *) node;                         
                                                                      
    (*visitor)( executing, arg, &extension->Callouts );               
4000ab10:	90 10 00 1c 	mov  %i4, %o0                                  
4000ab14:	9f c6 40 00 	call  %i1                                      
4000ab18:	92 10 00 18 	mov  %i0, %o1                                  
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_next(         
  const Chain_Node *the_node                                          
)                                                                     
{                                                                     
  return the_node->next;                                              
4000ab1c:	fa 07 40 00 	ld  [ %i5 ], %i5                               
    ++callouts_current;                                               
  }                                                                   
                                                                      
  node = _Chain_Immutable_first( &_User_extensions_List );            
  tail = _Chain_Immutable_tail( &_User_extensions_List );             
  while ( node != tail ) {                                            
4000ab20:	80 a7 40 1b 	cmp  %i5, %i3                                  
4000ab24:	12 bf ff fb 	bne  4000ab10 <_User_extensions_Iterate+0x68>  
4000ab28:	94 07 60 14 	add  %i5, 0x14, %o2                            
4000ab2c:	81 c7 e0 08 	ret                                            
4000ab30:	81 e8 00 00 	restore                                        
                                                                      

4000c57c <_Watchdog_Adjust>: void _Watchdog_Adjust( Chain_Control *header, Watchdog_Adjust_directions direction, Watchdog_Interval units ) {
4000c57c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  ISR_Level level;                                                    
                                                                      
  _ISR_Disable( level );                                              
4000c580:	7f ff da 17 	call  40002ddc <sparc_disable_interrupts>      
4000c584:	01 00 00 00 	nop                                            
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(        
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_head( the_chain )->next;                    
4000c588:	c2 06 00 00 	ld  [ %i0 ], %g1                               
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
4000c58c:	b8 06 20 04 	add  %i0, 4, %i4                               
   *       hence the compiler must not assume *header to remain       
   *       unmodified across that call.                               
   *                                                                  
   *       Till Straumann, 7/2003                                     
   */                                                                 
  if ( !_Chain_Is_empty( header ) ) {                                 
4000c590:	80 a0 40 1c 	cmp  %g1, %i4                                  
4000c594:	02 80 00 1f 	be  4000c610 <_Watchdog_Adjust+0x94>           
4000c598:	80 a6 60 00 	cmp  %i1, 0                                    
    switch ( direction ) {                                            
4000c59c:	12 80 00 1f 	bne  4000c618 <_Watchdog_Adjust+0x9c>          
4000c5a0:	80 a6 60 01 	cmp  %i1, 1                                    
      case WATCHDOG_BACKWARD:                                         
        _Watchdog_First( header )->delta_interval += units;           
        break;                                                        
      case WATCHDOG_FORWARD:                                          
        while ( units ) {                                             
4000c5a4:	80 a6 a0 00 	cmp  %i2, 0                                    
4000c5a8:	02 80 00 1a 	be  4000c610 <_Watchdog_Adjust+0x94>           <== NEVER TAKEN
4000c5ac:	01 00 00 00 	nop                                            
          if ( units < _Watchdog_First( header )->delta_interval ) {  
4000c5b0:	c4 00 60 10 	ld  [ %g1 + 0x10 ], %g2                        
4000c5b4:	80 a6 80 02 	cmp  %i2, %g2                                  
4000c5b8:	1a 80 00 0a 	bcc  4000c5e0 <_Watchdog_Adjust+0x64>          <== ALWAYS TAKEN
4000c5bc:	b6 10 20 01 	mov  1, %i3                                    
            _Watchdog_First( header )->delta_interval -= units;       
4000c5c0:	10 80 00 1d 	b  4000c634 <_Watchdog_Adjust+0xb8>            <== NOT EXECUTED
4000c5c4:	84 20 80 1a 	sub  %g2, %i2, %g2                             <== NOT EXECUTED
    switch ( direction ) {                                            
      case WATCHDOG_BACKWARD:                                         
        _Watchdog_First( header )->delta_interval += units;           
        break;                                                        
      case WATCHDOG_FORWARD:                                          
        while ( units ) {                                             
4000c5c8:	02 80 00 12 	be  4000c610 <_Watchdog_Adjust+0x94>           <== NEVER TAKEN
4000c5cc:	01 00 00 00 	nop                                            
          if ( units < _Watchdog_First( header )->delta_interval ) {  
4000c5d0:	c4 00 60 10 	ld  [ %g1 + 0x10 ], %g2                        
4000c5d4:	80 a0 80 1a 	cmp  %g2, %i2                                  
4000c5d8:	38 80 00 17 	bgu,a   4000c634 <_Watchdog_Adjust+0xb8>       
4000c5dc:	84 20 80 1a 	sub  %g2, %i2, %g2                             
            _Watchdog_First( header )->delta_interval -= units;       
            break;                                                    
          } else {                                                    
            units -= _Watchdog_First( header )->delta_interval;       
            _Watchdog_First( header )->delta_interval = 1;            
4000c5e0:	f6 20 60 10 	st  %i3, [ %g1 + 0x10 ]                        
        while ( units ) {                                             
          if ( units < _Watchdog_First( header )->delta_interval ) {  
            _Watchdog_First( header )->delta_interval -= units;       
            break;                                                    
          } else {                                                    
            units -= _Watchdog_First( header )->delta_interval;       
4000c5e4:	b4 26 80 02 	sub  %i2, %g2, %i2                             
            _Watchdog_First( header )->delta_interval = 1;            
                                                                      
            _ISR_Enable( level );                                     
4000c5e8:	7f ff da 01 	call  40002dec <sparc_enable_interrupts>       
4000c5ec:	01 00 00 00 	nop                                            
                                                                      
            _Watchdog_Tickle( header );                               
4000c5f0:	40 00 00 a8 	call  4000c890 <_Watchdog_Tickle>              
4000c5f4:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
            _ISR_Disable( level );                                    
4000c5f8:	7f ff d9 f9 	call  40002ddc <sparc_disable_interrupts>      
4000c5fc:	01 00 00 00 	nop                                            
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(        
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_head( the_chain )->next;                    
4000c600:	c2 06 00 00 	ld  [ %i0 ], %g1                               
                                                                      
            if ( _Chain_Is_empty( header ) )                          
4000c604:	80 a7 00 01 	cmp  %i4, %g1                                  
4000c608:	12 bf ff f0 	bne  4000c5c8 <_Watchdog_Adjust+0x4c>          
4000c60c:	80 a6 a0 00 	cmp  %i2, 0                                    
        }                                                             
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  _ISR_Enable( level );                                               
4000c610:	7f ff d9 f7 	call  40002dec <sparc_enable_interrupts>       
4000c614:	91 e8 00 08 	restore  %g0, %o0, %o0                         
   *       unmodified across that call.                               
   *                                                                  
   *       Till Straumann, 7/2003                                     
   */                                                                 
  if ( !_Chain_Is_empty( header ) ) {                                 
    switch ( direction ) {                                            
4000c618:	12 bf ff fe 	bne  4000c610 <_Watchdog_Adjust+0x94>          <== NEVER TAKEN
4000c61c:	01 00 00 00 	nop                                            
      case WATCHDOG_BACKWARD:                                         
        _Watchdog_First( header )->delta_interval += units;           
4000c620:	c4 00 60 10 	ld  [ %g1 + 0x10 ], %g2                        
4000c624:	b4 00 80 1a 	add  %g2, %i2, %i2                             
4000c628:	f4 20 60 10 	st  %i2, [ %g1 + 0x10 ]                        
        }                                                             
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  _ISR_Enable( level );                                               
4000c62c:	7f ff d9 f0 	call  40002dec <sparc_enable_interrupts>       
4000c630:	91 e8 00 08 	restore  %g0, %o0, %o0                         
        break;                                                        
      case WATCHDOG_FORWARD:                                          
        while ( units ) {                                             
          if ( units < _Watchdog_First( header )->delta_interval ) {  
            _Watchdog_First( header )->delta_interval -= units;       
            break;                                                    
4000c634:	10 bf ff f7 	b  4000c610 <_Watchdog_Adjust+0x94>            
4000c638:	c4 20 60 10 	st  %g2, [ %g1 + 0x10 ]                        
                                                                      

4001c238 <_Watchdog_Adjust_to_chain>: Chain_Control *header, Watchdog_Interval units_arg, Chain_Control *to_fire ) {
4001c238:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Watchdog_Interval  units = units_arg;                               
  ISR_Level          level;                                           
  Watchdog_Control  *first;                                           
                                                                      
  _ISR_Disable( level );                                              
4001c23c:	7f ff cb d5 	call  4000f190 <sparc_disable_interrupts>      
4001c240:	01 00 00 00 	nop                                            
4001c244:	c2 06 00 00 	ld  [ %i0 ], %g1                               
4001c248:	ba 06 20 04 	add  %i0, 4, %i5                               
4001c24c:	b8 06 a0 04 	add  %i2, 4, %i4                               
                                                                      
  while ( 1 ) {                                                       
    if ( _Chain_Is_empty( header ) ) {                                
4001c250:	80 a7 40 01 	cmp  %i5, %g1                                  
4001c254:	02 80 00 20 	be  4001c2d4 <_Watchdog_Adjust_to_chain+0x9c>  
4001c258:	01 00 00 00 	nop                                            
                                                                      
    /*                                                                
     *  If it is longer than "units" until the first element on the chain
     *  fires, then bump it and quit.                                 
     */                                                               
    if ( units < first->delta_interval ) {                            
4001c25c:	c4 00 60 10 	ld  [ %g1 + 0x10 ], %g2                        
4001c260:	80 a6 40 02 	cmp  %i1, %g2                                  
4001c264:	2a 80 00 1e 	bcs,a   4001c2dc <_Watchdog_Adjust_to_chain+0xa4>
4001c268:	84 20 80 19 	sub  %g2, %i1, %g2                             
                                                                      
    /*                                                                
     *  The first set happens in less than units, so take all of them 
     *  off the chain and adjust units to reflect this.               
     */                                                               
    units -= first->delta_interval;                                   
4001c26c:	b2 26 40 02 	sub  %i1, %g2, %i1                             
    first->delta_interval = 0;                                        
4001c270:	c0 20 60 10 	clr  [ %g1 + 0x10 ]                            
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
4001c274:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
4001c278:	c6 00 40 00 	ld  [ %g1 ], %g3                               
  previous       = the_node->previous;                                
  next->previous = previous;                                          
4001c27c:	c4 20 e0 04 	st  %g2, [ %g3 + 4 ]                           
  previous->next = next;                                              
4001c280:	c6 20 80 00 	st  %g3, [ %g2 ]                               
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
4001c284:	c4 06 a0 08 	ld  [ %i2 + 8 ], %g2                           
                                                                      
  the_node->next = tail;                                              
4001c288:	f8 20 40 00 	st  %i4, [ %g1 ]                               
  tail->previous = the_node;                                          
4001c28c:	c2 26 a0 08 	st  %g1, [ %i2 + 8 ]                           
  old_last->next = the_node;                                          
4001c290:	c2 20 80 00 	st  %g1, [ %g2 ]                               
  the_node->previous = old_last;                                      
4001c294:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
                                                                      
    while ( 1 ) {                                                     
      _Chain_Extract_unprotected( &first->Node );                     
      _Chain_Append_unprotected( to_fire, &first->Node );             
                                                                      
      _ISR_Flash( level );                                            
4001c298:	7f ff cb c2 	call  4000f1a0 <sparc_enable_interrupts>       
4001c29c:	01 00 00 00 	nop                                            
4001c2a0:	7f ff cb bc 	call  4000f190 <sparc_disable_interrupts>      
4001c2a4:	01 00 00 00 	nop                                            
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(        
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_head( the_chain )->next;                    
4001c2a8:	c2 06 00 00 	ld  [ %i0 ], %g1                               
                                                                      
      if ( _Chain_Is_empty( header ) )                                
4001c2ac:	80 a7 40 01 	cmp  %i5, %g1                                  
4001c2b0:	02 bf ff e9 	be  4001c254 <_Watchdog_Adjust_to_chain+0x1c>  
4001c2b4:	01 00 00 00 	nop                                            
        break;                                                        
      first = _Watchdog_First( header );                              
      if ( first->delta_interval != 0 )                               
4001c2b8:	c4 00 60 10 	ld  [ %g1 + 0x10 ], %g2                        
4001c2bc:	80 a0 a0 00 	cmp  %g2, 0                                    
4001c2c0:	22 bf ff ee 	be,a   4001c278 <_Watchdog_Adjust_to_chain+0x40>
4001c2c4:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
  Watchdog_Control  *first;                                           
                                                                      
  _ISR_Disable( level );                                              
                                                                      
  while ( 1 ) {                                                       
    if ( _Chain_Is_empty( header ) ) {                                
4001c2c8:	80 a7 40 01 	cmp  %i5, %g1                                  
4001c2cc:	12 bf ff e6 	bne  4001c264 <_Watchdog_Adjust_to_chain+0x2c> <== ALWAYS TAKEN
4001c2d0:	80 a6 40 02 	cmp  %i1, %g2                                  
      if ( first->delta_interval != 0 )                               
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  _ISR_Enable( level );                                               
4001c2d4:	7f ff cb b3 	call  4000f1a0 <sparc_enable_interrupts>       
4001c2d8:	91 e8 00 08 	restore  %g0, %o0, %o0                         
    /*                                                                
     *  If it is longer than "units" until the first element on the chain
     *  fires, then bump it and quit.                                 
     */                                                               
    if ( units < first->delta_interval ) {                            
      first->delta_interval -= units;                                 
4001c2dc:	c4 20 60 10 	st  %g2, [ %g1 + 0x10 ]                        
      if ( first->delta_interval != 0 )                               
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  _ISR_Enable( level );                                               
4001c2e0:	7f ff cb b0 	call  4000f1a0 <sparc_enable_interrupts>       
4001c2e4:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

4000ad34 <_Watchdog_Remove>: #include <rtems/score/watchdog.h> Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) {
4000ad34:	9d e3 bf a0 	save  %sp, -96, %sp                            
  ISR_Level         level;                                            
  Watchdog_States   previous_state;                                   
  Watchdog_Control *next_watchdog;                                    
                                                                      
  _ISR_Disable( level );                                              
4000ad38:	7f ff dc db 	call  400020a4 <sparc_disable_interrupts>      
4000ad3c:	01 00 00 00 	nop                                            
  previous_state = the_watchdog->state;                               
4000ad40:	fa 06 20 08 	ld  [ %i0 + 8 ], %i5                           
  switch ( previous_state ) {                                         
4000ad44:	80 a7 60 01 	cmp  %i5, 1                                    
4000ad48:	02 80 00 2a 	be  4000adf0 <_Watchdog_Remove+0xbc>           
4000ad4c:	03 10 00 7b 	sethi  %hi(0x4001ec00), %g1                    
4000ad50:	1a 80 00 09 	bcc  4000ad74 <_Watchdog_Remove+0x40>          
4000ad54:	80 a7 60 03 	cmp  %i5, 3                                    
        _Watchdog_Sync_level = _ISR_Nest_level;                       
                                                                      
      _Chain_Extract_unprotected( &the_watchdog->Node );              
      break;                                                          
  }                                                                   
  the_watchdog->stop_time = _Watchdog_Ticks_since_boot;               
4000ad58:	03 10 00 7b 	sethi  %hi(0x4001ec00), %g1                    
4000ad5c:	c2 00 63 a8 	ld  [ %g1 + 0x3a8 ], %g1	! 4001efa8 <_Watchdog_Ticks_since_boot>
4000ad60:	c2 26 20 18 	st  %g1, [ %i0 + 0x18 ]                        
                                                                      
  _ISR_Enable( level );                                               
4000ad64:	7f ff dc d4 	call  400020b4 <sparc_enable_interrupts>       
4000ad68:	b0 10 00 1d 	mov  %i5, %i0                                  
  return( previous_state );                                           
}                                                                     
4000ad6c:	81 c7 e0 08 	ret                                            
4000ad70:	81 e8 00 00 	restore                                        
  Watchdog_States   previous_state;                                   
  Watchdog_Control *next_watchdog;                                    
                                                                      
  _ISR_Disable( level );                                              
  previous_state = the_watchdog->state;                               
  switch ( previous_state ) {                                         
4000ad74:	18 bf ff fa 	bgu  4000ad5c <_Watchdog_Remove+0x28>          <== NEVER TAKEN
4000ad78:	03 10 00 7b 	sethi  %hi(0x4001ec00), %g1                    
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Next(                
  Watchdog_Control *the_watchdog                                      
)                                                                     
{                                                                     
                                                                      
  return ( (Watchdog_Control *) the_watchdog->Node.next );            
4000ad7c:	c2 06 00 00 	ld  [ %i0 ], %g1                               
      break;                                                          
                                                                      
    case WATCHDOG_ACTIVE:                                             
    case WATCHDOG_REMOVE_IT:                                          
                                                                      
      the_watchdog->state = WATCHDOG_INACTIVE;                        
4000ad80:	c0 26 20 08 	clr  [ %i0 + 8 ]                               
      next_watchdog = _Watchdog_Next( the_watchdog );                 
                                                                      
      if ( _Watchdog_Next(next_watchdog) )                            
4000ad84:	c4 00 40 00 	ld  [ %g1 ], %g2                               
4000ad88:	80 a0 a0 00 	cmp  %g2, 0                                    
4000ad8c:	02 80 00 07 	be  4000ada8 <_Watchdog_Remove+0x74>           
4000ad90:	05 10 00 7b 	sethi  %hi(0x4001ec00), %g2                    
        next_watchdog->delta_interval += the_watchdog->delta_interval;
4000ad94:	c6 00 60 10 	ld  [ %g1 + 0x10 ], %g3                        
4000ad98:	c4 06 20 10 	ld  [ %i0 + 0x10 ], %g2                        
4000ad9c:	84 00 c0 02 	add  %g3, %g2, %g2                             
4000ada0:	c4 20 60 10 	st  %g2, [ %g1 + 0x10 ]                        
                                                                      
      if ( _Watchdog_Sync_count )                                     
4000ada4:	05 10 00 7b 	sethi  %hi(0x4001ec00), %g2                    
4000ada8:	c4 00 a3 a4 	ld  [ %g2 + 0x3a4 ], %g2	! 4001efa4 <_Watchdog_Sync_count>
4000adac:	80 a0 a0 00 	cmp  %g2, 0                                    
4000adb0:	22 80 00 07 	be,a   4000adcc <_Watchdog_Remove+0x98>        
4000adb4:	c4 06 20 04 	ld  [ %i0 + 4 ], %g2                           
        _Watchdog_Sync_level = _ISR_Nest_level;                       
4000adb8:	05 10 00 7c 	sethi  %hi(0x4001f000), %g2                    
4000adbc:	c6 00 a3 d8 	ld  [ %g2 + 0x3d8 ], %g3	! 4001f3d8 <_Per_CPU_Information+0x8>
4000adc0:	05 10 00 7b 	sethi  %hi(0x4001ec00), %g2                    
4000adc4:	c6 20 a3 44 	st  %g3, [ %g2 + 0x344 ]	! 4001ef44 <_Watchdog_Sync_level>
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
4000adc8:	c4 06 20 04 	ld  [ %i0 + 4 ], %g2                           
  next->previous = previous;                                          
4000adcc:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
  previous->next = next;                                              
4000add0:	c2 20 80 00 	st  %g1, [ %g2 ]                               
                                                                      
      _Chain_Extract_unprotected( &the_watchdog->Node );              
      break;                                                          
  }                                                                   
  the_watchdog->stop_time = _Watchdog_Ticks_since_boot;               
4000add4:	03 10 00 7b 	sethi  %hi(0x4001ec00), %g1                    
4000add8:	c2 00 63 a8 	ld  [ %g1 + 0x3a8 ], %g1	! 4001efa8 <_Watchdog_Ticks_since_boot>
4000addc:	c2 26 20 18 	st  %g1, [ %i0 + 0x18 ]                        
                                                                      
  _ISR_Enable( level );                                               
4000ade0:	7f ff dc b5 	call  400020b4 <sparc_enable_interrupts>       
4000ade4:	b0 10 00 1d 	mov  %i5, %i0                                  
  return( previous_state );                                           
}                                                                     
4000ade8:	81 c7 e0 08 	ret                                            
4000adec:	81 e8 00 00 	restore                                        
        _Watchdog_Sync_level = _ISR_Nest_level;                       
                                                                      
      _Chain_Extract_unprotected( &the_watchdog->Node );              
      break;                                                          
  }                                                                   
  the_watchdog->stop_time = _Watchdog_Ticks_since_boot;               
4000adf0:	c2 00 63 a8 	ld  [ %g1 + 0x3a8 ], %g1                       
                                                                      
      /*                                                              
       *  It is not actually on the chain so just change the state and
       *  the Insert operation we interrupted will be aborted.        
       */                                                             
      the_watchdog->state = WATCHDOG_INACTIVE;                        
4000adf4:	c0 26 20 08 	clr  [ %i0 + 8 ]                               
        _Watchdog_Sync_level = _ISR_Nest_level;                       
                                                                      
      _Chain_Extract_unprotected( &the_watchdog->Node );              
      break;                                                          
  }                                                                   
  the_watchdog->stop_time = _Watchdog_Ticks_since_boot;               
4000adf8:	c2 26 20 18 	st  %g1, [ %i0 + 0x18 ]                        
                                                                      
  _ISR_Enable( level );                                               
4000adfc:	7f ff dc ae 	call  400020b4 <sparc_enable_interrupts>       
4000ae00:	b0 10 00 1d 	mov  %i5, %i0                                  
  return( previous_state );                                           
}                                                                     
4000ae04:	81 c7 e0 08 	ret                                            
4000ae08:	81 e8 00 00 	restore                                        
                                                                      

4000bfbc <_Watchdog_Report_chain>: void _Watchdog_Report_chain( const char *name, Chain_Control *header ) {
4000bfbc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  ISR_Level          level;                                           
  Chain_Node        *node;                                            
                                                                      
  _ISR_Disable( level );                                              
4000bfc0:	7f ff da 85 	call  400029d4 <sparc_disable_interrupts>      
4000bfc4:	01 00 00 00 	nop                                            
4000bfc8:	b6 10 00 08 	mov  %o0, %i3                                  
    printk( "Watchdog Chain: %s %p\n", name, header );                
4000bfcc:	11 10 00 7c 	sethi  %hi(0x4001f000), %o0                    
4000bfd0:	94 10 00 19 	mov  %i1, %o2                                  
4000bfd4:	92 10 00 18 	mov  %i0, %o1                                  
4000bfd8:	7f ff e2 02 	call  400047e0 <printk>                        
4000bfdc:	90 12 20 40 	or  %o0, 0x40, %o0                             
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(        
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_head( the_chain )->next;                    
4000bfe0:	fa 06 40 00 	ld  [ %i1 ], %i5                               
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
4000bfe4:	b2 06 60 04 	add  %i1, 4, %i1                               
    if ( !_Chain_Is_empty( header ) ) {                               
4000bfe8:	80 a7 40 19 	cmp  %i5, %i1                                  
4000bfec:	02 80 00 0f 	be  4000c028 <_Watchdog_Report_chain+0x6c>     
4000bff0:	11 10 00 7c 	sethi  %hi(0x4001f000), %o0                    
            node != _Chain_Tail(header) ;                             
            node = node->next )                                       
      {                                                               
        Watchdog_Control *watch = (Watchdog_Control *) node;          
                                                                      
        _Watchdog_Report( NULL, watch );                              
4000bff4:	92 10 00 1d 	mov  %i5, %o1                                  
4000bff8:	40 00 00 0f 	call  4000c034 <_Watchdog_Report>              
4000bffc:	90 10 20 00 	clr  %o0                                       
  _ISR_Disable( level );                                              
    printk( "Watchdog Chain: %s %p\n", name, header );                
    if ( !_Chain_Is_empty( header ) ) {                               
      for ( node = _Chain_First( header ) ;                           
            node != _Chain_Tail(header) ;                             
            node = node->next )                                       
4000c000:	fa 07 40 00 	ld  [ %i5 ], %i5                               
  Chain_Node        *node;                                            
                                                                      
  _ISR_Disable( level );                                              
    printk( "Watchdog Chain: %s %p\n", name, header );                
    if ( !_Chain_Is_empty( header ) ) {                               
      for ( node = _Chain_First( header ) ;                           
4000c004:	80 a7 40 19 	cmp  %i5, %i1                                  
4000c008:	12 bf ff fc 	bne  4000bff8 <_Watchdog_Report_chain+0x3c>    <== NEVER TAKEN
4000c00c:	92 10 00 1d 	mov  %i5, %o1                                  
      {                                                               
        Watchdog_Control *watch = (Watchdog_Control *) node;          
                                                                      
        _Watchdog_Report( NULL, watch );                              
      }                                                               
      printk( "== end of %s \n", name );                              
4000c010:	11 10 00 7c 	sethi  %hi(0x4001f000), %o0                    
4000c014:	92 10 00 18 	mov  %i0, %o1                                  
4000c018:	7f ff e1 f2 	call  400047e0 <printk>                        
4000c01c:	90 12 20 58 	or  %o0, 0x58, %o0                             
    } else {                                                          
      printk( "Chain is empty\n" );                                   
    }                                                                 
  _ISR_Enable( level );                                               
4000c020:	7f ff da 71 	call  400029e4 <sparc_enable_interrupts>       
4000c024:	91 e8 00 1b 	restore  %g0, %i3, %o0                         
                                                                      
        _Watchdog_Report( NULL, watch );                              
      }                                                               
      printk( "== end of %s \n", name );                              
    } else {                                                          
      printk( "Chain is empty\n" );                                   
4000c028:	7f ff e1 ee 	call  400047e0 <printk>                        
4000c02c:	90 12 20 68 	or  %o0, 0x68, %o0                             
4000c030:	30 bf ff fc 	b,a   4000c020 <_Watchdog_Report_chain+0x64>   
                                                                      

4000aeb4 <_Workspace_Handler_initialization>: void _Workspace_Handler_initialization( Heap_Area *areas, size_t area_count, Heap_Initialization_or_extend_handler extend ) {
4000aeb4:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
  uintptr_t remaining = rtems_configuration_get_work_space_size();    
4000aeb8:	05 10 00 71 	sethi  %hi(0x4001c400), %g2                    
4000aebc:	82 10 a0 18 	or  %g2, 0x18, %g1	! 4001c418 <Configuration>  
4000aec0:	c6 08 60 32 	ldub  [ %g1 + 0x32 ], %g3                      
4000aec4:	f6 00 a0 18 	ld  [ %g2 + 0x18 ], %i3                        
4000aec8:	80 a0 e0 00 	cmp  %g3, 0                                    
4000aecc:	12 80 00 03 	bne  4000aed8 <_Workspace_Handler_initialization+0x24>
4000aed0:	84 10 20 00 	clr  %g2                                       
4000aed4:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
4000aed8:	b6 00 80 1b 	add  %g2, %i3, %i3                             
  bool do_zero = rtems_configuration_get_do_zero_of_workspace();      
4000aedc:	c4 08 60 30 	ldub  [ %g1 + 0x30 ], %g2                      
  bool unified = rtems_configuration_get_unified_work_area();         
4000aee0:	c2 08 60 31 	ldub  [ %g1 + 0x31 ], %g1                      
  Heap_Initialization_or_extend_handler extend                        
)                                                                     
{                                                                     
  Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
  uintptr_t remaining = rtems_configuration_get_work_space_size();    
  bool do_zero = rtems_configuration_get_do_zero_of_workspace();      
4000aee4:	c4 2f bf ff 	stb  %g2, [ %fp + -1 ]                         
  bool unified = rtems_configuration_get_unified_work_area();         
  uintptr_t page_size = CPU_HEAP_ALIGNMENT;                           
  uintptr_t overhead = _Heap_Area_overhead( page_size );              
  size_t i;                                                           
                                                                      
  for (i = 0; i < area_count; ++i) {                                  
4000aee8:	80 a6 60 00 	cmp  %i1, 0                                    
4000aeec:	02 80 00 3c 	be  4000afdc <_Workspace_Handler_initialization+0x128><== NEVER TAKEN
4000aef0:	c2 2f bf fe 	stb  %g1, [ %fp + -2 ]                         
  Heap_Area *areas,                                                   
  size_t area_count,                                                  
  Heap_Initialization_or_extend_handler extend                        
)                                                                     
{                                                                     
  Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
4000aef4:	23 10 00 21 	sethi  %hi(0x40008400), %l1                    
        } else {                                                      
          size = 0;                                                   
        }                                                             
      }                                                               
                                                                      
      space_available = (*init_or_extend)(                            
4000aef8:	27 10 00 7b 	sethi  %hi(0x4001ec00), %l3                    
  bool unified = rtems_configuration_get_unified_work_area();         
  uintptr_t page_size = CPU_HEAP_ALIGNMENT;                           
  uintptr_t overhead = _Heap_Area_overhead( page_size );              
  size_t i;                                                           
                                                                      
  for (i = 0; i < area_count; ++i) {                                  
4000aefc:	b8 10 20 00 	clr  %i4                                       
  Heap_Area *areas,                                                   
  size_t area_count,                                                  
  Heap_Initialization_or_extend_handler extend                        
)                                                                     
{                                                                     
  Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
4000af00:	a2 14 62 98 	or  %l1, 0x298, %l1                            
4000af04:	a0 08 a0 ff 	and  %g2, 0xff, %l0                            
                                                                      
    if ( area->size > overhead ) {                                    
      uintptr_t space_available;                                      
      uintptr_t size;                                                 
                                                                      
      if ( unified ) {                                                
4000af08:	a4 08 60 ff 	and  %g1, 0xff, %l2                            
        } else {                                                      
          size = 0;                                                   
        }                                                             
      }                                                               
                                                                      
      space_available = (*init_or_extend)(                            
4000af0c:	10 80 00 22 	b  4000af94 <_Workspace_Handler_initialization+0xe0>
4000af10:	a6 14 e2 d0 	or  %l3, 0x2d0, %l3                            
                                                                      
    if ( do_zero ) {                                                  
      memset( area->begin, 0, area->size );                           
    }                                                                 
                                                                      
    if ( area->size > overhead ) {                                    
4000af14:	80 a7 60 16 	cmp  %i5, 0x16                                 
4000af18:	28 80 00 1c 	bleu,a   4000af88 <_Workspace_Handler_initialization+0xd4>
4000af1c:	b8 07 20 01 	inc  %i4                                       
      uintptr_t space_available;                                      
      uintptr_t size;                                                 
                                                                      
      if ( unified ) {                                                
4000af20:	80 a4 a0 00 	cmp  %l2, 0                                    
4000af24:	32 80 00 0a 	bne,a   4000af4c <_Workspace_Handler_initialization+0x98>
4000af28:	d2 06 00 00 	ld  [ %i0 ], %o1                               
        size = area->size;                                            
      } else {                                                        
        if ( remaining > 0 ) {                                        
4000af2c:	80 a6 e0 00 	cmp  %i3, 0                                    
4000af30:	22 80 00 22 	be,a   4000afb8 <_Workspace_Handler_initialization+0x104><== NEVER TAKEN
4000af34:	d2 06 00 00 	ld  [ %i0 ], %o1                               <== NOT EXECUTED
          size = remaining < area->size - overhead ?                  
4000af38:	82 07 7f ea 	add  %i5, -22, %g1                             
            remaining + overhead : area->size;                        
4000af3c:	80 a0 40 1b 	cmp  %g1, %i3                                  
4000af40:	38 80 00 02 	bgu,a   4000af48 <_Workspace_Handler_initialization+0x94><== ALWAYS TAKEN
4000af44:	ba 06 e0 16 	add  %i3, 0x16, %i5                            
        } else {                                                      
          size = 0;                                                   
        }                                                             
      }                                                               
                                                                      
      space_available = (*init_or_extend)(                            
4000af48:	d2 06 00 00 	ld  [ %i0 ], %o1                               
4000af4c:	94 10 00 1d 	mov  %i5, %o2                                  
4000af50:	90 10 00 13 	mov  %l3, %o0                                  
4000af54:	9f c4 40 00 	call  %l1                                      
4000af58:	96 10 20 08 	mov  8, %o3                                    
        area->begin,                                                  
        size,                                                         
        page_size                                                     
      );                                                              
                                                                      
      area->begin = (char *) area->begin + size;                      
4000af5c:	c2 06 00 00 	ld  [ %i0 ], %g1                               
      area->size -= size;                                             
4000af60:	c4 06 20 04 	ld  [ %i0 + 4 ], %g2                           
        area->begin,                                                  
        size,                                                         
        page_size                                                     
      );                                                              
                                                                      
      area->begin = (char *) area->begin + size;                      
4000af64:	82 00 40 1d 	add  %g1, %i5, %g1                             
      area->size -= size;                                             
4000af68:	ba 20 80 1d 	sub  %g2, %i5, %i5                             
        area->begin,                                                  
        size,                                                         
        page_size                                                     
      );                                                              
                                                                      
      area->begin = (char *) area->begin + size;                      
4000af6c:	c2 26 00 00 	st  %g1, [ %i0 ]                               
      area->size -= size;                                             
                                                                      
      if ( space_available < remaining ) {                            
4000af70:	80 a2 00 1b 	cmp  %o0, %i3                                  
4000af74:	1a 80 00 1f 	bcc  4000aff0 <_Workspace_Handler_initialization+0x13c><== ALWAYS TAKEN
4000af78:	fa 26 20 04 	st  %i5, [ %i0 + 4 ]                           
        remaining -= space_available;                                 
4000af7c:	b6 26 c0 08 	sub  %i3, %o0, %i3                             <== NOT EXECUTED
      } else {                                                        
        remaining = 0;                                                
      }                                                               
                                                                      
      init_or_extend = extend;                                        
4000af80:	a2 10 00 1a 	mov  %i2, %l1                                  <== NOT EXECUTED
  bool unified = rtems_configuration_get_unified_work_area();         
  uintptr_t page_size = CPU_HEAP_ALIGNMENT;                           
  uintptr_t overhead = _Heap_Area_overhead( page_size );              
  size_t i;                                                           
                                                                      
  for (i = 0; i < area_count; ++i) {                                  
4000af84:	b8 07 20 01 	inc  %i4                                       
4000af88:	80 a7 00 19 	cmp  %i4, %i1                                  
4000af8c:	02 80 00 14 	be  4000afdc <_Workspace_Handler_initialization+0x128><== ALWAYS TAKEN
4000af90:	b0 06 20 08 	add  %i0, 8, %i0                               
    Heap_Area *area = &areas [i];                                     
                                                                      
    if ( do_zero ) {                                                  
4000af94:	80 a4 20 00 	cmp  %l0, 0                                    
4000af98:	22 bf ff df 	be,a   4000af14 <_Workspace_Handler_initialization+0x60>
4000af9c:	fa 06 20 04 	ld  [ %i0 + 4 ], %i5                           
      memset( area->begin, 0, area->size );                           
4000afa0:	d0 06 00 00 	ld  [ %i0 ], %o0                               
4000afa4:	d4 06 20 04 	ld  [ %i0 + 4 ], %o2                           
4000afa8:	40 00 14 74 	call  40010178 <memset>                        
4000afac:	92 10 20 00 	clr  %o1                                       
    }                                                                 
                                                                      
    if ( area->size > overhead ) {                                    
4000afb0:	10 bf ff d9 	b  4000af14 <_Workspace_Handler_initialization+0x60>
4000afb4:	fa 06 20 04 	ld  [ %i0 + 4 ], %i5                           
        } else {                                                      
          size = 0;                                                   
        }                                                             
      }                                                               
                                                                      
      space_available = (*init_or_extend)(                            
4000afb8:	90 10 00 13 	mov  %l3, %o0                                  <== NOT EXECUTED
4000afbc:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
4000afc0:	9f c4 40 00 	call  %l1                                      <== NOT EXECUTED
4000afc4:	96 10 20 08 	mov  8, %o3                                    <== NOT EXECUTED
  bool unified = rtems_configuration_get_unified_work_area();         
  uintptr_t page_size = CPU_HEAP_ALIGNMENT;                           
  uintptr_t overhead = _Heap_Area_overhead( page_size );              
  size_t i;                                                           
                                                                      
  for (i = 0; i < area_count; ++i) {                                  
4000afc8:	b8 07 20 01 	inc  %i4                                       <== NOT EXECUTED
        remaining -= space_available;                                 
      } else {                                                        
        remaining = 0;                                                
      }                                                               
                                                                      
      init_or_extend = extend;                                        
4000afcc:	a2 10 00 1a 	mov  %i2, %l1                                  <== NOT EXECUTED
  bool unified = rtems_configuration_get_unified_work_area();         
  uintptr_t page_size = CPU_HEAP_ALIGNMENT;                           
  uintptr_t overhead = _Heap_Area_overhead( page_size );              
  size_t i;                                                           
                                                                      
  for (i = 0; i < area_count; ++i) {                                  
4000afd0:	80 a7 00 19 	cmp  %i4, %i1                                  <== NOT EXECUTED
4000afd4:	12 bf ff f0 	bne  4000af94 <_Workspace_Handler_initialization+0xe0><== NOT EXECUTED
4000afd8:	b0 06 20 08 	add  %i0, 8, %i0                               <== NOT EXECUTED
                                                                      
      init_or_extend = extend;                                        
    }                                                                 
  }                                                                   
                                                                      
  if ( remaining > 0 ) {                                              
4000afdc:	80 a6 e0 00 	cmp  %i3, 0                                    
4000afe0:	12 80 00 07 	bne  4000affc <_Workspace_Handler_initialization+0x148>
4000afe4:	90 10 20 00 	clr  %o0                                       
4000afe8:	81 c7 e0 08 	ret                                            
4000afec:	81 e8 00 00 	restore                                        
        remaining -= space_available;                                 
      } else {                                                        
        remaining = 0;                                                
      }                                                               
                                                                      
      init_or_extend = extend;                                        
4000aff0:	a2 10 00 1a 	mov  %i2, %l1                                  
      area->size -= size;                                             
                                                                      
      if ( space_available < remaining ) {                            
        remaining -= space_available;                                 
      } else {                                                        
        remaining = 0;                                                
4000aff4:	10 bf ff e4 	b  4000af84 <_Workspace_Handler_initialization+0xd0>
4000aff8:	b6 10 20 00 	clr  %i3                                       
      init_or_extend = extend;                                        
    }                                                                 
  }                                                                   
                                                                      
  if ( remaining > 0 ) {                                              
    _Internal_error_Occurred(                                         
4000affc:	92 10 20 01 	mov  1, %o1                                    
4000b000:	7f ff f6 43 	call  4000890c <_Internal_error_Occurred>      
4000b004:	94 10 20 02 	mov  2, %o2                                    
                                                                      

4001b4a0 <_calloc_r>: struct _reent *ignored __attribute__((unused)), size_t elements, size_t size ) { return calloc( elements, size );
4001b4a0:	90 10 00 09 	mov  %o1, %o0                                  <== NOT EXECUTED
4001b4a4:	92 10 00 0a 	mov  %o2, %o1                                  <== NOT EXECUTED
4001b4a8:	82 13 c0 00 	mov  %o7, %g1                                  <== NOT EXECUTED
4001b4ac:	7f ff 9e 30 	call  40002d6c <calloc>                        <== NOT EXECUTED
4001b4b0:	9e 10 40 00 	mov  %g1, %o7                                  <== NOT EXECUTED
                                                                      

4001b52c <_close_r>: int _close_r( struct _reent *ptr __attribute__((unused)), int fd ) { return close( fd );
4001b52c:	90 10 00 09 	mov  %o1, %o0                                  
4001b530:	82 13 c0 00 	mov  %o7, %g1                                  
4001b534:	7f ff ff e0 	call  4001b4b4 <close>                         
4001b538:	9e 10 40 00 	mov  %g1, %o7                                  
                                                                      

400134d8 <_fat_block_read>: uint32_t start, uint32_t offset, uint32_t count, void *buff ) {
400134d8:	9d e3 bf 98 	save  %sp, -104, %sp                           
400134dc:	a0 10 00 18 	mov  %i0, %l0                                  
    uint32_t                sec_num = start;                          
    uint32_t                ofs = offset;                             
    uint8_t                *sec_buf;                                  
    uint32_t                c = 0;                                    
                                                                      
    while (count > 0)                                                 
400134e0:	80 a6 e0 00 	cmp  %i3, 0                                    
400134e4:	12 80 00 11 	bne  40013528 <_fat_block_read+0x50>           <== ALWAYS TAKEN
400134e8:	b0 10 20 00 	clr  %i0                                       
400134ec:	30 80 00 19 	b,a   40013550 <_fat_block_read+0x78>          <== NOT EXECUTED
    {                                                                 
        rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
        if (rc != RC_OK)                                              
            return -1;                                                
                                                                      
        c = MIN(count, (fs_info->vol.bps - ofs));                     
400134f0:	fa 14 00 00 	lduh  [ %l0 ], %i5                             
        memcpy((buff + cmpltd), (sec_buf + ofs), c);                  
400134f4:	d2 07 bf fc 	ld  [ %fp + -4 ], %o1                          
    {                                                                 
        rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
        if (rc != RC_OK)                                              
            return -1;                                                
                                                                      
        c = MIN(count, (fs_info->vol.bps - ofs));                     
400134f8:	ba 27 40 1a 	sub  %i5, %i2, %i5                             
400134fc:	80 a7 40 1b 	cmp  %i5, %i3                                  
40013500:	08 80 00 03 	bleu  4001350c <_fat_block_read+0x34>          
40013504:	92 02 40 1a 	add  %o1, %i2, %o1                             
40013508:	ba 10 00 1b 	mov  %i3, %i5                                  
        memcpy((buff + cmpltd), (sec_buf + ofs), c);                  
4001350c:	40 00 26 46 	call  4001ce24 <memcpy>                        
40013510:	94 10 00 1d 	mov  %i5, %o2                                  
                                                                      
        count -= c;                                                   
        cmpltd += c;                                                  
40013514:	b0 07 40 18 	add  %i5, %i0, %i0                             
        sec_num++;                                                    
40013518:	b2 06 60 01 	inc  %i1                                       
    uint32_t                sec_num = start;                          
    uint32_t                ofs = offset;                             
    uint8_t                *sec_buf;                                  
    uint32_t                c = 0;                                    
                                                                      
    while (count > 0)                                                 
4001351c:	b6 a6 c0 1d 	subcc  %i3, %i5, %i3                           
40013520:	02 80 00 0c 	be  40013550 <_fat_block_read+0x78>            
40013524:	b4 10 20 00 	clr  %i2                                       
    {                                                                 
        rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
40013528:	92 10 00 19 	mov  %i1, %o1                                  
4001352c:	94 10 20 01 	mov  1, %o2                                    
40013530:	96 07 bf fc 	add  %fp, -4, %o3                              
40013534:	7f ff ff bb 	call  40013420 <fat_buf_access>                
40013538:	90 10 00 10 	mov  %l0, %o0                                  
        if (rc != RC_OK)                                              
4001353c:	80 a2 20 00 	cmp  %o0, 0                                    
40013540:	02 bf ff ec 	be  400134f0 <_fat_block_read+0x18>            <== ALWAYS TAKEN
40013544:	90 07 00 18 	add  %i4, %i0, %o0                             
        cmpltd += c;                                                  
        sec_num++;                                                    
        ofs = 0;                                                      
    }                                                                 
    return cmpltd;                                                    
}                                                                     
40013548:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001354c:	91 e8 3f ff 	restore  %g0, -1, %o0                          <== NOT EXECUTED
40013550:	81 c7 e0 08 	ret                                            
40013554:	81 e8 00 00 	restore                                        
                                                                      

40003d00 <_lstat_r>: struct _reent *ptr __attribute__((unused)), const char *path, struct stat *buf ) { return _STAT_NAME( path, buf );
40003d00:	90 10 00 09 	mov  %o1, %o0                                  <== NOT EXECUTED
40003d04:	92 10 00 0a 	mov  %o2, %o1                                  <== NOT EXECUTED
40003d08:	82 13 c0 00 	mov  %o7, %g1                                  <== NOT EXECUTED
40003d0c:	7f ff ff e9 	call  40003cb0 <lstat>                         <== NOT EXECUTED
40003d10:	9e 10 40 00 	mov  %g1, %o7                                  <== NOT EXECUTED
                                                                      

40003f38 <_stat_r>: struct _reent *ptr __attribute__((unused)), const char *path, struct stat *buf ) { return _STAT_NAME( path, buf );
40003f38:	90 10 00 09 	mov  %o1, %o0                                  <== NOT EXECUTED
40003f3c:	92 10 00 0a 	mov  %o2, %o1                                  <== NOT EXECUTED
40003f40:	82 13 c0 00 	mov  %o7, %g1                                  <== NOT EXECUTED
40003f44:	7f ff ff e9 	call  40003ee8 <stat>                          <== NOT EXECUTED
40003f48:	9e 10 40 00 	mov  %g1, %o7                                  <== NOT EXECUTED
                                                                      

40006ec0 <adjtime>: */ int adjtime( const struct timeval *delta, struct timeval *olddelta ) {
40006ec0:	9d e3 bf 98 	save  %sp, -104, %sp                           
  long   adjustment;                                                  
                                                                      
  /*                                                                  
   * Simple validations                                               
   */                                                                 
  if ( !delta )                                                       
40006ec4:	80 a6 20 00 	cmp  %i0, 0                                    
40006ec8:	02 80 00 8e 	be  40007100 <adjtime+0x240>                   
40006ecc:	01 00 00 00 	nop                                            
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND )                
40006ed0:	c4 06 20 04 	ld  [ %i0 + 4 ], %g2                           
40006ed4:	03 00 03 d0 	sethi  %hi(0xf4000), %g1                       
40006ed8:	82 10 62 3f 	or  %g1, 0x23f, %g1	! f423f <PROM_START+0xf423f>
40006edc:	80 a0 80 01 	cmp  %g2, %g1                                  
40006ee0:	18 80 00 88 	bgu  40007100 <adjtime+0x240>                  
40006ee4:	80 a6 60 00 	cmp  %i1, 0                                    
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( olddelta ) {                                                   
40006ee8:	22 80 00 06 	be,a   40006f00 <adjtime+0x40>                 
40006eec:	c2 06 00 00 	ld  [ %i0 ], %g1                               
    olddelta->tv_sec  = 0;                                            
    olddelta->tv_usec = 0;                                            
40006ef0:	c0 26 60 04 	clr  [ %i1 + 4 ]                               
40006ef4:	c4 06 20 04 	ld  [ %i0 + 4 ], %g2                           
                                                                      
  if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND )                
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( olddelta ) {                                                   
    olddelta->tv_sec  = 0;                                            
40006ef8:	c0 26 40 00 	clr  [ %i1 ]                                   
    olddelta->tv_usec = 0;                                            
  }                                                                   
                                                                      
  /* convert delta to microseconds */                                 
  adjustment  = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND);        
40006efc:	c2 06 00 00 	ld  [ %i0 ], %g1                               
  adjustment += delta->tv_usec;                                       
                                                                      
  /* too small to account for */                                      
  if ( adjustment < rtems_configuration_get_microseconds_per_tick() ) 
40006f00:	07 10 00 5d 	sethi  %hi(0x40017400), %g3                    
40006f04:	c8 00 e1 4c 	ld  [ %g3 + 0x14c ], %g4	! 4001754c <Configuration+0xc>
    olddelta->tv_sec  = 0;                                            
    olddelta->tv_usec = 0;                                            
  }                                                                   
                                                                      
  /* convert delta to microseconds */                                 
  adjustment  = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND);        
40006f08:	bb 28 60 08 	sll  %g1, 8, %i5                               
40006f0c:	87 28 60 03 	sll  %g1, 3, %g3                               
40006f10:	86 27 40 03 	sub  %i5, %g3, %g3                             
40006f14:	bb 28 e0 06 	sll  %g3, 6, %i5                               
40006f18:	86 27 40 03 	sub  %i5, %g3, %g3                             
40006f1c:	82 00 c0 01 	add  %g3, %g1, %g1                             
40006f20:	83 28 60 06 	sll  %g1, 6, %g1                               
  adjustment += delta->tv_usec;                                       
40006f24:	84 00 40 02 	add  %g1, %g2, %g2                             
                                                                      
  /* too small to account for */                                      
  if ( adjustment < rtems_configuration_get_microseconds_per_tick() ) 
40006f28:	80 a0 80 04 	cmp  %g2, %g4                                  
40006f2c:	1a 80 00 05 	bcc  40006f40 <adjtime+0x80>                   
40006f30:	03 10 00 65 	sethi  %hi(0x40019400), %g1                    
    return 0;                                                         
40006f34:	82 10 20 00 	clr  %g1                                       
  /* set the user's output */                                         
  if ( olddelta )                                                     
    *olddelta = *delta;                                               
                                                                      
  return 0;                                                           
}                                                                     
40006f38:	81 c7 e0 08 	ret                                            
40006f3c:	91 e8 00 01 	restore  %g0, %g1, %o0                         
   *                                                                  
   * This rountine increments the thread dispatch level               
   */                                                                 
  RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
  {                                                                   
    uint32_t level = _Thread_Dispatch_disable_level;                  
40006f40:	c4 00 63 e0 	ld  [ %g1 + 0x3e0 ], %g2                       
                                                                      
    ++level;                                                          
40006f44:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
40006f48:	c4 20 63 e0 	st  %g2, [ %g1 + 0x3e0 ]                       
)                                                                     
{                                                                     
  Timestamp_Control  tod_as_timestamp;                                
  Timestamp_Control *tod_as_timestamp_ptr;                            
                                                                      
  tod_as_timestamp_ptr =                                              
40006f4c:	13 10 00 65 	sethi  %hi(0x40019400), %o1                    
40006f50:	90 07 bf f8 	add  %fp, -8, %o0                              
40006f54:	40 00 07 1c 	call  40008bc4 <_TOD_Get_with_nanoseconds>     
40006f58:	92 12 63 28 	or  %o1, 0x328, %o1                            
40006f5c:	f8 1a 00 00 	ldd  [ %o0 ], %i4                              
static inline void _Timestamp64_implementation_To_timespec(           
  const Timestamp64_Control *_timestamp,                              
  struct timespec           *_timespec                                
)                                                                     
{                                                                     
  _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);           
40006f60:	94 10 20 00 	clr  %o2                                       
40006f64:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
40006f68:	90 10 00 1c 	mov  %i4, %o0                                  
40006f6c:	96 12 e2 00 	or  %o3, 0x200, %o3                            
40006f70:	40 00 3a 42 	call  40015878 <__divdi3>                      
40006f74:	92 10 00 1d 	mov  %i5, %o1                                  
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
    _TOD_Get( &ts );                                                  
                                                                      
    ts.tv_sec  += delta->tv_sec;                                      
40006f78:	f6 06 00 00 	ld  [ %i0 ], %i3                               
  _timespec->tv_nsec = (long) (*_timestamp % 1000000000L);            
40006f7c:	94 10 20 00 	clr  %o2                                       
40006f80:	b6 06 c0 09 	add  %i3, %o1, %i3                             
40006f84:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
40006f88:	90 10 00 1c 	mov  %i4, %o0                                  
40006f8c:	96 12 e2 00 	or  %o3, 0x200, %o3                            
40006f90:	40 00 3b 25 	call  40015c24 <__moddi3>                      
40006f94:	92 10 00 1d 	mov  %i5, %o1                                  
    ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;   
40006f98:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
                                                                      
    /* if adjustment is too much positive */                          
    while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {              
      ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;                       
40006f9c:	09 31 19 4d 	sethi  %hi(0xc4653400), %g4                    
  _Thread_Disable_dispatch();                                         
                                                                      
    _TOD_Get( &ts );                                                  
                                                                      
    ts.tv_sec  += delta->tv_sec;                                      
    ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;   
40006fa0:	87 28 60 07 	sll  %g1, 7, %g3                               
40006fa4:	85 28 60 02 	sll  %g1, 2, %g2                               
40006fa8:	84 20 c0 02 	sub  %g3, %g2, %g2                             
                                                                      
    /* if adjustment is too much positive */                          
    while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {              
      ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;                       
40006fac:	88 11 22 00 	or  %g4, 0x200, %g4                            
  _Thread_Disable_dispatch();                                         
                                                                      
    _TOD_Get( &ts );                                                  
                                                                      
    ts.tv_sec  += delta->tv_sec;                                      
    ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;   
40006fb0:	82 00 80 01 	add  %g2, %g1, %g1                             
                                                                      
    /* if adjustment is too much positive */                          
    while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {              
40006fb4:	07 0e e6 b2 	sethi  %hi(0x3b9ac800), %g3                    
  _Thread_Disable_dispatch();                                         
                                                                      
    _TOD_Get( &ts );                                                  
                                                                      
    ts.tv_sec  += delta->tv_sec;                                      
    ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;   
40006fb8:	83 28 60 03 	sll  %g1, 3, %g1                               
                                                                      
    /* if adjustment is too much positive */                          
    while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {              
40006fbc:	86 10 e1 ff 	or  %g3, 0x1ff, %g3                            
  _Thread_Disable_dispatch();                                         
                                                                      
    _TOD_Get( &ts );                                                  
                                                                      
    ts.tv_sec  += delta->tv_sec;                                      
    ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;   
40006fc0:	92 02 40 01 	add  %o1, %g1, %o1                             
                                                                      
    /* if adjustment is too much positive */                          
    while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {              
40006fc4:	80 a2 40 03 	cmp  %o1, %g3                                  
40006fc8:	08 80 00 07 	bleu  40006fe4 <adjtime+0x124>                 
40006fcc:	84 06 e0 01 	add  %i3, 1, %g2                               
      ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;                       
40006fd0:	92 02 40 04 	add  %o1, %g4, %o1                             
      ts.tv_sec++;                                                    
40006fd4:	b6 10 00 02 	mov  %g2, %i3                                  
                                                                      
    ts.tv_sec  += delta->tv_sec;                                      
    ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;   
                                                                      
    /* if adjustment is too much positive */                          
    while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {              
40006fd8:	80 a2 40 03 	cmp  %o1, %g3                                  
40006fdc:	18 bf ff fd 	bgu  40006fd0 <adjtime+0x110>                  <== NEVER TAKEN
40006fe0:	84 00 a0 01 	inc  %g2                                       
      ts.tv_sec++;                                                    
    }                                                                 
                                                                      
    /* if adjustment is too much negative */                          
    while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) {       
      ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND;                       
40006fe4:	3b 0e e6 b2 	sethi  %hi(0x3b9ac800), %i5                    
      ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;                       
      ts.tv_sec++;                                                    
    }                                                                 
                                                                      
    /* if adjustment is too much negative */                          
    while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) {       
40006fe8:	07 31 19 4d 	sethi  %hi(0xc4653400), %g3                    
40006fec:	82 10 00 09 	mov  %o1, %g1                                  
int _EXFUN(setitimer, (int __which, const struct itimerval *__value,  
					struct itimerval *__ovalue));                                    
                                                                      
#if defined(__rtems__)                                                
/* BSD function used by RTEMS code */                                 
int _EXFUN(adjtime,(const struct timeval *, struct timeval *));       
40006ff0:	84 06 ff ff 	add  %i3, -1, %g2                              
      ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND;                       
40006ff4:	ba 17 62 00 	or  %i5, 0x200, %i5                            
      ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;                       
      ts.tv_sec++;                                                    
    }                                                                 
                                                                      
    /* if adjustment is too much negative */                          
    while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) {       
40006ff8:	86 10 e2 00 	or  %g3, 0x200, %g3                            
      ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND;                       
40006ffc:	82 00 40 1d 	add  %g1, %i5, %g1                             
      ts.tv_sec--;                                                    
40007000:	88 10 00 02 	mov  %g2, %g4                                  
      ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;                       
      ts.tv_sec++;                                                    
    }                                                                 
                                                                      
    /* if adjustment is too much negative */                          
    while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) {       
40007004:	80 a0 40 03 	cmp  %g1, %g3                                  
40007008:	08 bf ff fd 	bleu  40006ffc <adjtime+0x13c>                 
4000700c:	84 00 bf ff 	add  %g2, -1, %g2                              
  const struct timespec *tod_as_timespec                              
)                                                                     
{                                                                     
  Timestamp_Control tod_as_timestamp;                                 
                                                                      
  _Timestamp_Set(                                                     
40007010:	85 39 20 1f 	sra  %g4, 0x1f, %g2                            
40007014:	a6 10 00 01 	mov  %g1, %l3                                  
40007018:	a5 38 60 1f 	sra  %g1, 0x1f, %l2                            
  Timestamp64_Control *_time,                                         
  Timestamp64_Control  _seconds,                                      
  Timestamp64_Control  _nanoseconds                                   
)                                                                     
{                                                                     
  *_time = _seconds * 1000000000L + _nanoseconds;                     
4000701c:	83 28 a0 03 	sll  %g2, 3, %g1                               
40007020:	86 10 00 04 	mov  %g4, %g3                                  
40007024:	89 31 20 1d 	srl  %g4, 0x1d, %g4                            
40007028:	bb 28 e0 03 	sll  %g3, 3, %i5                               
4000702c:	b8 11 00 01 	or  %g4, %g1, %i4                              
40007030:	83 37 60 1b 	srl  %i5, 0x1b, %g1                            
40007034:	a9 2f 20 05 	sll  %i4, 5, %l4                               
40007038:	ab 2f 60 05 	sll  %i5, 5, %l5                               
4000703c:	a8 10 40 14 	or  %g1, %l4, %l4                              
40007040:	ba a5 40 1d 	subcc  %l5, %i5, %i5                           
40007044:	83 37 60 1a 	srl  %i5, 0x1a, %g1                            
40007048:	b8 65 00 1c 	subx  %l4, %i4, %i4                            
4000704c:	a3 2f 60 06 	sll  %i5, 6, %l1                               
40007050:	a1 2f 20 06 	sll  %i4, 6, %l0                               
40007054:	ba a4 40 1d 	subcc  %l1, %i5, %i5                           
40007058:	a0 10 40 10 	or  %g1, %l0, %l0                              
4000705c:	b8 64 00 1c 	subx  %l0, %i4, %i4                            
40007060:	ae 87 40 03 	addcc  %i5, %g3, %l7                           
40007064:	83 35 e0 1e 	srl  %l7, 0x1e, %g1                            
40007068:	ac 47 00 02 	addx  %i4, %g2, %l6                            
4000706c:	97 2d e0 02 	sll  %l7, 2, %o3                               
40007070:	95 2d a0 02 	sll  %l6, 2, %o2                               
40007074:	86 85 c0 0b 	addcc  %l7, %o3, %g3                           
40007078:	94 10 40 0a 	or  %g1, %o2, %o2                              
4000707c:	9b 28 e0 02 	sll  %g3, 2, %o5                               
40007080:	84 45 80 0a 	addx  %l6, %o2, %g2                            
40007084:	83 30 e0 1e 	srl  %g3, 0x1e, %g1                            
40007088:	ba 80 c0 0d 	addcc  %g3, %o5, %i5                           
4000708c:	99 28 a0 02 	sll  %g2, 2, %o4                               
40007090:	b7 2f 60 02 	sll  %i5, 2, %i3                               
40007094:	98 10 40 0c 	or  %g1, %o4, %o4                              
40007098:	83 37 60 1e 	srl  %i5, 0x1e, %g1                            
4000709c:	b8 40 80 0c 	addx  %g2, %o4, %i4                            
400070a0:	86 87 40 1b 	addcc  %i5, %i3, %g3                           
400070a4:	b5 2f 20 02 	sll  %i4, 2, %i2                               
400070a8:	bb 30 e0 17 	srl  %g3, 0x17, %i5                            
400070ac:	b4 10 40 1a 	or  %g1, %i2, %i2                              
400070b0:	84 47 00 1a 	addx  %i4, %i2, %g2                            
400070b4:	83 28 e0 09 	sll  %g3, 9, %g1                               
400070b8:	89 28 a0 09 	sll  %g2, 9, %g4                               
    &tod_as_timestamp,                                                
    tod_as_timespec->tv_sec,                                          
    tod_as_timespec->tv_nsec                                          
  );                                                                  
  _TOD_Set_with_timestamp( &tod_as_timestamp );                       
400070bc:	90 07 bf f8 	add  %fp, -8, %o0                              
400070c0:	84 17 40 04 	or  %i5, %g4, %g2                              
400070c4:	ba 84 c0 01 	addcc  %l3, %g1, %i5                           
400070c8:	b8 44 80 02 	addx  %l2, %g2, %i4                            
400070cc:	40 00 06 d9 	call  40008c30 <_TOD_Set_with_timestamp>       
400070d0:	f8 3f bf f8 	std  %i4, [ %fp + -8 ]                         
      ts.tv_sec--;                                                    
    }                                                                 
                                                                      
    _TOD_Set( &ts );                                                  
                                                                      
  _Thread_Enable_dispatch();                                          
400070d4:	40 00 0d 7e 	call  4000a6cc <_Thread_Enable_dispatch>       
400070d8:	01 00 00 00 	nop                                            
                                                                      
  /* set the user's output */                                         
  if ( olddelta )                                                     
400070dc:	80 a6 60 00 	cmp  %i1, 0                                    
400070e0:	02 bf ff 95 	be  40006f34 <adjtime+0x74>                    
400070e4:	82 10 20 00 	clr  %g1                                       
    *olddelta = *delta;                                               
400070e8:	c4 06 00 00 	ld  [ %i0 ], %g2                               
400070ec:	c4 26 40 00 	st  %g2, [ %i1 ]                               
400070f0:	c4 06 20 04 	ld  [ %i0 + 4 ], %g2                           
400070f4:	c4 26 60 04 	st  %g2, [ %i1 + 4 ]                           
                                                                      
  return 0;                                                           
}                                                                     
400070f8:	81 c7 e0 08 	ret                                            
400070fc:	91 e8 00 01 	restore  %g0, %g1, %o0                         
   */                                                                 
  if ( !delta )                                                       
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND )                
    rtems_set_errno_and_return_minus_one( EINVAL );                   
40007100:	40 00 23 b0 	call  4000ffc0 <__errno>                       
40007104:	01 00 00 00 	nop                                            
40007108:	84 10 20 16 	mov  0x16, %g2	! 16 <PROM_START+0x16>          
4000710c:	82 10 3f ff 	mov  -1, %g1                                   
40007110:	10 bf ff 8a 	b  40006f38 <adjtime+0x78>                     
40007114:	c4 22 00 00 	st  %g2, [ %o0 ]                               
                                                                      

400070cc <aio_cancel>: #include <stdlib.h> #include <rtems/system.h> #include <rtems/seterr.h> int aio_cancel(int fildes, struct aiocb *aiocbp) {
400070cc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_aio_request_chain *r_chain;                                   
  int result;                                                         
                                                                      
  pthread_mutex_lock (&aio_request_queue.mutex);                      
400070d0:	3b 10 00 63 	sethi  %hi(0x40018c00), %i5                    
400070d4:	40 00 04 85 	call  400082e8 <pthread_mutex_lock>            
400070d8:	90 17 63 f4 	or  %i5, 0x3f4, %o0	! 40018ff4 <aio_request_queue>
                                                                      
  if (fcntl (fildes, F_GETFD) < 0) {                                  
400070dc:	90 10 00 18 	mov  %i0, %o0                                  
400070e0:	40 00 1b af 	call  4000df9c <fcntl>                         
400070e4:	92 10 20 01 	mov  1, %o1                                    
400070e8:	80 a2 20 00 	cmp  %o0, 0                                    
400070ec:	06 80 00 6c 	bl  4000729c <aio_cancel+0x1d0>                
400070f0:	80 a6 60 00 	cmp  %i1, 0                                    
    pthread_mutex_unlock(&aio_request_queue.mutex);                   
    rtems_set_errno_and_return_minus_one (EBADF);                     
  }                                                                   
                                                                      
  /* if aiocbp is NULL remove all request for given file descriptor */
  if (aiocbp == NULL) {                                               
400070f4:	02 80 00 3b 	be  400071e0 <aio_cancel+0x114>                
400070f8:	92 10 00 18 	mov  %i0, %o1                                  
    pthread_mutex_unlock (&aio_request_queue.mutex);                  
    return AIO_CANCELED;                                              
  } else {                                                            
    AIO_printf ("Cancel request\n");                                  
                                                                      
    if (aiocbp->aio_fildes != fildes) {                               
400070fc:	f8 06 40 00 	ld  [ %i1 ], %i4                               
40007100:	80 a7 00 18 	cmp  %i4, %i0                                  
40007104:	12 80 00 2f 	bne  400071c0 <aio_cancel+0xf4>                
40007108:	90 17 63 f4 	or  %i5, 0x3f4, %o0                            
      pthread_mutex_unlock (&aio_request_queue.mutex);                
      rtems_set_errno_and_return_minus_one (EINVAL);                  
    }                                                                 
                                                                      
    r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
4000710c:	92 10 00 1c 	mov  %i4, %o1                                  
40007110:	11 10 00 64 	sethi  %hi(0x40019000), %o0                    
40007114:	94 10 20 00 	clr  %o2                                       
40007118:	40 00 01 92 	call  40007760 <rtems_aio_search_fd>           
4000711c:	90 12 20 3c 	or  %o0, 0x3c, %o0                             
    if (r_chain == NULL) {                                            
40007120:	b6 92 20 00 	orcc  %o0, 0, %i3                              
40007124:	22 80 00 0f 	be,a   40007160 <aio_cancel+0x94>              
40007128:	b6 17 63 f4 	or  %i5, 0x3f4, %i3                            
        return AIO_ALLDONE;                                           
      }                                                               
    }                                                                 
      AIO_printf ("Request on [WQ]\n");                               
                                                                      
      pthread_mutex_lock (&r_chain->mutex);                           
4000712c:	b8 06 e0 1c 	add  %i3, 0x1c, %i4                            
40007130:	40 00 04 6e 	call  400082e8 <pthread_mutex_lock>            
40007134:	90 10 00 1c 	mov  %i4, %o0                                  
      result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);        
40007138:	92 10 00 19 	mov  %i1, %o1                                  
4000713c:	40 00 01 d2 	call  40007884 <rtems_aio_remove_req>          
40007140:	90 06 e0 08 	add  %i3, 8, %o0                               
40007144:	b0 10 00 08 	mov  %o0, %i0                                  
      pthread_mutex_unlock (&r_chain->mutex);                         
40007148:	40 00 04 88 	call  40008368 <pthread_mutex_unlock>          
4000714c:	90 10 00 1c 	mov  %i4, %o0                                  
      pthread_mutex_unlock (&aio_request_queue.mutex);                
40007150:	40 00 04 86 	call  40008368 <pthread_mutex_unlock>          
40007154:	90 17 63 f4 	or  %i5, 0x3f4, %o0                            
      return result;                                                  
  }                                                                   
  return AIO_ALLDONE;                                                 
}                                                                     
40007158:	81 c7 e0 08 	ret                                            
4000715c:	81 e8 00 00 	restore                                        
      rtems_set_errno_and_return_minus_one (EINVAL);                  
    }                                                                 
                                                                      
    r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
    if (r_chain == NULL) {                                            
      if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {      
40007160:	c4 06 e0 54 	ld  [ %i3 + 0x54 ], %g2                        
40007164:	82 06 e0 58 	add  %i3, 0x58, %g1                            
40007168:	80 a0 80 01 	cmp  %g2, %g1                                  
4000716c:	02 80 00 0f 	be  400071a8 <aio_cancel+0xdc>                 <== NEVER TAKEN
40007170:	90 06 e0 54 	add  %i3, 0x54, %o0                            
        r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
40007174:	92 10 00 1c 	mov  %i4, %o1                                  
40007178:	40 00 01 7a 	call  40007760 <rtems_aio_search_fd>           
4000717c:	94 10 20 00 	clr  %o2                                       
        if (r_chain == NULL) {                                        
40007180:	80 a2 20 00 	cmp  %o0, 0                                    
40007184:	02 80 00 0e 	be  400071bc <aio_cancel+0xf0>                 
40007188:	92 10 00 19 	mov  %i1, %o1                                  
          rtems_set_errno_and_return_minus_one (EINVAL);              
        }                                                             
                                                                      
        AIO_printf ("Request on [IQ]\n");                             
                                                                      
        result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);      
4000718c:	40 00 01 be 	call  40007884 <rtems_aio_remove_req>          
40007190:	90 02 20 08 	add  %o0, 8, %o0                               
40007194:	b0 10 00 08 	mov  %o0, %i0                                  
        pthread_mutex_unlock (&aio_request_queue.mutex);              
40007198:	40 00 04 74 	call  40008368 <pthread_mutex_unlock>          
4000719c:	90 10 00 1b 	mov  %i3, %o0                                  
        return result;                                                
400071a0:	81 c7 e0 08 	ret                                            
400071a4:	81 e8 00 00 	restore                                        
                                                                      
      if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {      
        r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
        if (r_chain == NULL) {                                        
          pthread_mutex_unlock(&aio_request_queue.mutex);             
          return AIO_ALLDONE;                                         
400071a8:	b0 10 20 02 	mov  2, %i0                                    <== NOT EXECUTED
      AIO_printf ("Request chain not on [WQ]\n");                     
                                                                      
      if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {      
        r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
        if (r_chain == NULL) {                                        
          pthread_mutex_unlock(&aio_request_queue.mutex);             
400071ac:	40 00 04 6f 	call  40008368 <pthread_mutex_unlock>          
400071b0:	90 17 63 f4 	or  %i5, 0x3f4, %o0                            
          return AIO_ALLDONE;                                         
400071b4:	81 c7 e0 08 	ret                                            
400071b8:	81 e8 00 00 	restore                                        
    r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
    if (r_chain == NULL) {                                            
      if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {      
        r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
        if (r_chain == NULL) {                                        
          pthread_mutex_unlock (&aio_request_queue.mutex);            
400071bc:	90 10 00 1b 	mov  %i3, %o0                                  
400071c0:	40 00 04 6a 	call  40008368 <pthread_mutex_unlock>          
400071c4:	b0 10 3f ff 	mov  -1, %i0                                   
          rtems_set_errno_and_return_minus_one (EINVAL);              
400071c8:	40 00 29 9e 	call  40011840 <__errno>                       
400071cc:	01 00 00 00 	nop                                            
400071d0:	82 10 20 16 	mov  0x16, %g1	! 16 <PROM_START+0x16>          
400071d4:	c2 22 00 00 	st  %g1, [ %o0 ]                               
400071d8:	81 c7 e0 08 	ret                                            
400071dc:	81 e8 00 00 	restore                                        
                                                                      
  /* if aiocbp is NULL remove all request for given file descriptor */
  if (aiocbp == NULL) {                                               
    AIO_printf ("Cancel all requests\n");                             
                                                                      
    r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
400071e0:	11 10 00 64 	sethi  %hi(0x40019000), %o0                    
400071e4:	94 10 20 00 	clr  %o2                                       
400071e8:	40 00 01 5e 	call  40007760 <rtems_aio_search_fd>           
400071ec:	90 12 20 3c 	or  %o0, 0x3c, %o0                             
    if (r_chain == NULL) {                                            
400071f0:	b8 92 20 00 	orcc  %o0, 0, %i4                              
400071f4:	02 80 00 0f 	be  40007230 <aio_cancel+0x164>                
400071f8:	b6 07 20 1c 	add  %i4, 0x1c, %i3                            
      return AIO_ALLDONE;                                             
    }                                                                 
                                                                      
    AIO_printf ("Request chain on [WQ]\n");                           
                                                                      
    pthread_mutex_lock (&r_chain->mutex);                             
400071fc:	40 00 04 3b 	call  400082e8 <pthread_mutex_lock>            
40007200:	90 10 00 1b 	mov  %i3, %o0                                  
 */                                                                   
RTEMS_INLINE_ROUTINE void rtems_chain_extract(                        
  rtems_chain_node *the_node                                          
)                                                                     
{                                                                     
  _Chain_Extract( the_node );                                         
40007204:	40 00 0b 28 	call  40009ea4 <_Chain_Extract>                
40007208:	90 10 00 1c 	mov  %i4, %o0                                  
    rtems_chain_extract (&r_chain->next_fd);                          
    rtems_aio_remove_fd (r_chain);                                    
4000720c:	40 00 01 8a 	call  40007834 <rtems_aio_remove_fd>           
40007210:	90 10 00 1c 	mov  %i4, %o0                                  
    pthread_mutex_unlock (&r_chain->mutex);                           
40007214:	40 00 04 55 	call  40008368 <pthread_mutex_unlock>          
40007218:	90 10 00 1b 	mov  %i3, %o0                                  
    pthread_mutex_unlock (&aio_request_queue.mutex);                  
    return AIO_CANCELED;                                              
4000721c:	b0 10 20 00 	clr  %i0                                       
                                                                      
    pthread_mutex_lock (&r_chain->mutex);                             
    rtems_chain_extract (&r_chain->next_fd);                          
    rtems_aio_remove_fd (r_chain);                                    
    pthread_mutex_unlock (&r_chain->mutex);                           
    pthread_mutex_unlock (&aio_request_queue.mutex);                  
40007220:	40 00 04 52 	call  40008368 <pthread_mutex_unlock>          
40007224:	90 17 63 f4 	or  %i5, 0x3f4, %o0                            
    return AIO_CANCELED;                                              
40007228:	81 c7 e0 08 	ret                                            
4000722c:	81 e8 00 00 	restore                                        
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(        
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_head( the_chain )->next;                    
40007230:	b8 17 63 f4 	or  %i5, 0x3f4, %i4                            
                                                                      
    r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
    if (r_chain == NULL) {                                            
      AIO_printf ("Request chain not on [WQ]\n");                     
                                                                      
      if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {      
40007234:	c4 07 20 54 	ld  [ %i4 + 0x54 ], %g2                        
40007238:	82 07 20 58 	add  %i4, 0x58, %g1                            
4000723c:	80 a0 80 01 	cmp  %g2, %g1                                  
40007240:	02 bf ff da 	be  400071a8 <aio_cancel+0xdc>                 <== NEVER TAKEN
40007244:	90 07 20 54 	add  %i4, 0x54, %o0                            
        r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
40007248:	92 10 00 18 	mov  %i0, %o1                                  
4000724c:	40 00 01 45 	call  40007760 <rtems_aio_search_fd>           
40007250:	94 10 20 00 	clr  %o2                                       
        if (r_chain == NULL) {                                        
40007254:	b6 92 20 00 	orcc  %o0, 0, %i3                              
40007258:	22 bf ff d5 	be,a   400071ac <aio_cancel+0xe0>              
4000725c:	b0 10 20 02 	mov  2, %i0                                    
40007260:	40 00 0b 11 	call  40009ea4 <_Chain_Extract>                
40007264:	ba 06 e0 1c 	add  %i3, 0x1c, %i5                            
        }                                                             
                                                                      
        AIO_printf ("Request chain on [IQ]\n");                       
                                                                      
        rtems_chain_extract (&r_chain->next_fd);                      
        rtems_aio_remove_fd (r_chain);                                
40007268:	40 00 01 73 	call  40007834 <rtems_aio_remove_fd>           
4000726c:	90 10 00 1b 	mov  %i3, %o0                                  
        pthread_mutex_destroy (&r_chain->mutex);                      
40007270:	40 00 03 72 	call  40008038 <pthread_mutex_destroy>         
40007274:	90 10 00 1d 	mov  %i5, %o0                                  
        pthread_cond_destroy (&r_chain->mutex);                       
40007278:	40 00 02 94 	call  40007cc8 <pthread_cond_destroy>          
4000727c:	90 10 00 1d 	mov  %i5, %o0                                  
        free (r_chain);                                               
40007280:	7f ff f0 1f 	call  400032fc <free>                          
40007284:	90 10 00 1b 	mov  %i3, %o0                                  
                                                                      
        pthread_mutex_unlock (&aio_request_queue.mutex);              
        return AIO_CANCELED;                                          
40007288:	b0 10 20 00 	clr  %i0                                       
        rtems_aio_remove_fd (r_chain);                                
        pthread_mutex_destroy (&r_chain->mutex);                      
        pthread_cond_destroy (&r_chain->mutex);                       
        free (r_chain);                                               
                                                                      
        pthread_mutex_unlock (&aio_request_queue.mutex);              
4000728c:	40 00 04 37 	call  40008368 <pthread_mutex_unlock>          
40007290:	90 10 00 1c 	mov  %i4, %o0                                  
        return AIO_CANCELED;                                          
40007294:	81 c7 e0 08 	ret                                            
40007298:	81 e8 00 00 	restore                                        
  int result;                                                         
                                                                      
  pthread_mutex_lock (&aio_request_queue.mutex);                      
                                                                      
  if (fcntl (fildes, F_GETFD) < 0) {                                  
    pthread_mutex_unlock(&aio_request_queue.mutex);                   
4000729c:	40 00 04 33 	call  40008368 <pthread_mutex_unlock>          
400072a0:	90 17 63 f4 	or  %i5, 0x3f4, %o0                            
    rtems_set_errno_and_return_minus_one (EBADF);                     
400072a4:	40 00 29 67 	call  40011840 <__errno>                       
400072a8:	b0 10 3f ff 	mov  -1, %i0                                   
400072ac:	82 10 20 09 	mov  9, %g1                                    
400072b0:	c2 22 00 00 	st  %g1, [ %o0 ]                               
400072b4:	81 c7 e0 08 	ret                                            
400072b8:	81 e8 00 00 	restore                                        
                                                                      

400072c4 <aio_fsync>: int aio_fsync( int op, struct aiocb *aiocbp ) {
400072c4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_aio_request *req;                                             
  int mode;                                                           
                                                                      
  if (op != O_SYNC)                                                   
400072c8:	03 00 00 08 	sethi  %hi(0x2000), %g1                        
400072cc:	80 a6 00 01 	cmp  %i0, %g1                                  
400072d0:	12 80 00 14 	bne  40007320 <aio_fsync+0x5c>                 
400072d4:	ba 10 20 16 	mov  0x16, %i5                                 
    rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);            
                                                                      
  mode = fcntl (aiocbp->aio_fildes, F_GETFL);                         
400072d8:	d0 06 40 00 	ld  [ %i1 ], %o0                               
400072dc:	40 00 1b 30 	call  4000df9c <fcntl>                         
400072e0:	92 10 20 03 	mov  3, %o1                                    
  if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
400072e4:	90 0a 20 03 	and  %o0, 3, %o0                               
400072e8:	90 02 3f ff 	add  %o0, -1, %o0                              
400072ec:	80 a2 20 01 	cmp  %o0, 1                                    
400072f0:	18 80 00 0c 	bgu  40007320 <aio_fsync+0x5c>                 
400072f4:	ba 10 20 09 	mov  9, %i5                                    
    rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);             
                                                                      
  req = malloc (sizeof (rtems_aio_request));                          
400072f8:	7f ff f1 28 	call  40003798 <malloc>                        
400072fc:	90 10 20 18 	mov  0x18, %o0                                 
  if (req == NULL)                                                    
40007300:	80 a2 20 00 	cmp  %o0, 0                                    
40007304:	02 80 00 06 	be  4000731c <aio_fsync+0x58>                  <== NEVER TAKEN
40007308:	82 10 20 03 	mov  3, %g1                                    
    rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);            
                                                                      
  req->aiocbp = aiocbp;                                               
4000730c:	f2 22 20 14 	st  %i1, [ %o0 + 0x14 ]                        
  req->aiocbp->aio_lio_opcode = LIO_SYNC;                             
40007310:	c2 26 60 30 	st  %g1, [ %i1 + 0x30 ]                        
                                                                      
  return rtems_aio_enqueue (req);                                     
40007314:	40 00 01 78 	call  400078f4 <rtems_aio_enqueue>             
40007318:	91 e8 00 08 	restore  %g0, %o0, %o0                         
  if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
    rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);             
                                                                      
  req = malloc (sizeof (rtems_aio_request));                          
  if (req == NULL)                                                    
    rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);            
4000731c:	ba 10 20 0b 	mov  0xb, %i5                                  <== NOT EXECUTED
40007320:	82 10 3f ff 	mov  -1, %g1                                   
40007324:	fa 26 60 34 	st  %i5, [ %i1 + 0x34 ]                        
40007328:	c2 26 60 38 	st  %g1, [ %i1 + 0x38 ]                        
4000732c:	40 00 29 45 	call  40011840 <__errno>                       
40007330:	b0 10 3f ff 	mov  -1, %i0                                   
40007334:	fa 22 00 00 	st  %i5, [ %o0 ]                               
  req->aiocbp = aiocbp;                                               
  req->aiocbp->aio_lio_opcode = LIO_SYNC;                             
                                                                      
  return rtems_aio_enqueue (req);                                     
                                                                      
}                                                                     
40007338:	81 c7 e0 08 	ret                                            
4000733c:	81 e8 00 00 	restore                                        
                                                                      

40007ad8 <aio_read>: * 0 - otherwise */ int aio_read (struct aiocb *aiocbp) {
40007ad8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_aio_request *req;                                             
  int mode;                                                           
                                                                      
  mode = fcntl (aiocbp->aio_fildes, F_GETFL);                         
40007adc:	d0 06 00 00 	ld  [ %i0 ], %o0                               
40007ae0:	92 10 20 03 	mov  3, %o1                                    
40007ae4:	40 00 19 2e 	call  4000df9c <fcntl>                         
40007ae8:	ba 10 20 09 	mov  9, %i5                                    
  if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
40007aec:	80 8a 20 01 	btst  1, %o0                                   
40007af0:	12 80 00 0b 	bne  40007b1c <aio_read+0x44>                  
40007af4:	82 10 3f ff 	mov  -1, %g1                                   
    rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);             
                                                                      
  if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
40007af8:	c2 06 20 18 	ld  [ %i0 + 0x18 ], %g1                        
40007afc:	80 a0 60 00 	cmp  %g1, 0                                    
40007b00:	12 80 00 06 	bne  40007b18 <aio_read+0x40>                  
40007b04:	ba 10 20 16 	mov  0x16, %i5                                 
    rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);            
                                                                      
  if (aiocbp->aio_offset < 0)                                         
40007b08:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
40007b0c:	80 a0 60 00 	cmp  %g1, 0                                    
40007b10:	16 80 00 0a 	bge  40007b38 <aio_read+0x60>                  
40007b14:	01 00 00 00 	nop                                            
    rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);            
                                                                      
  req = malloc (sizeof (rtems_aio_request));                          
  if (req == NULL)                                                    
    rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);            
40007b18:	82 10 3f ff 	mov  -1, %g1	! ffffffff <LEON_REG+0x7fffffff>  
40007b1c:	fa 26 20 34 	st  %i5, [ %i0 + 0x34 ]                        
40007b20:	c2 26 20 38 	st  %g1, [ %i0 + 0x38 ]                        
40007b24:	40 00 27 47 	call  40011840 <__errno>                       
40007b28:	b0 10 3f ff 	mov  -1, %i0                                   
40007b2c:	fa 22 00 00 	st  %i5, [ %o0 ]                               
                                                                      
  req->aiocbp = aiocbp;                                               
  req->aiocbp->aio_lio_opcode = LIO_READ;                             
                                                                      
  return rtems_aio_enqueue (req);                                     
}                                                                     
40007b30:	81 c7 e0 08 	ret                                            
40007b34:	81 e8 00 00 	restore                                        
    rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);            
                                                                      
  if (aiocbp->aio_offset < 0)                                         
    rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);            
                                                                      
  req = malloc (sizeof (rtems_aio_request));                          
40007b38:	7f ff ef 18 	call  40003798 <malloc>                        
40007b3c:	90 10 20 18 	mov  0x18, %o0                                 
  if (req == NULL)                                                    
40007b40:	80 a2 20 00 	cmp  %o0, 0                                    
40007b44:	02 80 00 06 	be  40007b5c <aio_read+0x84>                   <== NEVER TAKEN
40007b48:	82 10 20 01 	mov  1, %g1                                    
    rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);            
                                                                      
  req->aiocbp = aiocbp;                                               
40007b4c:	f0 22 20 14 	st  %i0, [ %o0 + 0x14 ]                        
  req->aiocbp->aio_lio_opcode = LIO_READ;                             
40007b50:	c2 26 20 30 	st  %g1, [ %i0 + 0x30 ]                        
                                                                      
  return rtems_aio_enqueue (req);                                     
40007b54:	7f ff ff 68 	call  400078f4 <rtems_aio_enqueue>             
40007b58:	91 e8 00 08 	restore  %g0, %o0, %o0                         
  if (aiocbp->aio_offset < 0)                                         
    rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);            
                                                                      
  req = malloc (sizeof (rtems_aio_request));                          
  if (req == NULL)                                                    
    rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);            
40007b5c:	10 bf ff ef 	b  40007b18 <aio_read+0x40>                    <== NOT EXECUTED
40007b60:	ba 10 20 0b 	mov  0xb, %i5                                  <== NOT EXECUTED
                                                                      

40007b6c <aio_write>: * 0 - otherwise */ int aio_write (struct aiocb *aiocbp) {
40007b6c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_aio_request *req;                                             
  int mode;                                                           
                                                                      
  mode = fcntl (aiocbp->aio_fildes, F_GETFL);                         
40007b70:	d0 06 00 00 	ld  [ %i0 ], %o0                               
40007b74:	40 00 19 0a 	call  4000df9c <fcntl>                         
40007b78:	92 10 20 03 	mov  3, %o1                                    
  if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
40007b7c:	90 0a 20 03 	and  %o0, 3, %o0                               
40007b80:	90 02 3f ff 	add  %o0, -1, %o0                              
40007b84:	80 a2 20 01 	cmp  %o0, 1                                    
40007b88:	18 80 00 0a 	bgu  40007bb0 <aio_write+0x44>                 
40007b8c:	ba 10 20 09 	mov  9, %i5                                    
    rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);             
                                                                      
  if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
40007b90:	c2 06 20 18 	ld  [ %i0 + 0x18 ], %g1                        
40007b94:	80 a0 60 00 	cmp  %g1, 0                                    
40007b98:	12 80 00 06 	bne  40007bb0 <aio_write+0x44>                 
40007b9c:	ba 10 20 16 	mov  0x16, %i5                                 
    rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);            
                                                                      
  if (aiocbp->aio_offset < 0)                                         
40007ba0:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
40007ba4:	80 a0 60 00 	cmp  %g1, 0                                    
40007ba8:	16 80 00 0a 	bge  40007bd0 <aio_write+0x64>                 
40007bac:	01 00 00 00 	nop                                            
    rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);            
                                                                      
  req = malloc (sizeof (rtems_aio_request));                          
  if (req == NULL)                                                    
    rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);            
40007bb0:	82 10 3f ff 	mov  -1, %g1	! ffffffff <LEON_REG+0x7fffffff>  
40007bb4:	fa 26 20 34 	st  %i5, [ %i0 + 0x34 ]                        
40007bb8:	c2 26 20 38 	st  %g1, [ %i0 + 0x38 ]                        
40007bbc:	40 00 27 21 	call  40011840 <__errno>                       
40007bc0:	b0 10 3f ff 	mov  -1, %i0                                   
40007bc4:	fa 22 00 00 	st  %i5, [ %o0 ]                               
                                                                      
  req->aiocbp = aiocbp;                                               
  req->aiocbp->aio_lio_opcode = LIO_WRITE;                            
                                                                      
  return rtems_aio_enqueue (req);                                     
}                                                                     
40007bc8:	81 c7 e0 08 	ret                                            
40007bcc:	81 e8 00 00 	restore                                        
    rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);            
                                                                      
  if (aiocbp->aio_offset < 0)                                         
    rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);            
                                                                      
  req = malloc (sizeof (rtems_aio_request));                          
40007bd0:	7f ff ee f2 	call  40003798 <malloc>                        
40007bd4:	90 10 20 18 	mov  0x18, %o0                                 
  if (req == NULL)                                                    
40007bd8:	80 a2 20 00 	cmp  %o0, 0                                    
40007bdc:	02 80 00 06 	be  40007bf4 <aio_write+0x88>                  <== NEVER TAKEN
40007be0:	82 10 20 02 	mov  2, %g1                                    
    rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);            
                                                                      
  req->aiocbp = aiocbp;                                               
40007be4:	f0 22 20 14 	st  %i0, [ %o0 + 0x14 ]                        
  req->aiocbp->aio_lio_opcode = LIO_WRITE;                            
40007be8:	c2 26 20 30 	st  %g1, [ %i0 + 0x30 ]                        
                                                                      
  return rtems_aio_enqueue (req);                                     
40007bec:	7f ff ff 42 	call  400078f4 <rtems_aio_enqueue>             
40007bf0:	91 e8 00 08 	restore  %g0, %o0, %o0                         
  if (aiocbp->aio_offset < 0)                                         
    rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);            
                                                                      
  req = malloc (sizeof (rtems_aio_request));                          
  if (req == NULL)                                                    
    rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);            
40007bf4:	10 bf ff ef 	b  40007bb0 <aio_write+0x44>                   <== NOT EXECUTED
40007bf8:	ba 10 20 0b 	mov  0xb, %i5                                  <== NOT EXECUTED
                                                                      

4000812c <check_and_merge>: rtems_rbtree_control *chunk_tree, rtems_rbheap_chunk *a, rtems_rbheap_chunk *b ) { if (b != NULL_PAGE && rtems_rbheap_is_chunk_free(b)) {
4000812c:	80 a2 ff f8 	cmp  %o3, -8                                   
40008130:	02 80 00 23 	be  400081bc <check_and_merge+0x90>            
40008134:	01 00 00 00 	nop                                            
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(                   
  const Chain_Node *node                                              
)                                                                     
{                                                                     
  return (node->next == NULL) && (node->previous == NULL);            
40008138:	c2 02 c0 00 	ld  [ %o3 ], %g1                               
4000813c:	80 a0 60 00 	cmp  %g1, 0                                    
40008140:	22 80 00 1c 	be,a   400081b0 <check_and_merge+0x84>         
40008144:	c4 02 e0 04 	ld  [ %o3 + 4 ], %g2                           
    if (b->begin < a->begin) {                                        
40008148:	c6 02 e0 18 	ld  [ %o3 + 0x18 ], %g3                        
4000814c:	c4 02 a0 18 	ld  [ %o2 + 0x18 ], %g2                        
40008150:	80 a0 c0 02 	cmp  %g3, %g2                                  
40008154:	3a 80 00 07 	bcc,a   40008170 <check_and_merge+0x44>        
40008158:	c8 02 a0 1c 	ld  [ %o2 + 0x1c ], %g4                        
4000815c:	84 10 00 0a 	mov  %o2, %g2                                  
40008160:	c2 02 80 00 	ld  [ %o2 ], %g1                               
40008164:	94 10 00 0b 	mov  %o3, %o2                                  
40008168:	96 10 00 02 	mov  %g2, %o3                                  
                                                                      
      a = b;                                                          
      b = t;                                                          
    }                                                                 
                                                                      
    a->size += b->size;                                               
4000816c:	c8 02 a0 1c 	ld  [ %o2 + 0x1c ], %g4                        
40008170:	c6 02 e0 1c 	ld  [ %o3 + 0x1c ], %g3                        
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
40008174:	c4 02 e0 04 	ld  [ %o3 + 4 ], %g2                           
40008178:	86 01 00 03 	add  %g4, %g3, %g3                             
4000817c:	c6 22 a0 1c 	st  %g3, [ %o2 + 0x1c ]                        
  next->previous = previous;                                          
  previous->next = next;                                              
40008180:	c2 20 80 00 	st  %g1, [ %g2 ]                               
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
  next->previous = previous;                                          
40008184:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
40008188:	c2 02 00 00 	ld  [ %o0 ], %g1                               
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
4000818c:	d0 22 e0 04 	st  %o0, [ %o3 + 4 ]                           
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
40008190:	d6 22 00 00 	st  %o3, [ %o0 ]                               
  the_node->next        = before_node;                                
40008194:	c2 22 c0 00 	st  %g1, [ %o3 ]                               
    rtems_chain_extract_unprotected(&b->chain_node);                  
    add_to_chain(free_chain, b);                                      
    _RBTree_Extract_unprotected(chunk_tree, &b->tree_node);           
40008198:	90 10 00 09 	mov  %o1, %o0                                  
  before_node->previous = the_node;                                   
4000819c:	d6 20 60 04 	st  %o3, [ %g1 + 4 ]                           
400081a0:	92 02 e0 08 	add  %o3, 8, %o1                               
400081a4:	82 13 c0 00 	mov  %o7, %g1                                  
400081a8:	40 00 07 13 	call  40009df4 <_RBTree_Extract_unprotected>   
400081ac:	9e 10 40 00 	mov  %g1, %o7                                  
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(                   
  const Chain_Node *node                                              
)                                                                     
{                                                                     
  return (node->next == NULL) && (node->previous == NULL);            
400081b0:	80 a0 a0 00 	cmp  %g2, 0                                    
400081b4:	32 bf ff e6 	bne,a   4000814c <check_and_merge+0x20>        <== NEVER TAKEN
400081b8:	c6 02 e0 18 	ld  [ %o3 + 0x18 ], %g3                        <== NOT EXECUTED
400081bc:	81 c3 e0 08 	retl                                           
                                                                      

4000392c <chroot>: #include <unistd.h> #include <rtems/libio_.h> int chroot( const char *path ) {
4000392c:	9d e3 bf 48 	save  %sp, -184, %sp                           
                                                                      
  /*                                                                  
   * We use the global environment for path evaluation.  This makes it possible
   * to escape from a chroot environment referencing an unmounted file system.
   */                                                                 
  rtems_filesystem_eval_path_start_with_root_and_current(             
40003930:	94 10 20 19 	mov  0x19, %o2                                 
40003934:	92 10 00 18 	mov  %i0, %o1                                  
40003938:	90 07 bf c8 	add  %fp, -56, %o0                             
4000393c:	17 10 00 54 	sethi  %hi(0x40015000), %o3                    
40003940:	96 12 e2 64 	or  %o3, 0x264, %o3	! 40015264 <rtems_global_user_env+0x4>
40003944:	40 00 04 f3 	call  40004d10 <rtems_filesystem_eval_path_start_with_root_and_current>
40003948:	98 02 ff fc 	add  %o3, -4, %o4                              
4000394c:	92 07 bf e0 	add  %fp, -32, %o1                             
40003950:	40 00 06 0b 	call  4000517c <rtems_filesystem_location_copy_and_detach>
40003954:	90 07 bf b0 	add  %fp, -80, %o0                             
    &rtems_global_user_env.root_directory,                            
    &rtems_global_user_env.current_directory                          
  );                                                                  
                                                                      
  rtems_filesystem_eval_path_extract_currentloc( &ctx, &loc );        
  new_current_loc = rtems_filesystem_location_transform_to_global( &loc );
40003958:	40 00 06 98 	call  400053b8 <rtems_filesystem_location_transform_to_global>
4000395c:	90 07 bf b0 	add  %fp, -80, %o0                             
  if ( !rtems_filesystem_global_location_is_null( new_current_loc ) ) {
40003960:	c2 02 20 10 	ld  [ %o0 + 0x10 ], %g1                        
40003964:	39 10 00 51 	sethi  %hi(0x40014400), %i4                    
40003968:	b8 17 23 14 	or  %i4, 0x314, %i4	! 40014714 <rtems_filesystem_null_handlers>
4000396c:	80 a0 40 1c 	cmp  %g1, %i4                                  
40003970:	02 80 00 16 	be  400039c8 <chroot+0x9c>                     
40003974:	d0 27 bf ac 	st  %o0, [ %fp + -84 ]                         
    rtems_filesystem_global_location_t *new_root_loc =                
40003978:	40 00 06 56 	call  400052d0 <rtems_filesystem_global_location_obtain>
4000397c:	90 07 bf ac 	add  %fp, -84, %o0                             
      rtems_filesystem_global_location_obtain( &new_current_loc );    
    rtems_filesystem_node_types_t type =                              
      (*new_root_loc->location.mt_entry->ops->node_type_h)(           
40003980:	c2 02 20 14 	ld  [ %o0 + 0x14 ], %g1                        
40003984:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
  rtems_filesystem_eval_path_extract_currentloc( &ctx, &loc );        
  new_current_loc = rtems_filesystem_location_transform_to_global( &loc );
  if ( !rtems_filesystem_global_location_is_null( new_current_loc ) ) {
    rtems_filesystem_global_location_t *new_root_loc =                
      rtems_filesystem_global_location_obtain( &new_current_loc );    
    rtems_filesystem_node_types_t type =                              
40003988:	c2 00 60 14 	ld  [ %g1 + 0x14 ], %g1                        
4000398c:	9f c0 40 00 	call  %g1                                      
40003990:	ba 10 00 08 	mov  %o0, %i5                                  
      (*new_root_loc->location.mt_entry->ops->node_type_h)(           
        &new_root_loc->location                                       
      );                                                              
                                                                      
    if ( type == RTEMS_FILESYSTEM_DIRECTORY ) {                       
40003994:	80 a2 20 00 	cmp  %o0, 0                                    
40003998:	02 80 00 13 	be  400039e4 <chroot+0xb8>                     
4000399c:	01 00 00 00 	nop                                            
static inline void rtems_filesystem_location_error(                   
  const rtems_filesystem_location_info_t *loc,                        
  int eno                                                             
)                                                                     
{                                                                     
  if ( !rtems_filesystem_location_is_null( loc ) ) {                  
400039a0:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
400039a4:	80 a0 40 1c 	cmp  %g1, %i4                                  
400039a8:	02 80 00 06 	be  400039c0 <chroot+0x94>                     <== NEVER TAKEN
400039ac:	01 00 00 00 	nop                                            
    errno = eno;                                                      
400039b0:	40 00 21 ac 	call  4000c060 <__errno>                       
400039b4:	01 00 00 00 	nop                                            
400039b8:	82 10 20 14 	mov  0x14, %g1	! 14 <PROM_START+0x14>          
400039bc:	c2 22 00 00 	st  %g1, [ %o0 ]                               
      rtems_filesystem_location_error( &new_root_loc->location, ENOTDIR );
      rv = -1;                                                        
    }                                                                 
                                                                      
    if ( rv != 0 ) {                                                  
      rtems_filesystem_global_location_release( new_root_loc );       
400039c0:	40 00 06 24 	call  40005250 <rtems_filesystem_global_location_release>
400039c4:	90 10 00 1d 	mov  %i5, %o0                                  
    }                                                                 
  } else {                                                            
    rv = -1;                                                          
  }                                                                   
                                                                      
  rtems_filesystem_eval_path_cleanup( &ctx );                         
400039c8:	40 00 05 1c 	call  40004e38 <rtems_filesystem_eval_path_cleanup>
400039cc:	90 07 bf c8 	add  %fp, -56, %o0                             
                                                                      
  if ( rv != 0 ) {                                                    
    rtems_filesystem_global_location_release( new_current_loc );      
400039d0:	d0 07 bf ac 	ld  [ %fp + -84 ], %o0                         
400039d4:	40 00 06 1f 	call  40005250 <rtems_filesystem_global_location_release>
400039d8:	b0 10 3f ff 	mov  -1, %i0                                   
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
400039dc:	81 c7 e0 08 	ret                                            
400039e0:	81 e8 00 00 	restore                                        
      (*new_root_loc->location.mt_entry->ops->node_type_h)(           
        &new_root_loc->location                                       
      );                                                              
                                                                      
    if ( type == RTEMS_FILESYSTEM_DIRECTORY ) {                       
      sc = rtems_libio_set_private_env();                             
400039e4:	40 00 03 11 	call  40004628 <rtems_libio_set_private_env>   
400039e8:	01 00 00 00 	nop                                            
      if (sc == RTEMS_SUCCESSFUL) {                                   
400039ec:	80 a2 20 00 	cmp  %o0, 0                                    
400039f0:	02 80 00 09 	be  40003a14 <chroot+0xe8>                     
400039f4:	80 a2 20 0d 	cmp  %o0, 0xd                                  
        rtems_filesystem_global_location_assign(                      
          &rtems_filesystem_current,                                  
          new_current_loc                                             
        );                                                            
      } else {                                                        
        if (sc != RTEMS_UNSATISFIED) {                                
400039f8:	02 bf ff f2 	be  400039c0 <chroot+0x94>                     <== NEVER TAKEN
400039fc:	01 00 00 00 	nop                                            
          errno = ENOMEM;                                             
40003a00:	40 00 21 98 	call  4000c060 <__errno>                       
40003a04:	01 00 00 00 	nop                                            
40003a08:	82 10 20 0c 	mov  0xc, %g1	! c <PROM_START+0xc>             
40003a0c:	10 bf ff ed 	b  400039c0 <chroot+0x94>                      
40003a10:	c2 22 00 00 	st  %g1, [ %o0 ]                               
      );                                                              
                                                                      
    if ( type == RTEMS_FILESYSTEM_DIRECTORY ) {                       
      sc = rtems_libio_set_private_env();                             
      if (sc == RTEMS_SUCCESSFUL) {                                   
        rtems_filesystem_global_location_assign(                      
40003a14:	39 10 00 54 	sethi  %hi(0x40015000), %i4                    
40003a18:	d0 07 22 5c 	ld  [ %i4 + 0x25c ], %o0	! 4001525c <rtems_current_user_env>
40003a1c:	92 10 00 1d 	mov  %i5, %o1                                  
40003a20:	40 00 06 22 	call  400052a8 <rtems_filesystem_global_location_assign>
40003a24:	90 02 20 04 	add  %o0, 4, %o0                               
          &rtems_filesystem_root,                                     
          new_root_loc                                                
        );                                                            
        rtems_filesystem_global_location_assign(                      
40003a28:	d2 07 bf ac 	ld  [ %fp + -84 ], %o1                         
40003a2c:	d0 07 22 5c 	ld  [ %i4 + 0x25c ], %o0                       
40003a30:	40 00 06 1e 	call  400052a8 <rtems_filesystem_global_location_assign>
40003a34:	b0 10 20 00 	clr  %i0                                       
    }                                                                 
  } else {                                                            
    rv = -1;                                                          
  }                                                                   
                                                                      
  rtems_filesystem_eval_path_cleanup( &ctx );                         
40003a38:	40 00 05 00 	call  40004e38 <rtems_filesystem_eval_path_cleanup>
40003a3c:	90 07 bf c8 	add  %fp, -56, %o0                             
40003a40:	81 c7 e0 08 	ret                                            
40003a44:	81 e8 00 00 	restore                                        
                                                                      

40006d2c <clock_gettime>: int clock_gettime( clockid_t clock_id, struct timespec *tp ) {
40006d2c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  if ( !tp )                                                          
40006d30:	80 a6 60 00 	cmp  %i1, 0                                    
40006d34:	02 80 00 0a 	be  40006d5c <clock_gettime+0x30>              
40006d38:	80 a6 20 01 	cmp  %i0, 1                                    
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( clock_id == CLOCK_REALTIME ) {                                 
40006d3c:	02 80 00 19 	be  40006da0 <clock_gettime+0x74>              
40006d40:	80 a6 20 04 	cmp  %i0, 4                                    
    _TOD_Get(tp);                                                     
    return 0;                                                         
  }                                                                   
#ifdef CLOCK_MONOTONIC                                                
  if ( clock_id == CLOCK_MONOTONIC ) {                                
40006d44:	02 80 00 12 	be  40006d8c <clock_gettime+0x60>              <== NEVER TAKEN
40006d48:	80 a6 20 02 	cmp  %i0, 2                                    
    return 0;                                                         
  }                                                                   
#endif                                                                
                                                                      
#ifdef _POSIX_CPUTIME                                                 
  if ( clock_id == CLOCK_PROCESS_CPUTIME_ID ) {                       
40006d4c:	02 80 00 10 	be  40006d8c <clock_gettime+0x60>              
40006d50:	80 a6 20 03 	cmp  %i0, 3                                    
    return 0;                                                         
  }                                                                   
#endif                                                                
                                                                      
#ifdef _POSIX_THREAD_CPUTIME                                          
  if ( clock_id == CLOCK_THREAD_CPUTIME_ID )                          
40006d54:	02 80 00 08 	be  40006d74 <clock_gettime+0x48>              
40006d58:	01 00 00 00 	nop                                            
    rtems_set_errno_and_return_minus_one( ENOSYS );                   
#endif                                                                
                                                                      
  rtems_set_errno_and_return_minus_one( EINVAL );                     
40006d5c:	40 00 25 fa 	call  40010544 <__errno>                       
40006d60:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <LEON_REG+0x7fffffff>  
40006d64:	82 10 20 16 	mov  0x16, %g1                                 
40006d68:	c2 22 00 00 	st  %g1, [ %o0 ]                               
                                                                      
  return 0;                                                           
}                                                                     
40006d6c:	81 c7 e0 08 	ret                                            
40006d70:	81 e8 00 00 	restore                                        
  }                                                                   
#endif                                                                
                                                                      
#ifdef _POSIX_THREAD_CPUTIME                                          
  if ( clock_id == CLOCK_THREAD_CPUTIME_ID )                          
    rtems_set_errno_and_return_minus_one( ENOSYS );                   
40006d74:	40 00 25 f4 	call  40010544 <__errno>                       
40006d78:	b0 10 3f ff 	mov  -1, %i0                                   
40006d7c:	82 10 20 58 	mov  0x58, %g1                                 
40006d80:	c2 22 00 00 	st  %g1, [ %o0 ]                               
40006d84:	81 c7 e0 08 	ret                                            
40006d88:	81 e8 00 00 	restore                                        
    _TOD_Get(tp);                                                     
    return 0;                                                         
  }                                                                   
#ifdef CLOCK_MONOTONIC                                                
  if ( clock_id == CLOCK_MONOTONIC ) {                                
    _TOD_Get_uptime_as_timespec( tp );                                
40006d8c:	90 10 00 19 	mov  %i1, %o0                                  
40006d90:	40 00 08 a4 	call  40009020 <_TOD_Get_uptime_as_timespec>   
40006d94:	b0 10 20 00 	clr  %i0                                       
    return 0;                                                         
40006d98:	81 c7 e0 08 	ret                                            
40006d9c:	81 e8 00 00 	restore                                        
)                                                                     
{                                                                     
  Timestamp_Control  tod_as_timestamp;                                
  Timestamp_Control *tod_as_timestamp_ptr;                            
                                                                      
  tod_as_timestamp_ptr =                                              
40006da0:	90 07 bf f8 	add  %fp, -8, %o0                              
40006da4:	13 10 00 68 	sethi  %hi(0x4001a000), %o1                    
40006da8:	40 00 08 8d 	call  40008fdc <_TOD_Get_with_nanoseconds>     
40006dac:	92 12 63 48 	or  %o1, 0x348, %o1	! 4001a348 <_TOD>          
#endif                                                                
                                                                      
  rtems_set_errno_and_return_minus_one( EINVAL );                     
                                                                      
  return 0;                                                           
}                                                                     
40006db0:	f8 1a 00 00 	ldd  [ %o0 ], %i4                              
static inline void _Timestamp64_implementation_To_timespec(           
  const Timestamp64_Control *_timestamp,                              
  struct timespec           *_timespec                                
)                                                                     
{                                                                     
  _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);           
40006db4:	94 10 20 00 	clr  %o2                                       
40006db8:	90 10 00 1c 	mov  %i4, %o0                                  
40006dbc:	92 10 00 1d 	mov  %i5, %o1                                  
40006dc0:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
40006dc4:	40 00 3e 50 	call  40016704 <__divdi3>                      
40006dc8:	96 12 e2 00 	or  %o3, 0x200, %o3	! 3b9aca00 <RAM_SIZE+0x3b5aca00>
  _timespec->tv_nsec = (long) (*_timestamp % 1000000000L);            
40006dcc:	94 10 20 00 	clr  %o2                                       
static inline void _Timestamp64_implementation_To_timespec(           
  const Timestamp64_Control *_timestamp,                              
  struct timespec           *_timespec                                
)                                                                     
{                                                                     
  _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);           
40006dd0:	d2 26 40 00 	st  %o1, [ %i1 ]                               
  _timespec->tv_nsec = (long) (*_timestamp % 1000000000L);            
40006dd4:	90 10 00 1c 	mov  %i4, %o0                                  
40006dd8:	92 10 00 1d 	mov  %i5, %o1                                  
40006ddc:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
  if ( !tp )                                                          
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( clock_id == CLOCK_REALTIME ) {                                 
    _TOD_Get(tp);                                                     
    return 0;                                                         
40006de0:	b0 10 20 00 	clr  %i0                                       
40006de4:	40 00 3f 33 	call  40016ab0 <__moddi3>                      
40006de8:	96 12 e2 00 	or  %o3, 0x200, %o3                            
40006dec:	d2 26 60 04 	st  %o1, [ %i1 + 4 ]                           
40006df0:	81 c7 e0 08 	ret                                            
40006df4:	81 e8 00 00 	restore                                        
                                                                      

40028884 <clock_settime>: int clock_settime( clockid_t clock_id, const struct timespec *tp ) {
40028884:	9d e3 bf 98 	save  %sp, -104, %sp                           
  if ( !tp )                                                          
40028888:	80 a6 60 00 	cmp  %i1, 0                                    
4002888c:	02 80 00 08 	be  400288ac <clock_settime+0x28>              <== NEVER TAKEN
40028890:	80 a6 20 01 	cmp  %i0, 1                                    
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( clock_id == CLOCK_REALTIME ) {                                 
40028894:	02 80 00 0c 	be  400288c4 <clock_settime+0x40>              
40028898:	80 a6 20 02 	cmp  %i0, 2                                    
    _Thread_Disable_dispatch();                                       
      _TOD_Set( tp );                                                 
    _Thread_Enable_dispatch();                                        
  }                                                                   
#ifdef _POSIX_CPUTIME                                                 
  else if ( clock_id == CLOCK_PROCESS_CPUTIME_ID )                    
4002889c:	02 80 00 49 	be  400289c0 <clock_settime+0x13c>             
400288a0:	80 a6 20 03 	cmp  %i0, 3                                    
    rtems_set_errno_and_return_minus_one( ENOSYS );                   
#endif                                                                
#ifdef _POSIX_THREAD_CPUTIME                                          
  else if ( clock_id == CLOCK_THREAD_CPUTIME_ID )                     
400288a4:	02 80 00 47 	be  400289c0 <clock_settime+0x13c>             
400288a8:	01 00 00 00 	nop                                            
    rtems_set_errno_and_return_minus_one( ENOSYS );                   
#endif                                                                
  else                                                                
    rtems_set_errno_and_return_minus_one( EINVAL );                   
400288ac:	40 00 4b 2f 	call  4003b568 <__errno>                       
400288b0:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <LEON_REG+0x7fffffff>  
400288b4:	82 10 20 16 	mov  0x16, %g1                                 
400288b8:	c2 22 00 00 	st  %g1, [ %o0 ]                               
                                                                      
  return 0;                                                           
}                                                                     
400288bc:	81 c7 e0 08 	ret                                            
400288c0:	81 e8 00 00 	restore                                        
{                                                                     
  if ( !tp )                                                          
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( clock_id == CLOCK_REALTIME ) {                                 
    if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )                 
400288c4:	c4 06 40 00 	ld  [ %i1 ], %g2                               
400288c8:	03 08 76 b9 	sethi  %hi(0x21dae400), %g1                    
400288cc:	82 10 60 ff 	or  %g1, 0xff, %g1	! 21dae4ff <RAM_SIZE+0x219ae4ff>
400288d0:	80 a0 80 01 	cmp  %g2, %g1                                  
400288d4:	08 bf ff f6 	bleu  400288ac <clock_settime+0x28>            
400288d8:	03 10 01 a1 	sethi  %hi(0x40068400), %g1                    
   *                                                                  
   * This rountine increments the thread dispatch level               
   */                                                                 
  RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
  {                                                                   
    uint32_t level = _Thread_Dispatch_disable_level;                  
400288dc:	c4 00 60 a0 	ld  [ %g1 + 0xa0 ], %g2	! 400684a0 <_Thread_Dispatch_disable_level>
                                                                      
    ++level;                                                          
400288e0:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
400288e4:	c4 20 60 a0 	st  %g2, [ %g1 + 0xa0 ]                        
  const struct timespec *tod_as_timespec                              
)                                                                     
{                                                                     
  Timestamp_Control tod_as_timestamp;                                 
                                                                      
  _Timestamp_Set(                                                     
400288e8:	c6 06 40 00 	ld  [ %i1 ], %g3                               
400288ec:	e2 06 60 04 	ld  [ %i1 + 4 ], %l1                           
400288f0:	85 38 e0 1f 	sra  %g3, 0x1f, %g2                            
  Timestamp64_Control *_time,                                         
  Timestamp64_Control  _seconds,                                      
  Timestamp64_Control  _nanoseconds                                   
)                                                                     
{                                                                     
  *_time = _seconds * 1000000000L + _nanoseconds;                     
400288f4:	83 28 a0 03 	sll  %g2, 3, %g1                               
400288f8:	bb 28 e0 03 	sll  %g3, 3, %i5                               
400288fc:	89 30 e0 1d 	srl  %g3, 0x1d, %g4                            
40028900:	b8 11 00 01 	or  %g4, %g1, %i4                              
40028904:	83 37 60 1b 	srl  %i5, 0x1b, %g1                            
40028908:	a5 2f 20 05 	sll  %i4, 5, %l2                               
4002890c:	a7 2f 60 05 	sll  %i5, 5, %l3                               
40028910:	a4 10 40 12 	or  %g1, %l2, %l2                              
40028914:	ba a4 c0 1d 	subcc  %l3, %i5, %i5                           
40028918:	83 37 60 1a 	srl  %i5, 0x1a, %g1                            
4002891c:	b8 64 80 1c 	subx  %l2, %i4, %i4                            
40028920:	97 2f 60 06 	sll  %i5, 6, %o3                               
40028924:	95 2f 20 06 	sll  %i4, 6, %o2                               
40028928:	ba a2 c0 1d 	subcc  %o3, %i5, %i5                           
4002892c:	94 10 40 0a 	or  %g1, %o2, %o2                              
40028930:	b8 62 80 1c 	subx  %o2, %i4, %i4                            
40028934:	aa 87 40 03 	addcc  %i5, %g3, %l5                           
40028938:	83 35 60 1e 	srl  %l5, 0x1e, %g1                            
4002893c:	a8 47 00 02 	addx  %i4, %g2, %l4                            
40028940:	9b 2d 60 02 	sll  %l5, 2, %o5                               
40028944:	99 2d 20 02 	sll  %l4, 2, %o4                               
40028948:	86 85 40 0d 	addcc  %l5, %o5, %g3                           
4002894c:	98 10 40 0c 	or  %g1, %o4, %o4                              
40028950:	b3 28 e0 02 	sll  %g3, 2, %i1                               
40028954:	84 45 00 0c 	addx  %l4, %o4, %g2                            
40028958:	83 30 e0 1e 	srl  %g3, 0x1e, %g1                            
4002895c:	ba 80 c0 19 	addcc  %g3, %i1, %i5                           
40028960:	b1 28 a0 02 	sll  %g2, 2, %i0                               
40028964:	b7 2f 60 02 	sll  %i5, 2, %i3                               
40028968:	b0 10 40 18 	or  %g1, %i0, %i0                              
4002896c:	83 37 60 1e 	srl  %i5, 0x1e, %g1                            
40028970:	b8 40 80 18 	addx  %g2, %i0, %i4                            
40028974:	86 87 40 1b 	addcc  %i5, %i3, %g3                           
40028978:	b5 2f 20 02 	sll  %i4, 2, %i2                               
4002897c:	bb 30 e0 17 	srl  %g3, 0x17, %i5                            
40028980:	b4 10 40 1a 	or  %g1, %i2, %i2                              
40028984:	84 47 00 1a 	addx  %i4, %i2, %g2                            
40028988:	83 28 e0 09 	sll  %g3, 9, %g1                               
4002898c:	89 28 a0 09 	sll  %g2, 9, %g4                               
    &tod_as_timestamp,                                                
    tod_as_timespec->tv_sec,                                          
    tod_as_timespec->tv_nsec                                          
  );                                                                  
  _TOD_Set_with_timestamp( &tod_as_timestamp );                       
40028990:	90 07 bf f8 	add  %fp, -8, %o0                              
40028994:	84 17 40 04 	or  %i5, %g4, %g2                              
40028998:	ba 84 40 01 	addcc  %l1, %g1, %i5                           
  const struct timespec *tod_as_timespec                              
)                                                                     
{                                                                     
  Timestamp_Control tod_as_timestamp;                                 
                                                                      
  _Timestamp_Set(                                                     
4002899c:	a1 3c 60 1f 	sra  %l1, 0x1f, %l0                            
    rtems_set_errno_and_return_minus_one( ENOSYS );                   
#endif                                                                
  else                                                                
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  return 0;                                                           
400289a0:	b0 10 20 00 	clr  %i0                                       
400289a4:	b8 44 00 02 	addx  %l0, %g2, %i4                            
    &tod_as_timestamp,                                                
    tod_as_timespec->tv_sec,                                          
    tod_as_timespec->tv_nsec                                          
  );                                                                  
  _TOD_Set_with_timestamp( &tod_as_timestamp );                       
400289a8:	40 00 04 92 	call  40029bf0 <_TOD_Set_with_timestamp>       
400289ac:	f8 3f bf f8 	std  %i4, [ %fp + -8 ]                         
    if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )                 
      rtems_set_errno_and_return_minus_one( EINVAL );                 
                                                                      
    _Thread_Disable_dispatch();                                       
      _TOD_Set( tp );                                                 
    _Thread_Enable_dispatch();                                        
400289b0:	7f ff 83 a7 	call  4000984c <_Thread_Enable_dispatch>       
400289b4:	01 00 00 00 	nop                                            
    rtems_set_errno_and_return_minus_one( ENOSYS );                   
#endif                                                                
  else                                                                
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  return 0;                                                           
400289b8:	81 c7 e0 08 	ret                                            
400289bc:	81 e8 00 00 	restore                                        
  else if ( clock_id == CLOCK_PROCESS_CPUTIME_ID )                    
    rtems_set_errno_and_return_minus_one( ENOSYS );                   
#endif                                                                
#ifdef _POSIX_THREAD_CPUTIME                                          
  else if ( clock_id == CLOCK_THREAD_CPUTIME_ID )                     
    rtems_set_errno_and_return_minus_one( ENOSYS );                   
400289c0:	40 00 4a ea 	call  4003b568 <__errno>                       
400289c4:	b0 10 3f ff 	mov  -1, %i0                                   
400289c8:	82 10 20 58 	mov  0x58, %g1                                 
400289cc:	c2 22 00 00 	st  %g1, [ %o0 ]                               
400289d0:	81 c7 e0 08 	ret                                            
400289d4:	81 e8 00 00 	restore                                        
                                                                      

40002f68 <create_disk>: dev_t dev, const char *name, rtems_disk_device **dd_ptr, char **alloc_name_ptr ) {
40002f68:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_device_major_number major = 0;                                
  rtems_device_minor_number minor = 0;                                
                                                                      
  rtems_filesystem_split_dev_t(dev, major, minor);                    
                                                                      
  if (major >= disktab_size) {                                        
40002f6c:	25 10 00 6b 	sethi  %hi(0x4001ac00), %l2                    
40002f70:	fa 04 a2 18 	ld  [ %l2 + 0x218 ], %i5	! 4001ae18 <disktab_size>
40002f74:	80 a6 00 1d 	cmp  %i0, %i5                                  
40002f78:	1a 80 00 30 	bcc  40003038 <create_disk+0xd0>               
40002f7c:	a2 10 00 18 	mov  %i0, %l1                                  
40002f80:	03 10 00 6b 	sethi  %hi(0x4001ac00), %g1                    
40002f84:	e0 00 62 1c 	ld  [ %g1 + 0x21c ], %l0	! 4001ae1c <disktab>  
    memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
    disktab = table;                                                  
    disktab_size = new_size;                                          
  }                                                                   
                                                                      
  if (disktab [major].minor == NULL || minor >= disktab[major].size) {
40002f88:	83 2c 60 03 	sll  %l1, 3, %g1                               
40002f8c:	fa 04 00 01 	ld  [ %l0 + %g1 ], %i5                         
40002f90:	a0 04 00 01 	add  %l0, %g1, %l0                             
40002f94:	80 a7 60 00 	cmp  %i5, 0                                    
40002f98:	02 80 00 0f 	be  40002fd4 <create_disk+0x6c>                
40002f9c:	f0 04 20 04 	ld  [ %l0 + 4 ], %i0                           
40002fa0:	80 a6 40 18 	cmp  %i1, %i0                                  
40002fa4:	1a 80 00 0d 	bcc  40002fd8 <create_disk+0x70>               
40002fa8:	80 a6 20 00 	cmp  %i0, 0                                    
    memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
    disktab [major].minor = table;                                    
    disktab [major].size = new_size;                                  
  }                                                                   
                                                                      
  return disktab [major].minor + minor;                               
40002fac:	83 2e 60 02 	sll  %i1, 2, %g1                               
{                                                                     
  rtems_disk_device **dd_entry = create_disk_table_entry(dev);        
  rtems_disk_device *dd = NULL;                                       
  char *alloc_name = NULL;                                            
                                                                      
  if (dd_entry == NULL) {                                             
40002fb0:	a0 87 40 01 	addcc  %i5, %g1, %l0                           
40002fb4:	02 80 00 1f 	be  40003030 <create_disk+0xc8>                <== NEVER TAKEN
40002fb8:	01 00 00 00 	nop                                            
    return RTEMS_NO_MEMORY;                                           
  }                                                                   
                                                                      
  if (*dd_entry != NULL) {                                            
40002fbc:	c2 07 40 01 	ld  [ %i5 + %g1 ], %g1                         
40002fc0:	80 a0 60 00 	cmp  %g1, 0                                    
40002fc4:	02 80 00 36 	be  4000309c <create_disk+0x134>               
40002fc8:	b0 10 20 0c 	mov  0xc, %i0                                  
  *dd_entry = dd;                                                     
  *dd_ptr = dd;                                                       
  *alloc_name_ptr = alloc_name;                                       
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
40002fcc:	81 c7 e0 08 	ret                                            
40002fd0:	81 e8 00 00 	restore                                        
  if (disktab [major].minor == NULL || minor >= disktab[major].size) {
    rtems_disk_device **table = disktab [major].minor;                
    rtems_device_minor_number old_size = disktab [major].size;        
    rtems_device_minor_number new_size = 0;                           
                                                                      
    if (old_size == 0) {                                              
40002fd4:	80 a6 20 00 	cmp  %i0, 0                                    
40002fd8:	12 80 00 2b 	bne  40003084 <create_disk+0x11c>              
40002fdc:	a4 10 20 08 	mov  8, %l2                                    
      new_size = DISKTAB_INITIAL_SIZE;                                
    } else {                                                          
      new_size = 2 * old_size;                                        
    }                                                                 
    if (minor >= new_size) {                                          
40002fe0:	80 a6 40 12 	cmp  %i1, %l2                                  
40002fe4:	3a 80 00 02 	bcc,a   40002fec <create_disk+0x84>            
40002fe8:	a4 06 60 01 	add  %i1, 1, %l2                               
      new_size = minor + 1;                                           
    }                                                                 
                                                                      
    table = realloc(table, new_size * sizeof(*table));                
40002fec:	90 10 00 1d 	mov  %i5, %o0                                  
40002ff0:	40 00 08 12 	call  40005038 <realloc>                       
40002ff4:	93 2c a0 02 	sll  %l2, 2, %o1                               
    if (table == NULL) {                                              
40002ff8:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40002ffc:	02 80 00 0d 	be  40003030 <create_disk+0xc8>                
40003000:	94 24 80 18 	sub  %l2, %i0, %o2                             
      return NULL;                                                    
    }                                                                 
                                                                      
    memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
40003004:	91 2e 20 02 	sll  %i0, 2, %o0                               
40003008:	92 10 20 00 	clr  %o1                                       
4000300c:	90 07 40 08 	add  %i5, %o0, %o0                             
40003010:	40 00 45 f5 	call  400147e4 <memset>                        
40003014:	95 2a a0 02 	sll  %o2, 2, %o2                               
    disktab [major].minor = table;                                    
40003018:	fa 24 00 00 	st  %i5, [ %l0 ]                               
    disktab [major].size = new_size;                                  
4000301c:	e4 24 20 04 	st  %l2, [ %l0 + 4 ]                           
  }                                                                   
                                                                      
  return disktab [major].minor + minor;                               
40003020:	83 2e 60 02 	sll  %i1, 2, %g1                               
{                                                                     
  rtems_disk_device **dd_entry = create_disk_table_entry(dev);        
  rtems_disk_device *dd = NULL;                                       
  char *alloc_name = NULL;                                            
                                                                      
  if (dd_entry == NULL) {                                             
40003024:	a0 87 40 01 	addcc  %i5, %g1, %l0                           
40003028:	32 bf ff e6 	bne,a   40002fc0 <create_disk+0x58>            <== ALWAYS TAKEN
4000302c:	c2 07 40 01 	ld  [ %i5 + %g1 ], %g1                         
    alloc_name = strdup(name);                                        
                                                                      
    if (alloc_name == NULL) {                                         
      free(dd);                                                       
                                                                      
      return RTEMS_NO_MEMORY;                                         
40003030:	81 c7 e0 08 	ret                                            
40003034:	91 e8 20 1a 	restore  %g0, 0x1a, %o0                        
  rtems_device_minor_number minor = 0;                                
                                                                      
  rtems_filesystem_split_dev_t(dev, major, minor);                    
                                                                      
  if (major >= disktab_size) {                                        
    rtems_disk_device_table *table = disktab;                         
40003038:	27 10 00 6b 	sethi  %hi(0x4001ac00), %l3                    
    rtems_device_major_number old_size = disktab_size;                
    rtems_device_major_number new_size = 2 * old_size;                
4000303c:	b1 2f 60 01 	sll  %i5, 1, %i0                               
                                                                      
    if (major >= new_size) {                                          
40003040:	80 a4 40 18 	cmp  %l1, %i0                                  
40003044:	0a 80 00 03 	bcs  40003050 <create_disk+0xe8>               <== NEVER TAKEN
40003048:	d0 04 e2 1c 	ld  [ %l3 + 0x21c ], %o0                       
      new_size = major + 1;                                           
4000304c:	b0 04 60 01 	add  %l1, 1, %i0                               
    }                                                                 
                                                                      
    table = realloc(table, new_size * sizeof(*table));                
40003050:	40 00 07 fa 	call  40005038 <realloc>                       
40003054:	93 2e 20 03 	sll  %i0, 3, %o1                               
    if (table == NULL) {                                              
40003058:	a0 92 20 00 	orcc  %o0, 0, %l0                              
4000305c:	02 bf ff f5 	be  40003030 <create_disk+0xc8>                <== ALWAYS TAKEN
40003060:	94 26 00 1d 	sub  %i0, %i5, %o2                             
      return NULL;                                                    
    }                                                                 
                                                                      
    memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
40003064:	91 2f 60 03 	sll  %i5, 3, %o0                               <== NOT EXECUTED
40003068:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4000306c:	90 04 00 08 	add  %l0, %o0, %o0                             <== NOT EXECUTED
40003070:	40 00 45 dd 	call  400147e4 <memset>                        <== NOT EXECUTED
40003074:	95 2a a0 03 	sll  %o2, 3, %o2                               <== NOT EXECUTED
    disktab = table;                                                  
40003078:	e0 24 e2 1c 	st  %l0, [ %l3 + 0x21c ]                       <== NOT EXECUTED
    disktab_size = new_size;                                          
4000307c:	10 bf ff c3 	b  40002f88 <create_disk+0x20>                 <== NOT EXECUTED
40003080:	f0 24 a2 18 	st  %i0, [ %l2 + 0x218 ]                       <== NOT EXECUTED
    rtems_device_minor_number new_size = 0;                           
                                                                      
    if (old_size == 0) {                                              
      new_size = DISKTAB_INITIAL_SIZE;                                
    } else {                                                          
      new_size = 2 * old_size;                                        
40003084:	a5 2e 20 01 	sll  %i0, 1, %l2                               
    }                                                                 
    if (minor >= new_size) {                                          
40003088:	80 a6 40 12 	cmp  %i1, %l2                                  
4000308c:	0a bf ff d9 	bcs  40002ff0 <create_disk+0x88>               <== ALWAYS TAKEN
40003090:	90 10 00 1d 	mov  %i5, %o0                                  
40003094:	10 bf ff d7 	b  40002ff0 <create_disk+0x88>                 <== NOT EXECUTED
40003098:	a4 06 60 01 	add  %i1, 1, %l2                               <== NOT EXECUTED
                                                                      
  if (*dd_entry != NULL) {                                            
    return RTEMS_RESOURCE_IN_USE;                                     
  }                                                                   
                                                                      
  dd = malloc(sizeof(*dd));                                           
4000309c:	40 00 05 35 	call  40004570 <malloc>                        
400030a0:	90 10 20 78 	mov  0x78, %o0                                 
  if (dd == NULL) {                                                   
400030a4:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400030a8:	02 bf ff e2 	be  40003030 <create_disk+0xc8>                <== NEVER TAKEN
400030ac:	80 a6 a0 00 	cmp  %i2, 0                                    
    return RTEMS_NO_MEMORY;                                           
  }                                                                   
                                                                      
  if (name != NULL) {                                                 
400030b0:	02 80 00 0f 	be  400030ec <create_disk+0x184>               
400030b4:	b0 10 20 00 	clr  %i0                                       
    alloc_name = strdup(name);                                        
400030b8:	40 00 46 83 	call  40014ac4 <strdup>                        
400030bc:	90 10 00 1a 	mov  %i2, %o0                                  
                                                                      
    if (alloc_name == NULL) {                                         
400030c0:	b0 92 20 00 	orcc  %o0, 0, %i0                              
400030c4:	02 80 00 16 	be  4000311c <create_disk+0x1b4>               <== NEVER TAKEN
400030c8:	b4 10 00 08 	mov  %o0, %i2                                  
      return RTEMS_NO_MEMORY;                                         
    }                                                                 
  }                                                                   
                                                                      
  if (name != NULL) {                                                 
    if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {                 
400030cc:	94 10 00 11 	mov  %l1, %o2                                  
400030d0:	13 00 00 18 	sethi  %hi(0x6000), %o1                        
400030d4:	96 10 00 19 	mov  %i1, %o3                                  
400030d8:	40 00 05 95 	call  4000472c <mknod>                         
400030dc:	92 12 61 ff 	or  %o1, 0x1ff, %o1                            
400030e0:	80 a2 20 00 	cmp  %o0, 0                                    
400030e4:	06 80 00 07 	bl  40003100 <create_disk+0x198>               <== NEVER TAKEN
400030e8:	01 00 00 00 	nop                                            
      free(dd);                                                       
      return RTEMS_UNSATISFIED;                                       
    }                                                                 
  }                                                                   
                                                                      
  *dd_entry = dd;                                                     
400030ec:	fa 24 00 00 	st  %i5, [ %l0 ]                               
  *dd_ptr = dd;                                                       
400030f0:	fa 26 c0 00 	st  %i5, [ %i3 ]                               
  *alloc_name_ptr = alloc_name;                                       
400030f4:	f0 27 00 00 	st  %i0, [ %i4 ]                               
                                                                      
  return RTEMS_SUCCESSFUL;                                            
400030f8:	81 c7 e0 08 	ret                                            
400030fc:	91 e8 20 00 	restore  %g0, 0, %o0                           
    }                                                                 
  }                                                                   
                                                                      
  if (name != NULL) {                                                 
    if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {                 
      free(alloc_name);                                               
40003100:	40 00 03 d4 	call  40004050 <free>                          <== NOT EXECUTED
40003104:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
      free(dd);                                                       
40003108:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4000310c:	40 00 03 d1 	call  40004050 <free>                          <== NOT EXECUTED
40003110:	b0 10 20 0d 	mov  0xd, %i0                                  <== NOT EXECUTED
      return RTEMS_UNSATISFIED;                                       
40003114:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40003118:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
  if (name != NULL) {                                                 
    alloc_name = strdup(name);                                        
                                                                      
    if (alloc_name == NULL) {                                         
      free(dd);                                                       
4000311c:	40 00 03 cd 	call  40004050 <free>                          <== NOT EXECUTED
40003120:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40003124:	30 bf ff c3 	b,a   40003030 <create_disk+0xc8>              <== NOT EXECUTED
                                                                      

40004540 <data_to_part_desc.part.1>: * RTEMS_SUCCESSFUL, if success; * RTEMS_NO_MEMOTY, if cannot allocate memory for part_desc_t strucure; * RTEMS_INTERNAL_ERROR, if other error occurs. */ static rtems_status_code data_to_part_desc(uint8_t *data, rtems_part_desc_t **new_part_desc)
40004540:	9d e3 bf 98 	save  %sp, -104, %sp                           
        return RTEMS_INTERNAL_ERROR;                                  
    }                                                                 
                                                                      
    *new_part_desc = NULL;                                            
                                                                      
    if ((part_desc = calloc(1, sizeof(rtems_part_desc_t))) == NULL)   
40004544:	90 10 20 01 	mov  1, %o0                                    
    if (new_part_desc == NULL)                                        
    {                                                                 
        return RTEMS_INTERNAL_ERROR;                                  
    }                                                                 
                                                                      
    *new_part_desc = NULL;                                            
40004548:	c0 26 40 00 	clr  [ %i1 ]                                   
                                                                      
    if ((part_desc = calloc(1, sizeof(rtems_part_desc_t))) == NULL)   
4000454c:	40 00 03 54 	call  4000529c <calloc>                        
40004550:	92 10 20 28 	mov  0x28, %o1                                 
 *      RTEMS_SUCCESSFUL, if success;                                 
 *      RTEMS_NO_MEMOTY, if cannot allocate memory for part_desc_t strucure;
 *      RTEMS_INTERNAL_ERROR, if other error occurs.                  
 */                                                                   
static rtems_status_code                                              
data_to_part_desc(uint8_t *data, rtems_part_desc_t **new_part_desc)   
40004554:	82 10 00 18 	mov  %i0, %g1                                  
        return RTEMS_INTERNAL_ERROR;                                  
    }                                                                 
                                                                      
    *new_part_desc = NULL;                                            
                                                                      
    if ((part_desc = calloc(1, sizeof(rtems_part_desc_t))) == NULL)   
40004558:	ba 10 00 08 	mov  %o0, %i5                                  
4000455c:	80 a2 20 00 	cmp  %o0, 0                                    
40004560:	02 80 00 40 	be  40004660 <data_to_part_desc.part.1+0x120>  <== NEVER TAKEN
40004564:	b0 10 20 1a 	mov  0x1a, %i0                                 
    part_desc->sys_type = *(data + RTEMS_IDE_PARTITION_SYS_TYPE_OFFSET);
                                                                      
    /* read the offset start position and partition size in sectors */
                                                                      
    /* due to incorrect data alignment one have to align data first */
    memcpy(&temp, data + RTEMS_IDE_PARTITION_START_OFFSET, sizeof(uint32_t));
40004568:	c6 08 60 0b 	ldub  [ %g1 + 0xb ], %g3                       
4000456c:	da 08 60 08 	ldub  [ %g1 + 8 ], %o5                         
40004570:	de 08 60 09 	ldub  [ %g1 + 9 ], %o7                         
40004574:	f0 08 60 0a 	ldub  [ %g1 + 0xa ], %i0                       
    part_desc->start = LE_TO_CPU_U32(temp);                           
                                                                      
    memcpy(&temp, data + RTEMS_IDE_PARTITION_SIZE_OFFSET, sizeof(uint32_t));
40004578:	f6 08 60 0d 	ldub  [ %g1 + 0xd ], %i3                       
4000457c:	f8 08 60 0e 	ldub  [ %g1 + 0xe ], %i4                       
40004580:	c8 08 60 0f 	ldub  [ %g1 + 0xf ], %g4                       
40004584:	f4 08 60 0c 	ldub  [ %g1 + 0xc ], %i2                       
    part_desc->sys_type = *(data + RTEMS_IDE_PARTITION_SYS_TYPE_OFFSET);
                                                                      
    /* read the offset start position and partition size in sectors */
                                                                      
    /* due to incorrect data alignment one have to align data first */
    memcpy(&temp, data + RTEMS_IDE_PARTITION_START_OFFSET, sizeof(uint32_t));
40004588:	c6 2f bf ff 	stb  %g3, [ %fp + -1 ]                         
4000458c:	da 2f bf fc 	stb  %o5, [ %fp + -4 ]                         
40004590:	de 2f bf fd 	stb  %o7, [ %fp + -3 ]                         
40004594:	f0 2f bf fe 	stb  %i0, [ %fp + -2 ]                         
    part_desc->start = LE_TO_CPU_U32(temp);                           
40004598:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
    {                                                                 
        return RTEMS_NO_MEMORY;                                       
    }                                                                 
                                                                      
    part_desc->bootable = *(data + RTEMS_IDE_PARTITION_BOOTABLE_OFFSET);
    part_desc->sys_type = *(data + RTEMS_IDE_PARTITION_SYS_TYPE_OFFSET);
4000459c:	d2 08 60 04 	ldub  [ %g1 + 4 ], %o1                         
    if ((part_desc = calloc(1, sizeof(rtems_part_desc_t))) == NULL)   
    {                                                                 
        return RTEMS_NO_MEMORY;                                       
    }                                                                 
                                                                      
    part_desc->bootable = *(data + RTEMS_IDE_PARTITION_BOOTABLE_OFFSET);
400045a0:	c6 08 40 00 	ldub  [ %g1 ], %g3                             
                                                                      
    /* due to incorrect data alignment one have to align data first */
    memcpy(&temp, data + RTEMS_IDE_PARTITION_START_OFFSET, sizeof(uint32_t));
    part_desc->start = LE_TO_CPU_U32(temp);                           
                                                                      
    memcpy(&temp, data + RTEMS_IDE_PARTITION_SIZE_OFFSET, sizeof(uint32_t));
400045a4:	f6 2f bf fd 	stb  %i3, [ %fp + -3 ]                         
400045a8:	f8 2f bf fe 	stb  %i4, [ %fp + -2 ]                         
400045ac:	c8 2f bf ff 	stb  %g4, [ %fp + -1 ]                         
400045b0:	f4 2f bf fc 	stb  %i2, [ %fp + -4 ]                         
    part_desc->size = LE_TO_CPU_U32(temp);                            
400045b4:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
  byte4 = (value >> 24) & 0xff;                                       
  byte3 = (value >> 16) & 0xff;                                       
  byte2 = (value >> 8)  & 0xff;                                       
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
400045b8:	b7 28 a0 18 	sll  %g2, 0x18, %i3                            
  uint32_t value                                                      
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
400045bc:	89 30 a0 18 	srl  %g2, 0x18, %g4                            
  byte3 = (value >> 16) & 0xff;                                       
  byte2 = (value >> 8)  & 0xff;                                       
400045c0:	b9 30 a0 08 	srl  %g2, 8, %i4                               
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
400045c4:	88 16 c0 04 	or  %i3, %g4, %g4                              
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
  byte3 = (value >> 16) & 0xff;                                       
  byte2 = (value >> 8)  & 0xff;                                       
400045c8:	b8 0f 20 ff 	and  %i4, 0xff, %i4                            
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
400045cc:	b9 2f 20 10 	sll  %i4, 0x10, %i4                            
400045d0:	88 11 00 1c 	or  %g4, %i4, %g4                              
400045d4:	b7 28 60 18 	sll  %g1, 0x18, %i3                            
  uint32_t value                                                      
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
400045d8:	b9 30 60 18 	srl  %g1, 0x18, %i4                            
  byte3 = (value >> 16) & 0xff;                                       
400045dc:	85 30 a0 10 	srl  %g2, 0x10, %g2                            
  byte2 = (value >> 8)  & 0xff;                                       
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
400045e0:	b8 16 c0 1c 	or  %i3, %i4, %i4                              
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
  byte3 = (value >> 16) & 0xff;                                       
400045e4:	84 08 a0 ff 	and  %g2, 0xff, %g2                            
    if ((part_desc = calloc(1, sizeof(rtems_part_desc_t))) == NULL)   
    {                                                                 
        return RTEMS_NO_MEMORY;                                       
    }                                                                 
                                                                      
    part_desc->bootable = *(data + RTEMS_IDE_PARTITION_BOOTABLE_OFFSET);
400045e8:	c6 2a 00 00 	stb  %g3, [ %o0 ]                              
  byte2 = (value >> 8)  & 0xff;                                       
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
400045ec:	85 28 a0 08 	sll  %g2, 8, %g2                               
    part_desc->sys_type = *(data + RTEMS_IDE_PARTITION_SYS_TYPE_OFFSET);
400045f0:	d2 2a 20 01 	stb  %o1, [ %o0 + 1 ]                          
400045f4:	84 11 00 02 	or  %g4, %g2, %g2                              
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
  byte3 = (value >> 16) & 0xff;                                       
  byte2 = (value >> 8)  & 0xff;                                       
400045f8:	89 30 60 08 	srl  %g1, 8, %g4                               
                                                                      
    /* read the offset start position and partition size in sectors */
                                                                      
    /* due to incorrect data alignment one have to align data first */
    memcpy(&temp, data + RTEMS_IDE_PARTITION_START_OFFSET, sizeof(uint32_t));
    part_desc->start = LE_TO_CPU_U32(temp);                           
400045fc:	c4 22 20 04 	st  %g2, [ %o0 + 4 ]                           
40004600:	88 09 20 ff 	and  %g4, 0xff, %g4                            
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
  byte3 = (value >> 16) & 0xff;                                       
40004604:	83 30 60 10 	srl  %g1, 0x10, %g1                            
  byte2 = (value >> 8)  & 0xff;                                       
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
40004608:	89 29 20 10 	sll  %g4, 0x10, %g4                            
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
  byte3 = (value >> 16) & 0xff;                                       
4000460c:	82 08 60 ff 	and  %g1, 0xff, %g1                            
  byte2 = (value >> 8)  & 0xff;                                       
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
40004610:	b8 17 00 04 	or  %i4, %g4, %i4                              
40004614:	83 28 60 08 	sll  %g1, 8, %g1                               
40004618:	b8 17 00 01 	or  %i4, %g1, %i4                              
     * use partitions that are                                        
     * - extended                                                     
     * or                                                             
     * - FAT type and non-zero                                        
     */                                                               
    if (is_extended(part_desc->sys_type) ||                           
4000461c:	82 0a 60 7f 	and  %o1, 0x7f, %g1                            
40004620:	80 a0 60 05 	cmp  %g1, 5                                    
40004624:	02 80 00 11 	be  40004668 <data_to_part_desc.part.1+0x128>  
40004628:	f8 22 20 08 	st  %i4, [ %o0 + 8 ]                           
    DOS_P32MB_PARTITION,                                              
    FAT32_PARTITION    ,FAT32_LBA_PARTITION,                          
    FAT16_LBA_PARTITION                                               
  };                                                                  
                                                                      
  return (NULL != memchr(fat_part_types,type,sizeof(fat_part_types)));
4000462c:	92 0a 60 ff 	and  %o1, 0xff, %o1                            
40004630:	11 10 00 95 	sethi  %hi(0x40025400), %o0                    
40004634:	94 10 20 06 	mov  6, %o2                                    
40004638:	40 00 45 58 	call  40015b98 <memchr>                        
4000463c:	90 12 22 78 	or  %o0, 0x278, %o0                            
     * use partitions that are                                        
     * - extended                                                     
     * or                                                             
     * - FAT type and non-zero                                        
     */                                                               
    if (is_extended(part_desc->sys_type) ||                           
40004640:	80 a2 20 00 	cmp  %o0, 0                                    
40004644:	02 80 00 04 	be  40004654 <data_to_part_desc.part.1+0x114>  
40004648:	80 a7 20 00 	cmp  %i4, 0                                    
       ((is_fat_partition(part_desc->sys_type)) && (part_desc->size != 0))) {
4000464c:	32 80 00 08 	bne,a   4000466c <data_to_part_desc.part.1+0x12c><== ALWAYS TAKEN
40004650:	fa 26 40 00 	st  %i5, [ %i1 ]                               
      *new_part_desc = part_desc;                                     
    }                                                                 
    else {                                                            
      /* empty partition */                                           
      free(part_desc);                                                
40004654:	90 10 00 1d 	mov  %i5, %o0                                  
40004658:	40 00 03 48 	call  40005378 <free>                          
4000465c:	b0 10 20 00 	clr  %i0                                       
    }                                                                 
    return RTEMS_SUCCESSFUL;                                          
}                                                                     
40004660:	81 c7 e0 08 	ret                                            
40004664:	81 e8 00 00 	restore                                        
     * or                                                             
     * - FAT type and non-zero                                        
     */                                                               
    if (is_extended(part_desc->sys_type) ||                           
       ((is_fat_partition(part_desc->sys_type)) && (part_desc->size != 0))) {
      *new_part_desc = part_desc;                                     
40004668:	fa 26 40 00 	st  %i5, [ %i1 ]                               
    }                                                                 
    else {                                                            
      /* empty partition */                                           
      free(part_desc);                                                
    }                                                                 
    return RTEMS_SUCCESSFUL;                                          
4000466c:	81 c7 e0 08 	ret                                            
40004670:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

40002460 <devFS_Show>: #endif #include "devfs.h" void devFS_Show(void) {
40002460:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_filesystem_location_info_t *rootloc = &rtems_filesystem_root->location;
40002464:	03 10 00 4d 	sethi  %hi(0x40013400), %g1                    
40002468:	c2 00 60 48 	ld  [ %g1 + 0x48 ], %g1	! 40013448 <rtems_current_user_env>
                                                                      
  if (rootloc->mt_entry->ops == &devFS_ops) {                         
4000246c:	05 10 00 4a 	sethi  %hi(0x40012800), %g2                    
40002470:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
40002474:	84 10 a0 7c 	or  %g2, 0x7c, %g2                             
40002478:	c2 00 60 14 	ld  [ %g1 + 0x14 ], %g1                        
4000247c:	c6 00 60 0c 	ld  [ %g1 + 0xc ], %g3                         
40002480:	80 a0 c0 02 	cmp  %g3, %g2                                  
40002484:	22 80 00 04 	be,a   40002494 <devFS_Show+0x34>              <== ALWAYS TAKEN
40002488:	c2 00 60 10 	ld  [ %g1 + 0x10 ], %g1                        
4000248c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40002490:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    const devFS_data *data = devFS_get_data(rootloc);                 
    size_t i = 0;                                                     
    size_t n = data->count;                                           
40002494:	f0 00 60 04 	ld  [ %g1 + 4 ], %i0                           
    devFS_node *nodes = data->nodes;                                  
                                                                      
    for (i = 0; i < n; ++i) {                                         
40002498:	80 a6 20 00 	cmp  %i0, 0                                    
4000249c:	02 bf ff fc 	be  4000248c <devFS_Show+0x2c>                 <== NEVER TAKEN
400024a0:	f8 00 40 00 	ld  [ %g1 ], %i4                               
                                                                      
      if (current->name != NULL) {                                    
        size_t j = 0;                                                 
        size_t m = current->namelen;                                  
                                                                      
        printk("/");                                                  
400024a4:	23 10 00 4a 	sethi  %hi(0x40012800), %l1                    
        for (j = 0; j < m; ++j) {                                     
          printk("%c", current->name [j]);                            
400024a8:	35 10 00 4a 	sethi  %hi(0x40012800), %i2                    
        }                                                             
        printk(                                                       
400024ac:	21 10 00 4a 	sethi  %hi(0x40012800), %l0                    
    const devFS_data *data = devFS_get_data(rootloc);                 
    size_t i = 0;                                                     
    size_t n = data->count;                                           
    devFS_node *nodes = data->nodes;                                  
                                                                      
    for (i = 0; i < n; ++i) {                                         
400024b0:	b2 10 20 00 	clr  %i1                                       
                                                                      
      if (current->name != NULL) {                                    
        size_t j = 0;                                                 
        size_t m = current->namelen;                                  
                                                                      
        printk("/");                                                  
400024b4:	a2 14 60 d0 	or  %l1, 0xd0, %l1                             
        for (j = 0; j < m; ++j) {                                     
          printk("%c", current->name [j]);                            
400024b8:	b4 16 a0 e8 	or  %i2, 0xe8, %i2                             
        }                                                             
        printk(                                                       
400024bc:	a0 14 20 d8 	or  %l0, 0xd8, %l0                             
    devFS_node *nodes = data->nodes;                                  
                                                                      
    for (i = 0; i < n; ++i) {                                         
      devFS_node *current = nodes + i;                                
                                                                      
      if (current->name != NULL) {                                    
400024c0:	c2 07 00 00 	ld  [ %i4 ], %g1                               
400024c4:	80 a0 60 00 	cmp  %g1, 0                                    
400024c8:	22 80 00 15 	be,a   4000251c <devFS_Show+0xbc>              
400024cc:	b2 06 60 01 	inc  %i1                                       
        size_t j = 0;                                                 
        size_t m = current->namelen;                                  
400024d0:	f6 07 20 04 	ld  [ %i4 + 4 ], %i3                           
                                                                      
        printk("/");                                                  
400024d4:	40 00 03 e8 	call  40003474 <printk>                        
400024d8:	90 10 00 11 	mov  %l1, %o0                                  
        for (j = 0; j < m; ++j) {                                     
400024dc:	80 a6 e0 00 	cmp  %i3, 0                                    
400024e0:	02 80 00 0a 	be  40002508 <devFS_Show+0xa8>                 <== NEVER TAKEN
400024e4:	ba 10 20 00 	clr  %i5                                       
          printk("%c", current->name [j]);                            
400024e8:	c2 07 00 00 	ld  [ %i4 ], %g1                               
400024ec:	90 10 00 1a 	mov  %i2, %o0                                  
400024f0:	d2 48 40 1d 	ldsb  [ %g1 + %i5 ], %o1                       
400024f4:	40 00 03 e0 	call  40003474 <printk>                        
400024f8:	ba 07 60 01 	inc  %i5                                       
      if (current->name != NULL) {                                    
        size_t j = 0;                                                 
        size_t m = current->namelen;                                  
                                                                      
        printk("/");                                                  
        for (j = 0; j < m; ++j) {                                     
400024fc:	80 a7 40 1b 	cmp  %i5, %i3                                  
40002500:	32 bf ff fb 	bne,a   400024ec <devFS_Show+0x8c>             
40002504:	c2 07 00 00 	ld  [ %i4 ], %g1                               
          printk("%c", current->name [j]);                            
        }                                                             
        printk(                                                       
40002508:	d2 07 20 08 	ld  [ %i4 + 8 ], %o1                           
4000250c:	d4 07 20 0c 	ld  [ %i4 + 0xc ], %o2                         
40002510:	40 00 03 d9 	call  40003474 <printk>                        
40002514:	90 10 00 10 	mov  %l0, %o0                                  
    const devFS_data *data = devFS_get_data(rootloc);                 
    size_t i = 0;                                                     
    size_t n = data->count;                                           
    devFS_node *nodes = data->nodes;                                  
                                                                      
    for (i = 0; i < n; ++i) {                                         
40002518:	b2 06 60 01 	inc  %i1                                       
4000251c:	80 a6 40 18 	cmp  %i1, %i0                                  
40002520:	12 bf ff e8 	bne  400024c0 <devFS_Show+0x60>                
40002524:	b8 07 20 14 	add  %i4, 0x14, %i4                            
40002528:	81 c7 e0 08 	ret                                            
4000252c:	81 e8 00 00 	restore                                        
                                                                      

4000c5e8 <devFS_eval_path>: } void devFS_eval_path( rtems_filesystem_eval_path_context_t *ctx ) {
4000c5e8:	9d e3 bf a0 	save  %sp, -96, %sp                            
                                                                      
static inline const devFS_data *devFS_get_data(                       
  const rtems_filesystem_location_info_t *loc                         
)                                                                     
{                                                                     
  return (const devFS_data *) loc->mt_entry->immutable_fs_info;       
4000c5ec:	c2 06 20 2c 	ld  [ %i0 + 0x2c ], %g1                        
                                                                      
static inline const char *rtems_filesystem_eval_path_get_path(        
  rtems_filesystem_eval_path_context_t *ctx                           
)                                                                     
{                                                                     
  return ctx->path;                                                   
4000c5f0:	e2 06 00 00 	ld  [ %i0 ], %l1                               
4000c5f4:	c2 00 60 10 	ld  [ %g1 + 0x10 ], %g1                        
                                                                      
static inline size_t rtems_filesystem_eval_path_get_pathlen(          
  rtems_filesystem_eval_path_context_t *ctx                           
)                                                                     
{                                                                     
  return ctx->pathlen;                                                
4000c5f8:	f2 06 20 04 	ld  [ %i0 + 4 ], %i1                           
  size_t pathlen,                                                     
  devFS_node **free_node_ptr                                          
)                                                                     
{                                                                     
  size_t i = 0;                                                       
  size_t n = data->count;                                             
4000c5fc:	e0 00 60 04 	ld  [ %g1 + 4 ], %l0                           
  devFS_node *nodes = data->nodes;                                    
  devFS_node *node = NULL;                                            
  devFS_node *free_node = NULL;                                       
                                                                      
  for (i = 0; (free_node == NULL || node == NULL) && i < n; ++i) {    
4000c600:	80 a4 20 00 	cmp  %l0, 0                                    
4000c604:	02 80 00 3d 	be  4000c6f8 <devFS_eval_path+0x110>           
4000c608:	fa 00 40 00 	ld  [ %g1 ], %i5                               
)                                                                     
{                                                                     
  size_t i = 0;                                                       
  size_t n = data->count;                                             
  devFS_node *nodes = data->nodes;                                    
  devFS_node *node = NULL;                                            
4000c60c:	b4 10 20 00 	clr  %i2                                       
  devFS_node *free_node = NULL;                                       
4000c610:	82 10 20 00 	clr  %g1                                       
                                                                      
  for (i = 0; (free_node == NULL || node == NULL) && i < n; ++i) {    
4000c614:	10 80 00 09 	b  4000c638 <devFS_eval_path+0x50>             
4000c618:	b8 10 20 00 	clr  %i4                                       
4000c61c:	80 a6 a0 00 	cmp  %i2, 0                                    
4000c620:	12 80 00 18 	bne  4000c680 <devFS_eval_path+0x98>           <== NEVER TAKEN
4000c624:	b8 07 20 01 	inc  %i4                                       
4000c628:	ba 07 60 14 	add  %i5, 0x14, %i5                            
4000c62c:	80 a7 00 10 	cmp  %i4, %l0                                  
4000c630:	02 80 00 1f 	be  4000c6ac <devFS_eval_path+0xc4>            
4000c634:	82 10 00 1b 	mov  %i3, %g1                                  
    devFS_node *current = nodes + i;                                  
                                                                      
    if (current->name != NULL) {                                      
4000c638:	d0 07 40 00 	ld  [ %i5 ], %o0                               
4000c63c:	80 a2 20 00 	cmp  %o0, 0                                    
4000c640:	02 bf ff f7 	be  4000c61c <devFS_eval_path+0x34>            
4000c644:	b6 10 00 1d 	mov  %i5, %i3                                  
      if (                                                            
4000c648:	c4 07 60 04 	ld  [ %i5 + 4 ], %g2                           
4000c64c:	80 a6 40 02 	cmp  %i1, %g2                                  
4000c650:	12 bf ff f3 	bne  4000c61c <devFS_eval_path+0x34>           
4000c654:	b6 10 00 01 	mov  %g1, %i3                                  
        current->namelen == pathlen                                   
          && memcmp(current->name, path, pathlen) == 0                
4000c658:	92 10 00 11 	mov  %l1, %o1                                  
4000c65c:	40 00 0b f2 	call  4000f624 <memcmp>                        
4000c660:	94 10 00 19 	mov  %i1, %o2                                  
4000c664:	80 a2 20 00 	cmp  %o0, 0                                    
4000c668:	12 bf ff ee 	bne  4000c620 <devFS_eval_path+0x38>           
4000c66c:	80 a6 a0 00 	cmp  %i2, 0                                    
4000c670:	b4 10 00 1d 	mov  %i5, %i2                                  
  size_t n = data->count;                                             
  devFS_node *nodes = data->nodes;                                    
  devFS_node *node = NULL;                                            
  devFS_node *free_node = NULL;                                       
                                                                      
  for (i = 0; (free_node == NULL || node == NULL) && i < n; ++i) {    
4000c674:	80 a6 a0 00 	cmp  %i2, 0                                    
4000c678:	02 bf ff ec 	be  4000c628 <devFS_eval_path+0x40>            <== NEVER TAKEN
4000c67c:	b8 07 20 01 	inc  %i4                                       
4000c680:	80 a6 e0 00 	cmp  %i3, 0                                    
4000c684:	22 bf ff ea 	be,a   4000c62c <devFS_eval_path+0x44>         <== NEVER TAKEN
4000c688:	ba 07 60 14 	add  %i5, 0x14, %i5                            <== NOT EXECUTED
                                                                      
static inline int rtems_filesystem_eval_path_get_flags(               
  const rtems_filesystem_eval_path_context_t *ctx                     
)                                                                     
{                                                                     
  return ctx->flags;                                                  
4000c68c:	c2 06 20 10 	ld  [ %i0 + 0x10 ], %g1                        
    &free_node                                                        
  );                                                                  
  int eval_flags = rtems_filesystem_eval_path_get_flags(ctx);         
                                                                      
  if (node != NULL) {                                                 
    if ((eval_flags & RTEMS_FS_EXCLUSIVE) == 0) {                     
4000c690:	80 88 60 40 	btst  0x40, %g1                                
4000c694:	12 80 00 15 	bne  4000c6e8 <devFS_eval_path+0x100>          
4000c698:	01 00 00 00 	nop                                            
      currentloc->node_access = node;                                 
4000c69c:	f4 26 20 20 	st  %i2, [ %i0 + 0x20 ]                        
                                                                      
static inline void rtems_filesystem_eval_path_clear_path(             
  rtems_filesystem_eval_path_context_t *ctx                           
)                                                                     
{                                                                     
  ctx->pathlen = 0;                                                   
4000c6a0:	c0 26 20 04 	clr  [ %i0 + 4 ]                               
4000c6a4:	81 c7 e0 08 	ret                                            
4000c6a8:	81 e8 00 00 	restore                                        
    rtems_filesystem_eval_path_get_pathlen(ctx),                      
    &free_node                                                        
  );                                                                  
  int eval_flags = rtems_filesystem_eval_path_get_flags(ctx);         
                                                                      
  if (node != NULL) {                                                 
4000c6ac:	80 a6 a0 00 	cmp  %i2, 0                                    
4000c6b0:	12 bf ff f8 	bne  4000c690 <devFS_eval_path+0xa8>           <== NEVER TAKEN
4000c6b4:	c2 06 20 10 	ld  [ %i0 + 0x10 ], %g1                        
      rtems_filesystem_eval_path_clear_path(ctx);                     
    } else {                                                          
      rtems_filesystem_eval_path_error(ctx, EEXIST);                  
    }                                                                 
  } else {                                                            
    if ((eval_flags & RTEMS_FS_MAKE) != 0) {                          
4000c6b8:	80 88 60 20 	btst  0x20, %g1                                
4000c6bc:	02 80 00 0d 	be  4000c6f0 <devFS_eval_path+0x108>           <== NEVER TAKEN
4000c6c0:	80 a6 e0 00 	cmp  %i3, 0                                    
      if (free_node != NULL) {                                        
4000c6c4:	02 80 00 11 	be  4000c708 <devFS_eval_path+0x120>           <== NEVER TAKEN
4000c6c8:	82 10 21 ff 	mov  0x1ff, %g1                                
        free_node->mode = S_IRWXU | S_IRWXG | S_IRWXO;                
4000c6cc:	c2 26 e0 10 	st  %g1, [ %i3 + 0x10 ]                        
        currentloc->node_access = free_node;                          
4000c6d0:	f6 26 20 20 	st  %i3, [ %i0 + 0x20 ]                        
  rtems_filesystem_eval_path_context_t *ctx,                          
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  ctx->token = token;                                                 
4000c6d4:	e2 26 20 08 	st  %l1, [ %i0 + 8 ]                           
  ctx->tokenlen = tokenlen;                                           
4000c6d8:	f2 26 20 0c 	st  %i1, [ %i0 + 0xc ]                         
                                                                      
static inline void rtems_filesystem_eval_path_clear_path(             
  rtems_filesystem_eval_path_context_t *ctx                           
)                                                                     
{                                                                     
  ctx->pathlen = 0;                                                   
4000c6dc:	c0 26 20 04 	clr  [ %i0 + 4 ]                               
4000c6e0:	81 c7 e0 08 	ret                                            
4000c6e4:	81 e8 00 00 	restore                                        
  if (node != NULL) {                                                 
    if ((eval_flags & RTEMS_FS_EXCLUSIVE) == 0) {                     
      currentloc->node_access = node;                                 
      rtems_filesystem_eval_path_clear_path(ctx);                     
    } else {                                                          
      rtems_filesystem_eval_path_error(ctx, EEXIST);                  
4000c6e8:	7f ff e2 a1 	call  4000516c <rtems_filesystem_eval_path_error>
4000c6ec:	93 e8 20 11 	restore  %g0, 0x11, %o1                        
        rtems_filesystem_eval_path_clear_path(ctx);                   
      } else {                                                        
        rtems_filesystem_eval_path_error(ctx, ENOSPC);                
      }                                                               
    } else {                                                          
      rtems_filesystem_eval_path_error(ctx, ENOENT);                  
4000c6f0:	7f ff e2 9f 	call  4000516c <rtems_filesystem_eval_path_error><== NOT EXECUTED
4000c6f4:	93 e8 20 02 	restore  %g0, 2, %o1                           <== NOT EXECUTED
      rtems_filesystem_eval_path_clear_path(ctx);                     
    } else {                                                          
      rtems_filesystem_eval_path_error(ctx, EEXIST);                  
    }                                                                 
  } else {                                                            
    if ((eval_flags & RTEMS_FS_MAKE) != 0) {                          
4000c6f8:	c2 06 20 10 	ld  [ %i0 + 0x10 ], %g1                        
4000c6fc:	80 88 60 20 	btst  0x20, %g1                                
4000c700:	02 bf ff fc 	be  4000c6f0 <devFS_eval_path+0x108>           <== NEVER TAKEN
4000c704:	01 00 00 00 	nop                                            
          rtems_filesystem_eval_path_get_path(ctx),                   
          rtems_filesystem_eval_path_get_pathlen(ctx)                 
        );                                                            
        rtems_filesystem_eval_path_clear_path(ctx);                   
      } else {                                                        
        rtems_filesystem_eval_path_error(ctx, ENOSPC);                
4000c708:	7f ff e2 99 	call  4000516c <rtems_filesystem_eval_path_error>
4000c70c:	93 e8 20 1c 	restore  %g0, 0x1c, %o1                        
                                                                      

40003ee8 <devFS_mknod>: const char *name, size_t namelen, mode_t mode, dev_t dev ) {
40003ee8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rv = 0;                                                         
                                                                      
  if (namelen != 3 || name [0] != 'd' || name [1] != 'e' || name [2] != 'v') {
40003eec:	80 a6 a0 03 	cmp  %i2, 3                                    
40003ef0:	22 80 00 18 	be,a   40003f50 <devFS_mknod+0x68>             
40003ef4:	c2 4e 40 00 	ldsb  [ %i1 ], %g1                             
    if (S_ISBLK(mode) || S_ISCHR(mode)) {                             
40003ef8:	05 00 00 2c 	sethi  %hi(0xb000), %g2                        
40003efc:	03 00 00 08 	sethi  %hi(0x2000), %g1                        
40003f00:	84 0e c0 02 	and  %i3, %g2, %g2                             
40003f04:	80 a0 80 01 	cmp  %g2, %g1                                  
40003f08:	12 80 00 23 	bne  40003f94 <devFS_mknod+0xac>               
40003f0c:	01 00 00 00 	nop                                            
      char *dupname = malloc(namelen);                                
40003f10:	40 00 01 5a 	call  40004478 <malloc>                        
40003f14:	90 10 00 1a 	mov  %i2, %o0                                  
                                                                      
      if (dupname != NULL) {                                          
40003f18:	84 92 20 00 	orcc  %o0, 0, %g2                              
40003f1c:	02 80 00 24 	be  40003fac <devFS_mknod+0xc4>                
40003f20:	92 10 00 19 	mov  %i1, %o1                                  
        devFS_node *node = parentloc->node_access;                    
40003f24:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
                                                                      
        node->name = dupname;                                         
40003f28:	c4 20 40 00 	st  %g2, [ %g1 ]                               
        node->namelen = namelen;                                      
40003f2c:	f4 20 60 04 	st  %i2, [ %g1 + 4 ]                           
        node->major = rtems_filesystem_dev_major_t(dev);              
40003f30:	f8 20 60 08 	st  %i4, [ %g1 + 8 ]                           
        node->minor = rtems_filesystem_dev_minor_t(dev);              
40003f34:	fa 20 60 0c 	st  %i5, [ %g1 + 0xc ]                         
        node->mode = mode;                                            
40003f38:	f6 20 60 10 	st  %i3, [ %g1 + 0x10 ]                        
        memcpy(dupname, name, namelen);                               
40003f3c:	94 10 00 1a 	mov  %i2, %o2                                  
40003f40:	40 00 2d e3 	call  4000f6cc <memcpy>                        
40003f44:	b0 10 20 00 	clr  %i0                                       
40003f48:	81 c7 e0 08 	ret                                            
40003f4c:	81 e8 00 00 	restore                                        
  dev_t dev                                                           
)                                                                     
{                                                                     
  int rv = 0;                                                         
                                                                      
  if (namelen != 3 || name [0] != 'd' || name [1] != 'e' || name [2] != 'v') {
40003f50:	80 a0 60 64 	cmp  %g1, 0x64                                 
40003f54:	12 bf ff ea 	bne  40003efc <devFS_mknod+0x14>               <== NEVER TAKEN
40003f58:	05 00 00 2c 	sethi  %hi(0xb000), %g2                        
40003f5c:	c2 4e 60 01 	ldsb  [ %i1 + 1 ], %g1                         
40003f60:	80 a0 60 65 	cmp  %g1, 0x65                                 
40003f64:	12 bf ff e7 	bne  40003f00 <devFS_mknod+0x18>               <== NEVER TAKEN
40003f68:	03 00 00 08 	sethi  %hi(0x2000), %g1                        
40003f6c:	c2 4e 60 02 	ldsb  [ %i1 + 2 ], %g1                         
40003f70:	80 a0 60 76 	cmp  %g1, 0x76                                 
40003f74:	12 bf ff e3 	bne  40003f00 <devFS_mknod+0x18>               <== NEVER TAKEN
40003f78:	03 00 00 08 	sethi  %hi(0x2000), %g1                        
    } else {                                                          
      errno = ENOTSUP;                                                
      rv = -1;                                                        
    }                                                                 
  } else {                                                            
    if (!S_ISDIR(mode)) {                                             
40003f7c:	03 00 00 3c 	sethi  %hi(0xf000), %g1                        
40003f80:	b6 0e c0 01 	and  %i3, %g1, %i3                             
40003f84:	03 00 00 10 	sethi  %hi(0x4000), %g1                        
40003f88:	80 a6 c0 01 	cmp  %i3, %g1                                  
40003f8c:	02 bf ff ef 	be  40003f48 <devFS_mknod+0x60>                <== ALWAYS TAKEN
40003f90:	b0 10 20 00 	clr  %i0                                       
      errno = ENOTSUP;                                                
40003f94:	40 00 2b 35 	call  4000ec68 <__errno>                       
40003f98:	b0 10 3f ff 	mov  -1, %i0                                   
40003f9c:	82 10 20 86 	mov  0x86, %g1                                 
40003fa0:	c2 22 00 00 	st  %g1, [ %o0 ]                               
      rv = -1;                                                        
    }                                                                 
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
40003fa4:	81 c7 e0 08 	ret                                            
40003fa8:	81 e8 00 00 	restore                                        
        node->major = rtems_filesystem_dev_major_t(dev);              
        node->minor = rtems_filesystem_dev_minor_t(dev);              
        node->mode = mode;                                            
        memcpy(dupname, name, namelen);                               
      } else {                                                        
        errno = ENOMEM;                                               
40003fac:	40 00 2b 2f 	call  4000ec68 <__errno>                       
40003fb0:	b0 10 3f ff 	mov  -1, %i0                                   
40003fb4:	82 10 20 0c 	mov  0xc, %g1                                  
40003fb8:	c2 22 00 00 	st  %g1, [ %o0 ]                               
40003fbc:	81 c7 e0 08 	ret                                            
40003fc0:	81 e8 00 00 	restore                                        
                                                                      

40002ef0 <disk_lock>: */ static volatile bool diskdevs_protected; static rtems_status_code disk_lock(void) {
40002ef0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  sc = rtems_semaphore_obtain(diskdevs_mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
40002ef4:	03 10 00 6b 	sethi  %hi(0x4001ac00), %g1                    
40002ef8:	d0 00 62 14 	ld  [ %g1 + 0x214 ], %o0	! 4001ae14 <diskdevs_mutex>
40002efc:	92 10 20 00 	clr  %o1                                       
40002f00:	94 10 20 00 	clr  %o2                                       
40002f04:	40 00 15 d1 	call  40008648 <rtems_semaphore_obtain>        
40002f08:	b0 10 20 16 	mov  0x16, %i0                                 
  if (sc == RTEMS_SUCCESSFUL) {                                       
40002f0c:	80 a2 20 00 	cmp  %o0, 0                                    
40002f10:	12 80 00 05 	bne  40002f24 <disk_lock+0x34>                 <== NEVER TAKEN
40002f14:	84 10 20 01 	mov  1, %g2                                    
    diskdevs_protected = true;                                        
40002f18:	03 10 00 6b 	sethi  %hi(0x4001ac00), %g1                    
                                                                      
    return RTEMS_SUCCESSFUL;                                          
40002f1c:	b0 10 20 00 	clr  %i0                                       
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  sc = rtems_semaphore_obtain(diskdevs_mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
  if (sc == RTEMS_SUCCESSFUL) {                                       
    diskdevs_protected = true;                                        
40002f20:	c4 28 62 10 	stb  %g2, [ %g1 + 0x210 ]                      
                                                                      
    return RTEMS_SUCCESSFUL;                                          
  } else {                                                            
    return RTEMS_NOT_CONFIGURED;                                      
  }                                                                   
}                                                                     
40002f24:	81 c7 e0 08 	ret                                            
40002f28:	81 e8 00 00 	restore                                        
                                                                      

40002f2c <disk_unlock>: static void disk_unlock(void) {
40002f2c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  diskdevs_protected = false;                                         
                                                                      
  sc = rtems_semaphore_release(diskdevs_mutex);                       
40002f30:	03 10 00 6b 	sethi  %hi(0x4001ac00), %g1                    
40002f34:	d0 00 62 14 	ld  [ %g1 + 0x214 ], %o0	! 4001ae14 <diskdevs_mutex>
static void                                                           
disk_unlock(void)                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  diskdevs_protected = false;                                         
40002f38:	03 10 00 6b 	sethi  %hi(0x4001ac00), %g1                    
40002f3c:	c0 28 62 10 	clrb  [ %g1 + 0x210 ]	! 4001ae10 <diskdevs_protected>
                                                                      
  sc = rtems_semaphore_release(diskdevs_mutex);                       
40002f40:	40 00 16 11 	call  40008784 <rtems_semaphore_release>       
40002f44:	01 00 00 00 	nop                                            
  if (sc != RTEMS_SUCCESSFUL) {                                       
40002f48:	80 a2 20 00 	cmp  %o0, 0                                    
40002f4c:	12 80 00 04 	bne  40002f5c <disk_unlock+0x30>               <== NEVER TAKEN
40002f50:	11 37 ab 6f 	sethi  %hi(0xdeadbc00), %o0                    
40002f54:	81 c7 e0 08 	ret                                            
40002f58:	81 e8 00 00 	restore                                        
    /* FIXME: Error number */                                         
    rtems_fatal_error_occurred(0xdeadbeef);                           
40002f5c:	40 00 17 75 	call  40008d30 <rtems_fatal_error_occurred>    <== NOT EXECUTED
40002f60:	90 12 22 ef 	or  %o0, 0x2ef, %o0                            <== NOT EXECUTED
                                                                      

40004bc8 <drainOutput.part.0>: /* * Drain output queue */ static void drainOutput (struct rtems_termios_tty *tty)
40004bc8:	9d e3 bf a0 	save  %sp, -96, %sp                            
{                                                                     
  rtems_interrupt_level level;                                        
  rtems_status_code sc;                                               
                                                                      
  if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {           
    rtems_interrupt_disable (level);                                  
40004bcc:	7f ff f5 36 	call  400020a4 <sparc_disable_interrupts>      
40004bd0:	01 00 00 00 	nop                                            
    while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {              
40004bd4:	c4 06 20 84 	ld  [ %i0 + 0x84 ], %g2                        
40004bd8:	c2 06 20 80 	ld  [ %i0 + 0x80 ], %g1                        
40004bdc:	80 a0 80 01 	cmp  %g2, %g1                                  
40004be0:	02 80 00 14 	be  40004c30 <drainOutput.part.0+0x68>         <== ALWAYS TAKEN
40004be4:	01 00 00 00 	nop                                            
      tty->rawOutBufState = rob_wait;                                 
40004be8:	b8 10 20 02 	mov  2, %i4	! 2 <PROM_START+0x2>               <== NOT EXECUTED
40004bec:	f8 26 20 94 	st  %i4, [ %i0 + 0x94 ]                        <== NOT EXECUTED
      rtems_interrupt_enable (level);                                 
40004bf0:	7f ff f5 31 	call  400020b4 <sparc_enable_interrupts>       <== NOT EXECUTED
40004bf4:	01 00 00 00 	nop                                            <== NOT EXECUTED
      sc = rtems_semaphore_obtain(                                    
40004bf8:	d0 06 20 8c 	ld  [ %i0 + 0x8c ], %o0                        <== NOT EXECUTED
40004bfc:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
40004c00:	40 00 09 e3 	call  4000738c <rtems_semaphore_obtain>        <== NOT EXECUTED
40004c04:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
        tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);      
      if (sc != RTEMS_SUCCESSFUL)                                     
40004c08:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40004c0c:	12 80 00 0b 	bne  40004c38 <drainOutput.part.0+0x70>        <== NOT EXECUTED
40004c10:	01 00 00 00 	nop                                            <== NOT EXECUTED
        rtems_fatal_error_occurred (sc);                              
      rtems_interrupt_disable (level);                                
40004c14:	7f ff f5 24 	call  400020a4 <sparc_disable_interrupts>      <== NOT EXECUTED
40004c18:	01 00 00 00 	nop                                            <== 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) {              
40004c1c:	c4 06 20 84 	ld  [ %i0 + 0x84 ], %g2                        <== NOT EXECUTED
40004c20:	c2 06 20 80 	ld  [ %i0 + 0x80 ], %g1                        <== NOT EXECUTED
40004c24:	80 a0 80 01 	cmp  %g2, %g1                                  <== NOT EXECUTED
40004c28:	32 bf ff f2 	bne,a   40004bf0 <drainOutput.part.0+0x28>     <== NOT EXECUTED
40004c2c:	f8 26 20 94 	st  %i4, [ %i0 + 0x94 ]                        <== NOT EXECUTED
        tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);      
      if (sc != RTEMS_SUCCESSFUL)                                     
        rtems_fatal_error_occurred (sc);                              
      rtems_interrupt_disable (level);                                
    }                                                                 
    rtems_interrupt_enable (level);                                   
40004c30:	7f ff f5 21 	call  400020b4 <sparc_enable_interrupts>       
40004c34:	91 e8 00 08 	restore  %g0, %o0, %o0                         
      tty->rawOutBufState = rob_wait;                                 
      rtems_interrupt_enable (level);                                 
      sc = rtems_semaphore_obtain(                                    
        tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);      
      if (sc != RTEMS_SUCCESSFUL)                                     
        rtems_fatal_error_occurred (sc);                              
40004c38:	40 00 0b ba 	call  40007b20 <rtems_fatal_error_occurred>    <== NOT EXECUTED
                                                                      

40003594 <dup>: int dup( int fildes ) { return fcntl( fildes, F_DUPFD, 0 );
40003594:	92 10 20 00 	clr  %o1                                       
40003598:	94 10 20 00 	clr  %o2                                       
4000359c:	82 13 c0 00 	mov  %o7, %g1                                  
400035a0:	40 00 00 0c 	call  400035d0 <fcntl>                         
400035a4:	9e 10 40 00 	mov  %g1, %o7                                  
400035a8:	40 00 37 10 	call  400111e8 <_fwalk_reent+0x14>             <== NOT EXECUTED
400035ac:	40 00 37 04 	call  400111bc <_fwalk+0x70>                   <== NOT EXECUTED
400035b0:	40 00 36 e4 	call  40011140 <fseek+0x18>                    <== NOT EXECUTED
400035b4:	40 00 36 c4 	call  400110c4 <_fseek_r+0x53c>                <== NOT EXECUTED
400035b8:	40 00 36 70 	call  40010f78 <_fseek_r+0x3f0>                <== NOT EXECUTED
400035bc:	40 00 36 58 	call  40010f1c <_fseek_r+0x394>                <== NOT EXECUTED
400035c0:	40 00 36 58 	call  40010f20 <_fseek_r+0x398>                <== NOT EXECUTED
400035c4:	40 00 36 58 	call  40010f24 <_fseek_r+0x39c>                <== NOT EXECUTED
400035c8:	40 00 36 58 	call  40010f28 <_fseek_r+0x3a0>                <== NOT EXECUTED
400035cc:	40 00 36 58 	call  40010f2c <_fseek_r+0x3a4>                <== NOT EXECUTED
                                                                      

40003548 <dup2>: */ int dup2( int fildes, int fildes2 ) {
40003548:	9d e3 bf 58 	save  %sp, -168, %sp                           
                                                                      
  /*                                                                  
   *  If fildes is not valid, then fildes2 should not be closed.      
   */                                                                 
                                                                      
  status = fstat( fildes, &buf );                                     
4000354c:	90 10 00 18 	mov  %i0, %o0                                  
40003550:	40 00 01 50 	call  40003a90 <fstat>                         
40003554:	92 07 bf b8 	add  %fp, -72, %o1                             
  if ( status == -1 )                                                 
40003558:	80 a2 3f ff 	cmp  %o0, -1                                   
4000355c:	02 80 00 0c 	be  4000358c <dup2+0x44>                       
40003560:	90 10 00 19 	mov  %i1, %o0                                  
                                                                      
  /*                                                                  
   *  If fildes2 is not valid, then we should not do anything either. 
   */                                                                 
                                                                      
  status = fstat( fildes2, &buf );                                    
40003564:	40 00 01 4b 	call  40003a90 <fstat>                         
40003568:	92 07 bf b8 	add  %fp, -72, %o1                             
  if ( status == -1 )                                                 
4000356c:	80 a2 3f ff 	cmp  %o0, -1                                   
40003570:	02 80 00 07 	be  4000358c <dup2+0x44>                       <== NEVER TAKEN
40003574:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
  /*                                                                  
   *  This fcntl handles everything else.                             
   */                                                                 
                                                                      
  return fcntl( fildes, F_DUPFD, fildes2 );                           
40003578:	92 10 20 00 	clr  %o1                                       
4000357c:	40 00 00 15 	call  400035d0 <fcntl>                         
40003580:	94 10 00 19 	mov  %i1, %o2                                  
}                                                                     
40003584:	81 c7 e0 08 	ret                                            
40003588:	91 e8 00 08 	restore  %g0, %o0, %o0                         
   *  If fildes is not valid, then fildes2 should not be closed.      
   */                                                                 
                                                                      
  status = fstat( fildes, &buf );                                     
  if ( status == -1 )                                                 
    return -1;                                                        
4000358c:	81 c7 e0 08 	ret                                            
40003590:	91 e8 3f ff 	restore  %g0, -1, %o0                          
                                                                      

400059ec <echo>: /* * Echo a typed character */ static void echo (unsigned char c, struct rtems_termios_tty *tty) {
400059ec:	9d e3 bf 98 	save  %sp, -104, %sp                           
  if ((tty->termios.c_lflag & ECHOCTL) &&                             
400059f0:	c2 06 60 3c 	ld  [ %i1 + 0x3c ], %g1                        
400059f4:	80 88 62 00 	btst  0x200, %g1                               
400059f8:	02 80 00 0d 	be  40005a2c <echo+0x40>                       <== NEVER TAKEN
400059fc:	03 10 00 79 	sethi  %hi(0x4001e400), %g1                    
       iscntrl(c) && (c != '\t') && (c != '\n')) {                    
40005a00:	c2 00 61 60 	ld  [ %g1 + 0x160 ], %g1	! 4001e560 <__ctype_ptr__>
40005a04:	82 00 40 18 	add  %g1, %i0, %g1                             
40005a08:	c2 08 60 01 	ldub  [ %g1 + 1 ], %g1                         
 * Echo a typed character                                             
 */                                                                   
static void                                                           
echo (unsigned char c, struct rtems_termios_tty *tty)                 
{                                                                     
  if ((tty->termios.c_lflag & ECHOCTL) &&                             
40005a0c:	80 88 60 20 	btst  0x20, %g1                                
40005a10:	02 80 00 08 	be  40005a30 <echo+0x44>                       
40005a14:	90 10 00 18 	mov  %i0, %o0                                  
       iscntrl(c) && (c != '\t') && (c != '\n')) {                    
40005a18:	82 06 3f f7 	add  %i0, -9, %g1                              
40005a1c:	82 08 60 ff 	and  %g1, 0xff, %g1                            
40005a20:	80 a0 60 01 	cmp  %g1, 1                                    
40005a24:	18 80 00 07 	bgu  40005a40 <echo+0x54>                      
40005a28:	82 10 20 5e 	mov  0x5e, %g1                                 
    echobuf[0] = '^';                                                 
    echobuf[1] = c ^ 0x40;                                            
    rtems_termios_puts (echobuf, 2, tty);                             
    tty->column += 2;                                                 
  } else {                                                            
    oproc (c, tty);                                                   
40005a2c:	90 10 00 18 	mov  %i0, %o0                                  
40005a30:	7f ff ff 8f 	call  4000586c <oproc>                         
40005a34:	92 10 00 19 	mov  %i1, %o1                                  
40005a38:	81 c7 e0 08 	ret                                            
40005a3c:	81 e8 00 00 	restore                                        
  if ((tty->termios.c_lflag & ECHOCTL) &&                             
       iscntrl(c) && (c != '\t') && (c != '\n')) {                    
    char echobuf[2];                                                  
                                                                      
    echobuf[0] = '^';                                                 
    echobuf[1] = c ^ 0x40;                                            
40005a40:	b0 1e 20 40 	xor  %i0, 0x40, %i0                            
{                                                                     
  if ((tty->termios.c_lflag & ECHOCTL) &&                             
       iscntrl(c) && (c != '\t') && (c != '\n')) {                    
    char echobuf[2];                                                  
                                                                      
    echobuf[0] = '^';                                                 
40005a44:	c2 2f bf f8 	stb  %g1, [ %fp + -8 ]                         
    echobuf[1] = c ^ 0x40;                                            
40005a48:	f0 2f bf f9 	stb  %i0, [ %fp + -7 ]                         
    rtems_termios_puts (echobuf, 2, tty);                             
40005a4c:	90 07 bf f8 	add  %fp, -8, %o0                              
40005a50:	92 10 20 02 	mov  2, %o1                                    
40005a54:	7f ff ff 36 	call  4000572c <rtems_termios_puts>            
40005a58:	94 10 00 19 	mov  %i1, %o2                                  
    tty->column += 2;                                                 
40005a5c:	c2 06 60 28 	ld  [ %i1 + 0x28 ], %g1                        
40005a60:	82 00 60 02 	add  %g1, 2, %g1                               
40005a64:	c2 26 60 28 	st  %g1, [ %i1 + 0x28 ]                        
40005a68:	81 c7 e0 08 	ret                                            
40005a6c:	81 e8 00 00 	restore                                        
                                                                      

40027728 <endgrent>: } void endgrent(void) { if (group_fp != NULL)
40027728:	03 10 01 9f 	sethi  %hi(0x40067c00), %g1                    
4002772c:	d0 00 62 e0 	ld  [ %g1 + 0x2e0 ], %o0	! 40067ee0 <group_fp> 
40027730:	80 a2 20 00 	cmp  %o0, 0                                    
40027734:	02 80 00 05 	be  40027748 <endgrent+0x20>                   <== NEVER TAKEN
40027738:	01 00 00 00 	nop                                            
    fclose(group_fp);                                                 
4002773c:	82 13 c0 00 	mov  %o7, %g1                                  
40027740:	40 00 4f dc 	call  4003b6b0 <fclose>                        
40027744:	9e 10 40 00 	mov  %g1, %o7                                  
40027748:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
                                                                      

4002758c <endpwent>: } void endpwent(void) { if (passwd_fp != NULL)
4002758c:	03 10 01 9f 	sethi  %hi(0x40067c00), %g1                    
40027590:	d0 00 62 00 	ld  [ %g1 + 0x200 ], %o0	! 40067e00 <passwd_fp>
40027594:	80 a2 20 00 	cmp  %o0, 0                                    
40027598:	02 80 00 05 	be  400275ac <endpwent+0x20>                   <== NEVER TAKEN
4002759c:	01 00 00 00 	nop                                            
    fclose(passwd_fp);                                                
400275a0:	82 13 c0 00 	mov  %o7, %g1                                  
400275a4:	40 00 50 43 	call  4003b6b0 <fclose>                        
400275a8:	9e 10 40 00 	mov  %g1, %o7                                  
400275ac:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
                                                                      

40005a70 <erase.part.2>: * Erase a character or line * 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)
40005a70:	9d e3 bf a0 	save  %sp, -96, %sp                            
                                                                      
        /*                                                            
         * Back up over the tab                                       
         */                                                           
        while (tty->column > col) {                                   
          rtems_termios_puts ("\b", 1, tty);                          
40005a74:	37 10 00 73 	sethi  %hi(0x4001cc00), %i3                    
 * Erase a character or line                                          
 * 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)                   
40005a78:	ba 10 00 18 	mov  %i0, %i5                                  
          rtems_termios_puts ("\b", 1, tty);                          
          tty->column--;                                              
        }                                                             
      }                                                               
      else {                                                          
        if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {        
40005a7c:	35 10 00 79 	sethi  %hi(0x4001e400), %i2                    
          rtems_termios_puts ("\b \b", 3, tty);                       
40005a80:	31 10 00 73 	sethi  %hi(0x4001cc00), %i0                    
                                                                      
        /*                                                            
         * Back up over the tab                                       
         */                                                           
        while (tty->column > col) {                                   
          rtems_termios_puts ("\b", 1, tty);                          
40005a84:	b6 16 e3 58 	or  %i3, 0x358, %i3                            
          tty->column--;                                              
        }                                                             
      }                                                               
      else {                                                          
        if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {        
          rtems_termios_puts ("\b \b", 3, tty);                       
40005a88:	10 80 00 0f 	b  40005ac4 <erase.part.2+0x54>                
40005a8c:	b0 16 23 60 	or  %i0, 0x360, %i0                            
          if (tty->column)                                            
            tty->column--;                                            
        }                                                             
        if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {       
          rtems_termios_puts ("\b \b", 3, tty);                       
40005a90:	90 12 23 60 	or  %o0, 0x360, %o0                            
40005a94:	92 10 20 03 	mov  3, %o1                                    
40005a98:	7f ff ff 25 	call  4000572c <rtems_termios_puts>            
40005a9c:	94 10 00 1d 	mov  %i5, %o2                                  
          if (tty->column)                                            
40005aa0:	c2 07 60 28 	ld  [ %i5 + 0x28 ], %g1                        
40005aa4:	80 a0 60 00 	cmp  %g1, 0                                    
40005aa8:	02 80 00 05 	be  40005abc <erase.part.2+0x4c>               <== NEVER TAKEN
40005aac:	80 a6 60 00 	cmp  %i1, 0                                    
            tty->column--;                                            
40005ab0:	82 00 7f ff 	add  %g1, -1, %g1                              
40005ab4:	c2 27 60 28 	st  %g1, [ %i5 + 0x28 ]                        
        }                                                             
      }                                                               
    }                                                                 
    if (!lineFlag)                                                    
40005ab8:	80 a6 60 00 	cmp  %i1, 0                                    
40005abc:	02 80 00 58 	be  40005c1c <erase.part.2+0x1ac>              
40005ac0:	01 00 00 00 	nop                                            
        echo ('\n', tty);                                             
      return;                                                         
    }                                                                 
  }                                                                   
                                                                      
  while (tty->ccount) {                                               
40005ac4:	c4 07 60 20 	ld  [ %i5 + 0x20 ], %g2                        
40005ac8:	80 a0 a0 00 	cmp  %g2, 0                                    
40005acc:	02 80 00 54 	be  40005c1c <erase.part.2+0x1ac>              
40005ad0:	84 00 bf ff 	add  %g2, -1, %g2                              
    unsigned char c = tty->cbuf[--tty->ccount];                       
40005ad4:	c8 07 60 1c 	ld  [ %i5 + 0x1c ], %g4                        
                                                                      
    if (tty->termios.c_lflag & ECHO) {                                
40005ad8:	c6 07 60 3c 	ld  [ %i5 + 0x3c ], %g3                        
      return;                                                         
    }                                                                 
  }                                                                   
                                                                      
  while (tty->ccount) {                                               
    unsigned char c = tty->cbuf[--tty->ccount];                       
40005adc:	c4 27 60 20 	st  %g2, [ %i5 + 0x20 ]                        
                                                                      
    if (tty->termios.c_lflag & ECHO) {                                
40005ae0:	80 88 e0 08 	btst  8, %g3                                   
40005ae4:	02 bf ff f5 	be  40005ab8 <erase.part.2+0x48>               <== NEVER TAKEN
40005ae8:	c2 09 00 02 	ldub  [ %g4 + %g2 ], %g1                       
      if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {             
40005aec:	80 a6 60 00 	cmp  %i1, 0                                    
40005af0:	12 80 00 05 	bne  40005b04 <erase.part.2+0x94>              
40005af4:	82 08 60 ff 	and  %g1, 0xff, %g1                            
40005af8:	80 88 e0 10 	btst  0x10, %g3                                
40005afc:	22 80 00 4d 	be,a   40005c30 <erase.part.2+0x1c0>           <== NEVER TAKEN
40005b00:	f0 0f 60 43 	ldub  [ %i5 + 0x43 ], %i0                      <== NOT EXECUTED
        echo (tty->termios.c_cc[VERASE], tty);                        
      } else if (c == '\t') {                                         
40005b04:	80 a0 60 09 	cmp  %g1, 9                                    
40005b08:	02 80 00 1e 	be  40005b80 <erase.part.2+0x110>              
40005b0c:	80 a0 a0 00 	cmp  %g2, 0                                    
          rtems_termios_puts ("\b", 1, tty);                          
          tty->column--;                                              
        }                                                             
      }                                                               
      else {                                                          
        if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {        
40005b10:	c4 06 a1 60 	ld  [ %i2 + 0x160 ], %g2                       
40005b14:	b8 00 60 01 	add  %g1, 1, %i4                               
40005b18:	c2 08 80 1c 	ldub  [ %g2 + %i4 ], %g1                       
40005b1c:	80 88 60 20 	btst  0x20, %g1                                
40005b20:	02 bf ff dc 	be  40005a90 <erase.part.2+0x20>               <== ALWAYS TAKEN
40005b24:	11 10 00 73 	sethi  %hi(0x4001cc00), %o0                    
40005b28:	80 88 e2 00 	btst  0x200, %g3                               <== NOT EXECUTED
40005b2c:	02 bf ff e4 	be  40005abc <erase.part.2+0x4c>               <== NOT EXECUTED
40005b30:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
          rtems_termios_puts ("\b \b", 3, tty);                       
40005b34:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40005b38:	92 10 20 03 	mov  3, %o1                                    <== NOT EXECUTED
40005b3c:	7f ff fe fc 	call  4000572c <rtems_termios_puts>            <== NOT EXECUTED
40005b40:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
          if (tty->column)                                            
40005b44:	c2 07 60 28 	ld  [ %i5 + 0x28 ], %g1                        <== NOT EXECUTED
40005b48:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40005b4c:	12 80 00 3b 	bne  40005c38 <erase.part.2+0x1c8>             <== NOT EXECUTED
40005b50:	11 10 00 73 	sethi  %hi(0x4001cc00), %o0                    <== NOT EXECUTED
            tty->column--;                                            
        }                                                             
        if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {       
40005b54:	c2 06 a1 60 	ld  [ %i2 + 0x160 ], %g1                       <== NOT EXECUTED
40005b58:	c2 08 40 1c 	ldub  [ %g1 + %i4 ], %g1                       <== NOT EXECUTED
40005b5c:	80 88 60 20 	btst  0x20, %g1                                <== NOT EXECUTED
40005b60:	22 bf ff cd 	be,a   40005a94 <erase.part.2+0x24>            <== NOT EXECUTED
40005b64:	90 12 23 60 	or  %o0, 0x360, %o0                            <== NOT EXECUTED
40005b68:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        <== NOT EXECUTED
40005b6c:	80 88 62 00 	btst  0x200, %g1                               <== NOT EXECUTED
40005b70:	32 bf ff c9 	bne,a   40005a94 <erase.part.2+0x24>           <== NOT EXECUTED
40005b74:	90 12 23 60 	or  %o0, 0x360, %o0                            <== NOT EXECUTED
          if (tty->column)                                            
            tty->column--;                                            
        }                                                             
      }                                                               
    }                                                                 
    if (!lineFlag)                                                    
40005b78:	10 bf ff d1 	b  40005abc <erase.part.2+0x4c>                <== NOT EXECUTED
40005b7c:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
        int i = 0;                                                    
                                                                      
        /*                                                            
         * Find the character before the tab                          
         */                                                           
        while (i != tty->ccount) {                                    
40005b80:	02 80 00 17 	be  40005bdc <erase.part.2+0x16c>              
40005b84:	f8 07 60 2c 	ld  [ %i5 + 0x2c ], %i4                        
          c = tty->cbuf[i++];                                         
          if (c == '\t') {                                            
            col = (col | 7) + 1;                                      
          } else if (iscntrl (c)) {                                   
40005b88:	da 06 a1 60 	ld  [ %i2 + 0x160 ], %o5                       
    if (tty->termios.c_lflag & ECHO) {                                
      if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {             
        echo (tty->termios.c_cc[VERASE], tty);                        
      } else if (c == '\t') {                                         
        int col = tty->read_start_column;                             
        int i = 0;                                                    
40005b8c:	82 10 20 00 	clr  %g1                                       
        while (i != tty->ccount) {                                    
          c = tty->cbuf[i++];                                         
          if (c == '\t') {                                            
            col = (col | 7) + 1;                                      
          } else if (iscntrl (c)) {                                   
            if (tty->termios.c_lflag & ECHOCTL)                       
40005b90:	10 80 00 07 	b  40005bac <erase.part.2+0x13c>               
40005b94:	98 08 e2 00 	and  %g3, 0x200, %o4                           
40005b98:	32 80 00 02 	bne,a   40005ba0 <erase.part.2+0x130>          <== NOT EXECUTED
40005b9c:	b8 07 20 02 	add  %i4, 2, %i4                               <== NOT EXECUTED
        int i = 0;                                                    
                                                                      
        /*                                                            
         * Find the character before the tab                          
         */                                                           
        while (i != tty->ccount) {                                    
40005ba0:	80 a0 80 01 	cmp  %g2, %g1                                  
40005ba4:	22 80 00 0f 	be,a   40005be0 <erase.part.2+0x170>           <== NEVER TAKEN
40005ba8:	c2 07 60 28 	ld  [ %i5 + 0x28 ], %g1                        <== NOT EXECUTED
          c = tty->cbuf[i++];                                         
40005bac:	c6 09 00 01 	ldub  [ %g4 + %g1 ], %g3                       
40005bb0:	82 00 60 01 	inc  %g1                                       
          if (c == '\t') {                                            
40005bb4:	80 a0 e0 09 	cmp  %g3, 9                                    
40005bb8:	02 80 00 1b 	be  40005c24 <erase.part.2+0x1b4>              
40005bbc:	9e 03 40 03 	add  %o5, %g3, %o7                             
            col = (col | 7) + 1;                                      
          } else if (iscntrl (c)) {                                   
40005bc0:	de 0b e0 01 	ldub  [ %o7 + 1 ], %o7                         
40005bc4:	80 8b e0 20 	btst  0x20, %o7                                
40005bc8:	12 bf ff f4 	bne  40005b98 <erase.part.2+0x128>             <== NEVER TAKEN
40005bcc:	80 a3 20 00 	cmp  %o4, 0                                    
        int i = 0;                                                    
                                                                      
        /*                                                            
         * Find the character before the tab                          
         */                                                           
        while (i != tty->ccount) {                                    
40005bd0:	80 a0 80 01 	cmp  %g2, %g1                                  
40005bd4:	12 bf ff f6 	bne  40005bac <erase.part.2+0x13c>             
40005bd8:	b8 07 20 01 	inc  %i4                                       
        }                                                             
                                                                      
        /*                                                            
         * Back up over the tab                                       
         */                                                           
        while (tty->column > col) {                                   
40005bdc:	c2 07 60 28 	ld  [ %i5 + 0x28 ], %g1                        
40005be0:	80 a0 40 1c 	cmp  %g1, %i4                                  
40005be4:	04 bf ff b6 	ble  40005abc <erase.part.2+0x4c>              <== NEVER TAKEN
40005be8:	80 a6 60 00 	cmp  %i1, 0                                    
          rtems_termios_puts ("\b", 1, tty);                          
40005bec:	90 10 00 1b 	mov  %i3, %o0                                  
40005bf0:	92 10 20 01 	mov  1, %o1                                    
40005bf4:	7f ff fe ce 	call  4000572c <rtems_termios_puts>            
40005bf8:	94 10 00 1d 	mov  %i5, %o2                                  
          tty->column--;                                              
40005bfc:	c2 07 60 28 	ld  [ %i5 + 0x28 ], %g1                        
40005c00:	82 00 7f ff 	add  %g1, -1, %g1                              
        }                                                             
                                                                      
        /*                                                            
         * Back up over the tab                                       
         */                                                           
        while (tty->column > col) {                                   
40005c04:	80 a0 40 1c 	cmp  %g1, %i4                                  
40005c08:	14 bf ff f9 	bg  40005bec <erase.part.2+0x17c>              
40005c0c:	c2 27 60 28 	st  %g1, [ %i5 + 0x28 ]                        
          if (tty->column)                                            
            tty->column--;                                            
        }                                                             
      }                                                               
    }                                                                 
    if (!lineFlag)                                                    
40005c10:	80 a6 60 00 	cmp  %i1, 0                                    
40005c14:	32 bf ff ad 	bne,a   40005ac8 <erase.part.2+0x58>           <== ALWAYS TAKEN
40005c18:	c4 07 60 20 	ld  [ %i5 + 0x20 ], %g2                        
40005c1c:	81 c7 e0 08 	ret                                            
40005c20:	81 e8 00 00 	restore                                        
         * Find the character before the tab                          
         */                                                           
        while (i != tty->ccount) {                                    
          c = tty->cbuf[i++];                                         
          if (c == '\t') {                                            
            col = (col | 7) + 1;                                      
40005c24:	b8 17 20 07 	or  %i4, 7, %i4                                
40005c28:	10 bf ff de 	b  40005ba0 <erase.part.2+0x130>               
40005c2c:	b8 07 20 01 	inc  %i4                                       
  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);                        
40005c30:	7f ff ff 6f 	call  400059ec <echo>                          <== NOT EXECUTED
40005c34:	93 e8 00 1d 	restore  %g0, %i5, %o1                         <== NOT EXECUTED
      }                                                               
      else {                                                          
        if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {        
          rtems_termios_puts ("\b \b", 3, tty);                       
          if (tty->column)                                            
            tty->column--;                                            
40005c38:	82 00 7f ff 	add  %g1, -1, %g1                              <== NOT EXECUTED
40005c3c:	10 bf ff c6 	b  40005b54 <erase.part.2+0xe4>                <== NOT EXECUTED
40005c40:	c2 27 60 28 	st  %g1, [ %i5 + 0x28 ]                        <== NOT EXECUTED
                                                                      

400040fc <eval_path_start>: size_t pathlen, int eval_flags, rtems_filesystem_global_location_t *const *global_root_ptr, rtems_filesystem_global_location_t *const *global_current_ptr ) {
400040fc:	9d e3 bf 98 	save  %sp, -104, %sp                           
  memset(ctx, 0, sizeof(*ctx));                                       
40004100:	92 10 20 00 	clr  %o1                                       
40004104:	90 10 00 18 	mov  %i0, %o0                                  
40004108:	40 00 30 1c 	call  40010178 <memset>                        
4000410c:	94 10 20 38 	mov  0x38, %o2                                 
                                                                      
  ctx->path = path;                                                   
40004110:	f2 26 00 00 	st  %i1, [ %i0 ]                               
  ctx->pathlen = pathlen;                                             
40004114:	f4 26 20 04 	st  %i2, [ %i0 + 4 ]                           
  rtems_filesystem_eval_path_context_t *ctx,                          
  rtems_filesystem_global_location_t *const *global_root_ptr,         
  rtems_filesystem_global_location_t *const *global_current_ptr       
)                                                                     
{                                                                     
  if (ctx->pathlen > 0) {                                             
40004118:	80 a6 a0 00 	cmp  %i2, 0                                    
4000411c:	02 80 00 21 	be  400041a0 <eval_path_start+0xa4>            
40004120:	f6 26 20 10 	st  %i3, [ %i0 + 0x10 ]                        
    char c = ctx->path [0];                                           
40004124:	f6 0e 40 00 	ldub  [ %i1 ], %i3                             
                                                                      
    ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr);
40004128:	40 00 01 a3 	call  400047b4 <rtems_filesystem_global_location_obtain>
4000412c:	90 10 00 1c 	mov  %i4, %o0                                  
  gid_t node_gid                                                      
);                                                                    
                                                                      
static inline bool rtems_filesystem_is_delimiter(char c)              
{                                                                     
  return c == '/' || c == '\\';                                       
40004130:	83 2e e0 18 	sll  %i3, 0x18, %g1                            
40004134:	83 38 60 18 	sra  %g1, 0x18, %g1                            
                                                                      
    if (rtems_filesystem_is_delimiter(c)) {                           
40004138:	80 a0 60 5c 	cmp  %g1, 0x5c                                 
4000413c:	12 80 00 32 	bne  40004204 <eval_path_start+0x108>          <== ALWAYS TAKEN
40004140:	d0 26 20 30 	st  %o0, [ %i0 + 0x30 ]                        
      ++ctx->path;                                                    
40004144:	c4 06 00 00 	ld  [ %i0 ], %g2                               <== NOT EXECUTED
      --ctx->pathlen;                                                 
40004148:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
    char c = ctx->path [0];                                           
                                                                      
    ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr);
                                                                      
    if (rtems_filesystem_is_delimiter(c)) {                           
      ++ctx->path;                                                    
4000414c:	84 00 a0 01 	inc  %g2                                       
      --ctx->pathlen;                                                 
40004150:	82 00 7f ff 	add  %g1, -1, %g1                              
    char c = ctx->path [0];                                           
                                                                      
    ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr);
                                                                      
    if (rtems_filesystem_is_delimiter(c)) {                           
      ++ctx->path;                                                    
40004154:	c4 26 00 00 	st  %g2, [ %i0 ]                               
      --ctx->pathlen;                                                 
40004158:	c2 26 20 04 	st  %g1, [ %i0 + 4 ]                           
      ctx->startloc = rtems_filesystem_global_location_obtain(        
4000415c:	40 00 01 96 	call  400047b4 <rtems_filesystem_global_location_obtain>
40004160:	90 06 20 30 	add  %i0, 0x30, %o0                            
40004164:	d0 26 20 34 	st  %o0, [ %i0 + 0x34 ]                        
40004168:	82 10 00 08 	mov  %o0, %g1                                  
                                                                      
static inline void rtems_filesystem_instance_lock(                    
  const rtems_filesystem_location_info_t *loc                         
)                                                                     
{                                                                     
  const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
4000416c:	d0 00 60 14 	ld  [ %g1 + 0x14 ], %o0                        
                                                                      
  (*mt_entry->ops->lock_h)( mt_entry );                               
40004170:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
40004174:	c2 00 40 00 	ld  [ %g1 ], %g1                               
40004178:	9f c0 40 00 	call  %g1                                      
4000417c:	ba 06 20 18 	add  %i0, 0x18, %i5                            
                                                                      
  set_startloc(ctx, global_root_ptr, global_current_ptr);             
                                                                      
  rtems_filesystem_instance_lock(&ctx->startloc->location);           
                                                                      
  rtems_filesystem_location_clone(                                    
40004180:	d2 06 20 34 	ld  [ %i0 + 0x34 ], %o1                        
40004184:	40 00 1e e1 	call  4000bd08 <rtems_filesystem_location_clone>
40004188:	90 10 00 1d 	mov  %i5, %o0                                  
    &ctx->currentloc,                                                 
    &ctx->startloc->location                                          
  );                                                                  
                                                                      
  rtems_filesystem_eval_path_continue(ctx);                           
4000418c:	90 10 00 18 	mov  %i0, %o0                                  
40004190:	7f ff ff be 	call  40004088 <rtems_filesystem_eval_path_continue>
40004194:	b0 10 00 1d 	mov  %i5, %i0                                  
                                                                      
  return &ctx->currentloc;                                            
}                                                                     
40004198:	81 c7 e0 08 	ret                                            
4000419c:	81 e8 00 00 	restore                                        
);                                                                    
                                                                      
static inline rtems_filesystem_global_location_t *                    
rtems_filesystem_global_location_obtain_null(void)                    
{                                                                     
  rtems_filesystem_global_location_t *global_loc = NULL;              
400041a0:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
                                                                      
  return rtems_filesystem_global_location_obtain( &global_loc );      
400041a4:	40 00 01 84 	call  400047b4 <rtems_filesystem_global_location_obtain>
400041a8:	90 07 bf fc 	add  %fp, -4, %o0                              
);                                                                    
                                                                      
static inline rtems_filesystem_global_location_t *                    
rtems_filesystem_global_location_obtain_null(void)                    
{                                                                     
  rtems_filesystem_global_location_t *global_loc = NULL;              
400041ac:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
      ctx->startloc = rtems_filesystem_global_location_obtain(        
        global_current_ptr                                            
      );                                                              
    }                                                                 
  } else {                                                            
    ctx->rootloc = rtems_filesystem_global_location_obtain_null();    
400041b0:	d0 26 20 30 	st  %o0, [ %i0 + 0x30 ]                        
                                                                      
  return rtems_filesystem_global_location_obtain( &global_loc );      
400041b4:	40 00 01 80 	call  400047b4 <rtems_filesystem_global_location_obtain>
400041b8:	90 07 bf fc 	add  %fp, -4, %o0                              
    ctx->startloc = rtems_filesystem_global_location_obtain_null();   
    errno = ENOENT;                                                   
400041bc:	40 00 2d 61 	call  4000f740 <__errno>                       
400041c0:	d0 26 20 34 	st  %o0, [ %i0 + 0x34 ]                        
400041c4:	c2 06 20 34 	ld  [ %i0 + 0x34 ], %g1                        
400041c8:	84 10 20 02 	mov  2, %g2                                    
400041cc:	c4 22 00 00 	st  %g2, [ %o0 ]                               
                                                                      
static inline void rtems_filesystem_instance_lock(                    
  const rtems_filesystem_location_info_t *loc                         
)                                                                     
{                                                                     
  const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
400041d0:	d0 00 60 14 	ld  [ %g1 + 0x14 ], %o0                        
                                                                      
  (*mt_entry->ops->lock_h)( mt_entry );                               
400041d4:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
400041d8:	c2 00 40 00 	ld  [ %g1 ], %g1                               
400041dc:	9f c0 40 00 	call  %g1                                      
400041e0:	ba 06 20 18 	add  %i0, 0x18, %i5                            
                                                                      
  set_startloc(ctx, global_root_ptr, global_current_ptr);             
                                                                      
  rtems_filesystem_instance_lock(&ctx->startloc->location);           
                                                                      
  rtems_filesystem_location_clone(                                    
400041e4:	d2 06 20 34 	ld  [ %i0 + 0x34 ], %o1                        
400041e8:	40 00 1e c8 	call  4000bd08 <rtems_filesystem_location_clone>
400041ec:	90 10 00 1d 	mov  %i5, %o0                                  
    &ctx->currentloc,                                                 
    &ctx->startloc->location                                          
  );                                                                  
                                                                      
  rtems_filesystem_eval_path_continue(ctx);                           
400041f0:	90 10 00 18 	mov  %i0, %o0                                  
400041f4:	7f ff ff a5 	call  40004088 <rtems_filesystem_eval_path_continue>
400041f8:	b0 10 00 1d 	mov  %i5, %i0                                  
                                                                      
  return &ctx->currentloc;                                            
}                                                                     
400041fc:	81 c7 e0 08 	ret                                            
40004200:	81 e8 00 00 	restore                                        
  if (ctx->pathlen > 0) {                                             
    char c = ctx->path [0];                                           
                                                                      
    ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr);
                                                                      
    if (rtems_filesystem_is_delimiter(c)) {                           
40004204:	80 a0 60 2f 	cmp  %g1, 0x2f                                 
40004208:	22 bf ff d0 	be,a   40004148 <eval_path_start+0x4c>         
4000420c:	c4 06 00 00 	ld  [ %i0 ], %g2                               
      --ctx->pathlen;                                                 
      ctx->startloc = rtems_filesystem_global_location_obtain(        
        &ctx->rootloc                                                 
      );                                                              
    } else {                                                          
      ctx->startloc = rtems_filesystem_global_location_obtain(        
40004210:	40 00 01 69 	call  400047b4 <rtems_filesystem_global_location_obtain>
40004214:	90 10 00 1d 	mov  %i5, %o0                                  
40004218:	d0 26 20 34 	st  %o0, [ %i0 + 0x34 ]                        
4000421c:	82 10 00 08 	mov  %o0, %g1                                  
                                                                      
static inline void rtems_filesystem_instance_lock(                    
  const rtems_filesystem_location_info_t *loc                         
)                                                                     
{                                                                     
  const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
40004220:	d0 00 60 14 	ld  [ %g1 + 0x14 ], %o0                        
                                                                      
  (*mt_entry->ops->lock_h)( mt_entry );                               
40004224:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
40004228:	c2 00 40 00 	ld  [ %g1 ], %g1                               
4000422c:	9f c0 40 00 	call  %g1                                      
40004230:	ba 06 20 18 	add  %i0, 0x18, %i5                            
                                                                      
  set_startloc(ctx, global_root_ptr, global_current_ptr);             
                                                                      
  rtems_filesystem_instance_lock(&ctx->startloc->location);           
                                                                      
  rtems_filesystem_location_clone(                                    
40004234:	d2 06 20 34 	ld  [ %i0 + 0x34 ], %o1                        
40004238:	40 00 1e b4 	call  4000bd08 <rtems_filesystem_location_clone>
4000423c:	90 10 00 1d 	mov  %i5, %o0                                  
    &ctx->currentloc,                                                 
    &ctx->startloc->location                                          
  );                                                                  
                                                                      
  rtems_filesystem_eval_path_continue(ctx);                           
40004240:	90 10 00 18 	mov  %i0, %o0                                  
40004244:	7f ff ff 91 	call  40004088 <rtems_filesystem_eval_path_continue>
40004248:	b0 10 00 1d 	mov  %i5, %i0                                  
                                                                      
  return &ctx->currentloc;                                            
}                                                                     
4000424c:	81 c7 e0 08 	ret                                            
40004250:	81 e8 00 00 	restore                                        
                                                                      

40013420 <fat_buf_access>: int fat_buf_access(fat_fs_info_t *fs_info, const uint32_t sec_num, const int op_type, uint8_t **sec_buf) {
40013420:	9d e3 bf a0 	save  %sp, -96, %sp                            
                                                                      
static inline uint32_t                                                
 fat_sector_num_to_block_num (const fat_fs_info_t *fs_info,           
                              const uint32_t sector_number)           
{                                                                     
  return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
40013424:	c2 0e 20 02 	ldub  [ %i0 + 2 ], %g1                         
40013428:	c4 0e 20 0c 	ldub  [ %i0 + 0xc ], %g2                       
                                                         sec_num);    
    uint32_t          blk_ofs = fat_sector_offset_to_block_offset (fs_info,
                                                                   sec_num,
                                                                   0);
                                                                      
    if (fs_info->c.state == FAT_CACHE_EMPTY || fs_info->c.blk_num != sec_num)
4001342c:	c6 0e 20 89 	ldub  [ %i0 + 0x89 ], %g3                      
40013430:	84 20 80 01 	sub  %g2, %g1, %g2                             
40013434:	80 a0 e0 00 	cmp  %g3, 0                                    
40013438:	bb 36 40 02 	srl  %i1, %g2, %i5                             
                                                                      
static inline uint32_t                                                
 fat_block_num_to_sector_num (const fat_fs_info_t *fs_info,           
                              const uint32_t block_number)            
{                                                                     
  return block_number << (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
4001343c:	85 2f 40 02 	sll  %i5, %g2, %g2                             
 fat_sector_offset_to_block_offset (const fat_fs_info_t *fs_info,     
                                    const uint32_t sector,            
                                    const uint32_t sector_offset)     
{                                                                     
  return sector_offset +                                              
           ((sector -                                                 
40013440:	84 26 40 02 	sub  %i1, %g2, %g2                             
40013444:	02 80 00 06 	be  4001345c <fat_buf_access+0x3c>             
40013448:	b9 28 80 01 	sll  %g2, %g1, %i4                             
4001344c:	c2 06 20 84 	ld  [ %i0 + 0x84 ], %g1                        
40013450:	80 a0 40 19 	cmp  %g1, %i1                                  
40013454:	22 80 00 12 	be,a   4001349c <fat_buf_access+0x7c>          
40013458:	c2 06 20 8c 	ld  [ %i0 + 0x8c ], %g1                        
    {                                                                 
        fat_buf_release(fs_info);                                     
4001345c:	7f ff ff 7a 	call  40013244 <fat_buf_release>               
40013460:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
        if (op_type == FAT_OP_TYPE_READ)                              
            sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
40013464:	d0 06 20 64 	ld  [ %i0 + 0x64 ], %o0                        
40013468:	92 10 00 1d 	mov  %i5, %o1                                  
                                                                      
    if (fs_info->c.state == FAT_CACHE_EMPTY || fs_info->c.blk_num != sec_num)
    {                                                                 
        fat_buf_release(fs_info);                                     
                                                                      
        if (op_type == FAT_OP_TYPE_READ)                              
4001346c:	80 a6 a0 01 	cmp  %i2, 1                                    
40013470:	02 80 00 10 	be  400134b0 <fat_buf_access+0x90>             
40013474:	94 06 20 8c 	add  %i0, 0x8c, %o2                            
            sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
        else                                                          
            sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &fs_info->c.buf);
40013478:	7f ff f6 c9 	call  40010f9c <rtems_bdbuf_get>               
4001347c:	01 00 00 00 	nop                                            
        if (sc != RTEMS_SUCCESSFUL)                                   
40013480:	80 a2 20 00 	cmp  %o0, 0                                    
40013484:	12 80 00 0f 	bne  400134c0 <fat_buf_access+0xa0>            <== NEVER TAKEN
40013488:	82 10 20 01 	mov  1, %g1                                    
            rtems_set_errno_and_return_minus_one(EIO);                
        fs_info->c.blk_num = sec_num;                                 
4001348c:	f2 26 20 84 	st  %i1, [ %i0 + 0x84 ]                        
        fs_info->c.modified = 0;                                      
40013490:	c0 2e 20 88 	clrb  [ %i0 + 0x88 ]                           
        fs_info->c.state = FAT_CACHE_ACTUAL;                          
40013494:	c2 2e 20 89 	stb  %g1, [ %i0 + 0x89 ]                       
    }                                                                 
    *sec_buf = &fs_info->c.buf->buffer[blk_ofs];                      
40013498:	c2 06 20 8c 	ld  [ %i0 + 0x8c ], %g1                        
4001349c:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        
400134a0:	b8 00 40 1c 	add  %g1, %i4, %i4                             
400134a4:	f8 26 c0 00 	st  %i4, [ %i3 ]                               
    return RC_OK;                                                     
}                                                                     
400134a8:	81 c7 e0 08 	ret                                            
400134ac:	91 e8 20 00 	restore  %g0, 0, %o0                           
    if (fs_info->c.state == FAT_CACHE_EMPTY || fs_info->c.blk_num != sec_num)
    {                                                                 
        fat_buf_release(fs_info);                                     
                                                                      
        if (op_type == FAT_OP_TYPE_READ)                              
            sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
400134b0:	7f ff f6 fb 	call  4001109c <rtems_bdbuf_read>              
400134b4:	01 00 00 00 	nop                                            
        else                                                          
            sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &fs_info->c.buf);
        if (sc != RTEMS_SUCCESSFUL)                                   
400134b8:	10 bf ff f3 	b  40013484 <fat_buf_access+0x64>              
400134bc:	80 a2 20 00 	cmp  %o0, 0                                    
            rtems_set_errno_and_return_minus_one(EIO);                
400134c0:	40 00 23 b4 	call  4001c390 <__errno>                       <== NOT EXECUTED
400134c4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
400134c8:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
400134cc:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
400134d0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400134d4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40013244 <fat_buf_release>: return RC_OK; } int fat_buf_release(fat_fs_info_t *fs_info) {
40013244:	9d e3 bf 98 	save  %sp, -104, %sp                           
    rtems_status_code sc = RTEMS_SUCCESSFUL;                          
                                                                      
    if (fs_info->c.state == FAT_CACHE_EMPTY)                          
40013248:	c2 0e 20 89 	ldub  [ %i0 + 0x89 ], %g1                      
    return RC_OK;                                                     
}                                                                     
                                                                      
int                                                                   
fat_buf_release(fat_fs_info_t *fs_info)                               
{                                                                     
4001324c:	ba 10 00 18 	mov  %i0, %i5                                  
    rtems_status_code sc = RTEMS_SUCCESSFUL;                          
                                                                      
    if (fs_info->c.state == FAT_CACHE_EMPTY)                          
40013250:	80 a0 60 00 	cmp  %g1, 0                                    
40013254:	02 80 00 6b 	be  40013400 <fat_buf_release+0x1bc>           
40013258:	b0 10 20 00 	clr  %i0                                       
        return RC_OK;                                                 
                                                                      
    if (fs_info->c.modified)                                          
4001325c:	c2 0f 60 88 	ldub  [ %i5 + 0x88 ], %g1                      
40013260:	80 a0 60 00 	cmp  %g1, 0                                    
40013264:	02 80 00 47 	be  40013380 <fat_buf_release+0x13c>           
40013268:	01 00 00 00 	nop                                            
    {                                                                 
        uint32_t sec_num = fs_info->c.blk_num;                        
4001326c:	c2 07 60 84 	ld  [ %i5 + 0x84 ], %g1                        
        bool     sec_of_fat = ((sec_num >= fs_info->vol.fat_loc) &&   
40013270:	c4 17 60 18 	lduh  [ %i5 + 0x18 ], %g2                      
40013274:	80 a0 40 02 	cmp  %g1, %g2                                  
40013278:	0a 80 00 06 	bcs  40013290 <fat_buf_release+0x4c>           
4001327c:	b8 10 20 00 	clr  %i4                                       
40013280:	c4 07 60 20 	ld  [ %i5 + 0x20 ], %g2                        
40013284:	80 a0 40 02 	cmp  %g1, %g2                                  
40013288:	2a 80 00 46 	bcs,a   400133a0 <fat_buf_release+0x15c>       
4001328c:	c4 0f 60 54 	ldub  [ %i5 + 0x54 ], %g2                      
        if (sec_of_fat && !fs_info->vol.mirror)                       
            memcpy(fs_info->sec_buf,                                  
                   fs_info->c.buf->buffer + blk_ofs,                  
                   fs_info->vol.bps);                                 
                                                                      
        sc = rtems_bdbuf_release_modified(fs_info->c.buf);            
40013290:	7f ff f8 40 	call  40011390 <rtems_bdbuf_release_modified>  
40013294:	d0 07 60 8c 	ld  [ %i5 + 0x8c ], %o0                        
        if (sc != RTEMS_SUCCESSFUL)                                   
40013298:	80 a2 20 00 	cmp  %o0, 0                                    
4001329c:	12 80 00 5b 	bne  40013408 <fat_buf_release+0x1c4>          <== NEVER TAKEN
400132a0:	80 8f 20 ff 	btst  0xff, %i4                                
            rtems_set_errno_and_return_minus_one(EIO);                
        fs_info->c.modified = 0;                                      
                                                                      
        if (sec_of_fat && !fs_info->vol.mirror)                       
400132a4:	02 80 00 3c 	be  40013394 <fat_buf_release+0x150>           
400132a8:	c0 2f 60 88 	clrb  [ %i5 + 0x88 ]                           
400132ac:	c2 0f 60 54 	ldub  [ %i5 + 0x54 ], %g1                      
400132b0:	80 a0 60 00 	cmp  %g1, 0                                    
400132b4:	32 80 00 39 	bne,a   40013398 <fat_buf_release+0x154>       <== NEVER TAKEN
400132b8:	c0 2f 60 89 	clrb  [ %i5 + 0x89 ]                           <== NOT EXECUTED
        {                                                             
            uint8_t i;                                                
                                                                      
            for (i = 1; i < fs_info->vol.fats; i++)                   
400132bc:	c2 0f 60 0d 	ldub  [ %i5 + 0xd ], %g1                       
400132c0:	80 a0 60 01 	cmp  %g1, 1                                    
400132c4:	08 80 00 34 	bleu  40013394 <fat_buf_release+0x150>         <== NEVER TAKEN
400132c8:	b6 10 20 01 	mov  1, %i3                                    
400132cc:	10 80 00 16 	b  40013324 <fat_buf_release+0xe0>             
400132d0:	90 10 20 01 	mov  1, %o0                                    
                {                                                     
                    sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &bd);  
                }                                                     
                else                                                  
                {                                                     
                    sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &bd); 
400132d4:	7f ff f7 72 	call  4001109c <rtems_bdbuf_read>              
400132d8:	94 07 bf fc 	add  %fp, -4, %o2                              
                }                                                     
                if ( sc != RTEMS_SUCCESSFUL)                          
400132dc:	80 a2 20 00 	cmp  %o0, 0                                    
400132e0:	12 80 00 44 	bne  400133f0 <fat_buf_release+0x1ac>          <== NEVER TAKEN
400132e4:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
                    rtems_set_errno_and_return_minus_one(ENOMEM);     
                memcpy(bd->buffer + blk_ofs, fs_info->sec_buf, fs_info->vol.bps);
400132e8:	d2 07 60 90 	ld  [ %i5 + 0x90 ], %o1                        
400132ec:	d0 00 60 1c 	ld  [ %g1 + 0x1c ], %o0                        
400132f0:	d4 17 40 00 	lduh  [ %i5 ], %o2                             
400132f4:	40 00 26 cc 	call  4001ce24 <memcpy>                        
400132f8:	90 02 00 1c 	add  %o0, %i4, %o0                             
                sc = rtems_bdbuf_release_modified(bd);                
400132fc:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
40013300:	7f ff f8 24 	call  40011390 <rtems_bdbuf_release_modified>  
40013304:	b6 06 e0 01 	inc  %i3                                       
                if ( sc != RTEMS_SUCCESSFUL)                          
40013308:	80 a2 20 00 	cmp  %o0, 0                                    
4001330c:	12 80 00 39 	bne  400133f0 <fat_buf_release+0x1ac>          <== NEVER TAKEN
40013310:	90 0e e0 ff 	and  %i3, 0xff, %o0                            
                                                                      
        if (sec_of_fat && !fs_info->vol.mirror)                       
        {                                                             
            uint8_t i;                                                
                                                                      
            for (i = 1; i < fs_info->vol.fats; i++)                   
40013314:	c2 0f 60 0d 	ldub  [ %i5 + 0xd ], %g1                       
40013318:	80 a2 00 01 	cmp  %o0, %g1                                  
4001331c:	3a 80 00 1f 	bcc,a   40013398 <fat_buf_release+0x154>       <== ALWAYS TAKEN
40013320:	c0 2f 60 89 	clrb  [ %i5 + 0x89 ]                           
            {                                                         
                rtems_bdbuf_buffer *bd;                               
                                                                      
                sec_num = fs_info->c.blk_num + fs_info->vol.fat_length * i,
40013324:	7f ff bc 9a 	call  4000258c <.umul>                         
40013328:	d2 07 60 1c 	ld  [ %i5 + 0x1c ], %o1                        
                                                                      
static inline uint32_t                                                
 fat_sector_num_to_block_num (const fat_fs_info_t *fs_info,           
                              const uint32_t sector_number)           
{                                                                     
  return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
4001332c:	c2 0f 60 02 	ldub  [ %i5 + 2 ], %g1                         
40013330:	c6 07 60 84 	ld  [ %i5 + 0x84 ], %g3                        
40013334:	c4 0f 60 0c 	ldub  [ %i5 + 0xc ], %g2                       
40013338:	90 02 00 03 	add  %o0, %g3, %o0                             
4001333c:	84 20 80 01 	sub  %g2, %g1, %g2                             
40013340:	93 32 00 02 	srl  %o0, %g2, %o1                             
                                                                      
static inline uint32_t                                                
 fat_block_num_to_sector_num (const fat_fs_info_t *fs_info,           
                              const uint32_t block_number)            
{                                                                     
  return block_number << (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
40013344:	85 2a 40 02 	sll  %o1, %g2, %g2                             
 fat_sector_offset_to_block_offset (const fat_fs_info_t *fs_info,     
                                    const uint32_t sector,            
                                    const uint32_t sector_offset)     
{                                                                     
  return sector_offset +                                              
           ((sector -                                                 
40013348:	90 22 00 02 	sub  %o0, %g2, %o0                             
              fat_block_num_to_sector_num (fs_info,                   
                  fat_sector_num_to_block_num (fs_info, sector)))     
            << fs_info->vol.sec_log2);                                
4001334c:	b9 2a 00 01 	sll  %o0, %g1, %i4                             
                blk = fat_sector_num_to_block_num(fs_info, sec_num);  
                blk_ofs = fat_sector_offset_to_block_offset(fs_info,  
                                                            sec_num,  
                                                            0);       
                                                                      
                if (blk_ofs == 0                                      
40013350:	80 a7 20 00 	cmp  %i4, 0                                    
40013354:	12 bf ff e0 	bne  400132d4 <fat_buf_release+0x90>           
40013358:	d0 07 60 64 	ld  [ %i5 + 0x64 ], %o0                        
                    && fs_info->vol.bps == fs_info->vol.bytes_per_block)
4001335c:	c4 17 40 00 	lduh  [ %i5 ], %g2                             
40013360:	c2 17 60 0a 	lduh  [ %i5 + 0xa ], %g1                       
40013364:	80 a0 80 01 	cmp  %g2, %g1                                  
40013368:	12 bf ff db 	bne  400132d4 <fat_buf_release+0x90>           
4001336c:	01 00 00 00 	nop                                            
                {                                                     
                    sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &bd);  
40013370:	7f ff f7 0b 	call  40010f9c <rtems_bdbuf_get>               
40013374:	94 07 bf fc 	add  %fp, -4, %o2                              
                }                                                     
                else                                                  
                {                                                     
                    sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &bd); 
                }                                                     
                if ( sc != RTEMS_SUCCESSFUL)                          
40013378:	10 bf ff da 	b  400132e0 <fat_buf_release+0x9c>             
4001337c:	80 a2 20 00 	cmp  %o0, 0                                    
            }                                                         
        }                                                             
    }                                                                 
    else                                                              
    {                                                                 
        sc = rtems_bdbuf_release(fs_info->c.buf);                     
40013380:	7f ff f7 cc 	call  400112b0 <rtems_bdbuf_release>           
40013384:	d0 07 60 8c 	ld  [ %i5 + 0x8c ], %o0                        
        if (sc != RTEMS_SUCCESSFUL)                                   
40013388:	80 a2 20 00 	cmp  %o0, 0                                    
4001338c:	12 80 00 1f 	bne  40013408 <fat_buf_release+0x1c4>          <== NEVER TAKEN
40013390:	01 00 00 00 	nop                                            
            rtems_set_errno_and_return_minus_one(EIO);                
    }                                                                 
    fs_info->c.state = FAT_CACHE_EMPTY;                               
40013394:	c0 2f 60 89 	clrb  [ %i5 + 0x89 ]                           
    return RC_OK;                                                     
40013398:	81 c7 e0 08 	ret                                            
4001339c:	91 e8 20 00 	restore  %g0, 0, %o0                           
    uint32_t                              ino                         
    )                                                                 
{                                                                     
                                                                      
    return (ino >= fs_info->uino_base);                               
}                                                                     
400133a0:	c8 0f 60 02 	ldub  [ %i5 + 2 ], %g4                         
400133a4:	c6 0f 60 0c 	ldub  [ %i5 + 0xc ], %g3                       
        uint32_t blk = fat_sector_num_to_block_num(fs_info, sec_num); 
        uint32_t blk_ofs = fat_sector_offset_to_block_offset(fs_info, 
                                                             sec_num, 
                                                             0);      
                                                                      
        if (sec_of_fat && !fs_info->vol.mirror)                       
400133a8:	80 a0 a0 00 	cmp  %g2, 0                                    
400133ac:	12 bf ff b9 	bne  40013290 <fat_buf_release+0x4c>           <== NEVER TAKEN
400133b0:	b8 10 20 01 	mov  1, %i4                                    
            memcpy(fs_info->sec_buf,                                  
                   fs_info->c.buf->buffer + blk_ofs,                  
400133b4:	c4 07 60 8c 	ld  [ %i5 + 0x8c ], %g2                        
        uint32_t blk_ofs = fat_sector_offset_to_block_offset(fs_info, 
                                                             sec_num, 
                                                             0);      
                                                                      
        if (sec_of_fat && !fs_info->vol.mirror)                       
            memcpy(fs_info->sec_buf,                                  
400133b8:	d0 07 60 90 	ld  [ %i5 + 0x90 ], %o0                        
400133bc:	d2 00 a0 1c 	ld  [ %g2 + 0x1c ], %o1                        
400133c0:	d4 17 40 00 	lduh  [ %i5 ], %o2                             
                                                                      
static inline uint32_t                                                
 fat_sector_num_to_block_num (const fat_fs_info_t *fs_info,           
                              const uint32_t sector_number)           
{                                                                     
  return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
400133c4:	84 09 20 ff 	and  %g4, 0xff, %g2                            
400133c8:	86 08 e0 ff 	and  %g3, 0xff, %g3                            
400133cc:	86 20 c0 02 	sub  %g3, %g2, %g3                             
400133d0:	89 30 40 03 	srl  %g1, %g3, %g4                             
                                                                      
static inline uint32_t                                                
 fat_block_num_to_sector_num (const fat_fs_info_t *fs_info,           
                              const uint32_t block_number)            
{                                                                     
  return block_number << (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
400133d4:	87 29 00 03 	sll  %g4, %g3, %g3                             
 fat_sector_offset_to_block_offset (const fat_fs_info_t *fs_info,     
                                    const uint32_t sector,            
                                    const uint32_t sector_offset)     
{                                                                     
  return sector_offset +                                              
           ((sector -                                                 
400133d8:	82 20 40 03 	sub  %g1, %g3, %g1                             
              fat_block_num_to_sector_num (fs_info,                   
                  fat_sector_num_to_block_num (fs_info, sector)))     
            << fs_info->vol.sec_log2);                                
400133dc:	85 28 40 02 	sll  %g1, %g2, %g2                             
        return RC_OK;                                                 
                                                                      
    if (fs_info->c.modified)                                          
    {                                                                 
        uint32_t sec_num = fs_info->c.blk_num;                        
        bool     sec_of_fat = ((sec_num >= fs_info->vol.fat_loc) &&   
400133e0:	b8 10 20 01 	mov  1, %i4                                    
        uint32_t blk_ofs = fat_sector_offset_to_block_offset(fs_info, 
                                                             sec_num, 
                                                             0);      
                                                                      
        if (sec_of_fat && !fs_info->vol.mirror)                       
            memcpy(fs_info->sec_buf,                                  
400133e4:	40 00 26 90 	call  4001ce24 <memcpy>                        
400133e8:	92 02 40 02 	add  %o1, %g2, %o1                             
400133ec:	30 bf ff a9 	b,a   40013290 <fat_buf_release+0x4c>          
                if ( sc != RTEMS_SUCCESSFUL)                          
                    rtems_set_errno_and_return_minus_one(ENOMEM);     
                memcpy(bd->buffer + blk_ofs, fs_info->sec_buf, fs_info->vol.bps);
                sc = rtems_bdbuf_release_modified(bd);                
                if ( sc != RTEMS_SUCCESSFUL)                          
                    rtems_set_errno_and_return_minus_one(ENOMEM);     
400133f0:	40 00 23 e8 	call  4001c390 <__errno>                       <== NOT EXECUTED
400133f4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
400133f8:	82 10 20 0c 	mov  0xc, %g1                                  <== NOT EXECUTED
400133fc:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
40013400:	81 c7 e0 08 	ret                                            
40013404:	81 e8 00 00 	restore                                        
    }                                                                 
    else                                                              
    {                                                                 
        sc = rtems_bdbuf_release(fs_info->c.buf);                     
        if (sc != RTEMS_SUCCESSFUL)                                   
            rtems_set_errno_and_return_minus_one(EIO);                
40013408:	40 00 23 e2 	call  4001c390 <__errno>                       <== NOT EXECUTED
4001340c:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40013410:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
40013414:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
40013418:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001341c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40013608 <fat_cluster_set>: fat_fs_info_t *fs_info, const uint32_t start_cln, const uint32_t offset, const uint32_t count, const uint8_t pattern) {
40013608:	9d e3 bf 98 	save  %sp, -104, %sp                           
  ssize_t             rc               = RC_OK;                       
  uint32_t            bytes_to_write   = MIN(count, (fs_info->vol.bpc - offset));
4001360c:	c2 16 20 06 	lduh  [ %i0 + 6 ], %g1                         
40013610:	82 20 40 1a 	sub  %g1, %i2, %g1                             
40013614:	80 a6 c0 01 	cmp  %i3, %g1                                  
40013618:	38 80 00 02 	bgu,a   40013620 <fat_cluster_set+0x18>        <== NEVER TAKEN
4001361c:	b6 10 00 01 	mov  %g1, %i3                                  <== NOT EXECUTED
fat_cluster_num_to_block_num (const fat_fs_info_t *fs_info,           
                              uint32_t             cln)               
{                                                                     
    uint32_t blk;                                                     
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
40013620:	80 a6 60 00 	cmp  %i1, 0                                    
40013624:	32 80 00 06 	bne,a   4001363c <fat_cluster_set+0x34>        <== ALWAYS TAKEN
40013628:	c2 0e 20 0c 	ldub  [ %i0 + 0xc ], %g1                       
4001362c:	c2 0e 20 0e 	ldub  [ %i0 + 0xe ], %g1                       <== NOT EXECUTED
40013630:	80 88 60 03 	btst  3, %g1                                   <== NOT EXECUTED
40013634:	12 80 00 50 	bne  40013774 <fat_cluster_set+0x16c>          <== NOT EXECUTED
40013638:	c2 0e 20 0c 	ldub  [ %i0 + 0xc ], %g1                       <== NOT EXECUTED
                                                                      
static inline uint32_t                                                
 fat_sector_num_to_block_num (const fat_fs_info_t *fs_info,           
                              const uint32_t sector_number)           
{                                                                     
  return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
4001363c:	e0 0e 20 02 	ldub  [ %i0 + 2 ], %l0                         
40013640:	c6 06 20 34 	ld  [ %i0 + 0x34 ], %g3                        
        blk = fat_sector_num_to_block_num(fs_info, fs_info->vol.rdir_loc);
    else                                                              
    {                                                                 
        cln -= FAT_RSRVD_CLN;                                         
        blk = cln << (fs_info->vol.bpc_log2 - fs_info->vol.bytes_per_block_log2);
40013644:	c4 0e 20 08 	ldub  [ %i0 + 8 ], %g2                         
40013648:	a0 20 40 10 	sub  %g1, %l0, %l0                             
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
        blk = fat_sector_num_to_block_num(fs_info, fs_info->vol.rdir_loc);
    else                                                              
    {                                                                 
        cln -= FAT_RSRVD_CLN;                                         
4001364c:	b2 06 7f fe 	add  %i1, -2, %i1                              
40013650:	a1 30 c0 10 	srl  %g3, %l0, %l0                             
        blk = cln << (fs_info->vol.bpc_log2 - fs_info->vol.bytes_per_block_log2);
40013654:	84 20 80 01 	sub  %g2, %g1, %g2                             
40013658:	b3 2e 40 02 	sll  %i1, %g2, %i1                             
        blk += fat_sector_num_to_block_num(fs_info, fs_info->vol.data_fsec);
4001365c:	a0 04 00 19 	add  %l0, %i1, %l0                             
     const uint8_t                         pattern)                   
{                                                                     
  ssize_t             rc               = RC_OK;                       
  uint32_t            bytes_to_write   = MIN(count, (fs_info->vol.bpc - offset));
  uint32_t            cur_blk          = fat_cluster_num_to_block_num(fs_info, start_cln);
  uint32_t            blocks_in_offset = offset >> fs_info->vol.bytes_per_block_log2;
40013660:	85 36 80 01 	srl  %i2, %g1, %g2                             
  uint32_t            ofs_blk          = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
40013664:	83 28 80 01 	sll  %g2, %g1, %g1                             
  ssize_t             bytes_written    = 0;                           
40013668:	a2 10 20 00 	clr  %l1                                       
{                                                                     
  ssize_t             rc               = RC_OK;                       
  uint32_t            bytes_to_write   = MIN(count, (fs_info->vol.bpc - offset));
  uint32_t            cur_blk          = fat_cluster_num_to_block_num(fs_info, start_cln);
  uint32_t            blocks_in_offset = offset >> fs_info->vol.bytes_per_block_log2;
  uint32_t            ofs_blk          = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
4001366c:	b4 26 80 01 	sub  %i2, %g1, %i2                             
  ssize_t             bytes_written    = 0;                           
  ssize_t             ret;                                            
                                                                      
  cur_blk += blocks_in_offset;                                        
40013670:	a0 00 80 10 	add  %g2, %l0, %l0                             
     const uint32_t                        start_cln,                 
     const uint32_t                        offset,                    
     const uint32_t                        count,                     
     const uint8_t                         pattern)                   
{                                                                     
  ssize_t             rc               = RC_OK;                       
40013674:	82 10 20 00 	clr  %g1                                       
  ssize_t             bytes_written    = 0;                           
  ssize_t             ret;                                            
                                                                      
  cur_blk += blocks_in_offset;                                        
                                                                      
  while (   (RC_OK == rc)                                             
40013678:	80 a6 e0 00 	cmp  %i3, 0                                    
4001367c:	02 80 00 25 	be  40013710 <fat_cluster_set+0x108>           <== NEVER TAKEN
40013680:	a4 10 20 01 	mov  1, %l2                                    
40013684:	80 a0 60 00 	cmp  %g1, 0                                    
40013688:	32 80 00 39 	bne,a   4001376c <fat_cluster_set+0x164>       <== NEVER TAKEN
4001368c:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
         && (0 < bytes_to_write))                                     
  {                                                                   
    uint32_t c = MIN(bytes_to_write, (fs_info->vol.bytes_per_block - ofs_blk));
40013690:	c4 16 20 0a 	lduh  [ %i0 + 0xa ], %g2                       
40013694:	82 20 80 1a 	sub  %g2, %i2, %g1                             
40013698:	80 a0 40 1b 	cmp  %g1, %i3                                  
4001369c:	08 80 00 03 	bleu  400136a8 <fat_cluster_set+0xa0>          <== ALWAYS TAKEN
400136a0:	ba 10 00 01 	mov  %g1, %i5                                  
400136a4:	ba 10 00 1b 	mov  %i3, %i5                                  <== NOT EXECUTED
     const uint32_t                        offset,                    
     const uint32_t                        count,                     
     const uint8_t                         pattern)                   
{                                                                     
    int                 rc             = RC_OK;                       
    uint32_t            bytes_to_write = MIN(count, (fs_info->vol.bytes_per_block - offset));
400136a8:	80 a7 40 01 	cmp  %i5, %g1                                  
400136ac:	08 80 00 03 	bleu  400136b8 <fat_cluster_set+0xb0>          <== ALWAYS TAKEN
400136b0:	b2 10 00 1d 	mov  %i5, %i1                                  
400136b4:	b2 10 00 01 	mov  %g1, %i1                                  <== NOT EXECUTED
    uint32_t                              ino                         
    )                                                                 
{                                                                     
                                                                      
    return (ino >= fs_info->uino_base);                               
}                                                                     
400136b8:	c2 0e 20 02 	ldub  [ %i0 + 2 ], %g1                         
    int                 rc             = RC_OK;                       
    uint32_t            bytes_to_write = MIN(count, (fs_info->vol.bytes_per_block - offset));
    uint8_t            *blk_buf;                                      
    uint32_t            sec_num        = fat_block_num_to_sector_num(fs_info, start_blk);
                                                                      
    if (0 < bytes_to_write)                                           
400136bc:	80 a6 60 00 	cmp  %i1, 0                                    
400136c0:	02 80 00 24 	be  40013750 <fat_cluster_set+0x148>           <== NEVER TAKEN
400136c4:	d2 0e 20 0c 	ldub  [ %i0 + 0xc ], %o1                       
                                                                      
static inline uint32_t                                                
 fat_block_num_to_sector_num (const fat_fs_info_t *fs_info,           
                              const uint32_t block_number)            
{                                                                     
  return block_number << (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
400136c8:	92 22 40 01 	sub  %o1, %g1, %o1                             
    {                                                                 
        if (bytes_to_write == fs_info->vol.bytes_per_block)           
        {                                                             
            rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &blk_buf);
400136cc:	90 10 00 18 	mov  %i0, %o0                                  
    uint8_t            *blk_buf;                                      
    uint32_t            sec_num        = fat_block_num_to_sector_num(fs_info, start_blk);
                                                                      
    if (0 < bytes_to_write)                                           
    {                                                                 
        if (bytes_to_write == fs_info->vol.bytes_per_block)           
400136d0:	80 a0 80 19 	cmp  %g2, %i1                                  
400136d4:	02 80 00 21 	be  40013758 <fat_cluster_set+0x150>           
400136d8:	93 2c 00 09 	sll  %l0, %o1, %o1                             
        {                                                             
            rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &blk_buf);
        }                                                             
        else                                                          
            rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &blk_buf);
400136dc:	94 10 20 01 	mov  1, %o2                                    
400136e0:	7f ff ff 50 	call  40013420 <fat_buf_access>                
400136e4:	96 07 bf fc 	add  %fp, -4, %o3                              
                                                                      
        if (RC_OK == rc)                                              
400136e8:	80 a2 20 00 	cmp  %o0, 0                                    
400136ec:	22 80 00 14 	be,a   4001373c <fat_cluster_set+0x134>        <== ALWAYS TAKEN
400136f0:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
        fs_info,                                                      
        cur_blk,                                                      
        ofs_blk,                                                      
        c,                                                            
        pattern);                                                     
    if (c != ret)                                                     
400136f4:	80 a2 00 1d 	cmp  %o0, %i5                                  
400136f8:	02 80 00 0b 	be  40013724 <fat_cluster_set+0x11c>           <== ALWAYS TAKEN
400136fc:	82 10 3f ff 	mov  -1, %g1                                   
40013700:	b4 10 20 00 	clr  %i2                                       <== NOT EXECUTED
  ssize_t             bytes_written    = 0;                           
  ssize_t             ret;                                            
                                                                      
  cur_blk += blocks_in_offset;                                        
                                                                      
  while (   (RC_OK == rc)                                             
40013704:	80 a6 e0 00 	cmp  %i3, 0                                    
40013708:	12 bf ff e0 	bne  40013688 <fat_cluster_set+0x80>           <== NEVER TAKEN
4001370c:	80 a0 60 00 	cmp  %g1, 0                                    
        bytes_written  += ret;                                        
        ++cur_blk;                                                    
    }                                                                 
    ofs_blk = 0;                                                      
  }                                                                   
  if (RC_OK != rc)                                                    
40013710:	80 a0 60 00 	cmp  %g1, 0                                    
40013714:	12 80 00 16 	bne  4001376c <fat_cluster_set+0x164>          <== NEVER TAKEN
40013718:	b0 10 3f ff 	mov  -1, %i0                                   
4001371c:	81 c7 e0 08 	ret                                            
40013720:	91 e8 00 11 	restore  %g0, %l1, %o0                         
        pattern);                                                     
    if (c != ret)                                                     
      rc = -1;                                                        
    else                                                              
    {                                                                 
        bytes_to_write -= ret;                                        
40013724:	b6 26 c0 08 	sub  %i3, %o0, %i3                             
        bytes_written  += ret;                                        
40013728:	a2 04 40 08 	add  %l1, %o0, %l1                             
        ++cur_blk;                                                    
4001372c:	a0 04 20 01 	inc  %l0                                       
40013730:	82 10 20 00 	clr  %g1                                       
40013734:	10 bf ff f4 	b  40013704 <fat_cluster_set+0xfc>             
40013738:	b4 10 20 00 	clr  %i2                                       
        else                                                          
            rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &blk_buf);
                                                                      
        if (RC_OK == rc)                                              
        {                                                             
            memset(blk_buf + offset, pattern, bytes_to_write);        
4001373c:	92 10 00 1c 	mov  %i4, %o1                                  
40013740:	90 02 00 1a 	add  %o0, %i2, %o0                             
40013744:	40 00 25 f5 	call  4001cf18 <memset>                        
40013748:	94 10 00 19 	mov  %i1, %o2                                  
}                                                                     
                                                                      
static inline void                                                    
fat_buf_mark_modified(fat_fs_info_t *fs_info)                         
{                                                                     
    fs_info->c.modified = true;                                       
4001374c:	e4 2e 20 88 	stb  %l2, [ %i0 + 0x88 ]                       
        }                                                             
    }                                                                 
    if (RC_OK != rc)                                                  
        return rc;                                                    
    else                                                              
        return bytes_to_write;                                        
40013750:	10 bf ff e9 	b  400136f4 <fat_cluster_set+0xec>             
40013754:	90 10 00 19 	mov  %i1, %o0                                  
                                                                      
    if (0 < bytes_to_write)                                           
    {                                                                 
        if (bytes_to_write == fs_info->vol.bytes_per_block)           
        {                                                             
            rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &blk_buf);
40013758:	94 10 20 02 	mov  2, %o2                                    
4001375c:	7f ff ff 31 	call  40013420 <fat_buf_access>                
40013760:	96 07 bf fc 	add  %fp, -4, %o3                              
        }                                                             
        else                                                          
            rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &blk_buf);
                                                                      
        if (RC_OK == rc)                                              
40013764:	10 bf ff e2 	b  400136ec <fat_cluster_set+0xe4>             
40013768:	80 a2 20 00 	cmp  %o0, 0                                    
  }                                                                   
  if (RC_OK != rc)                                                    
    return rc;                                                        
  else                                                                
    return bytes_written;                                             
}                                                                     
4001376c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40013770:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
static inline uint32_t                                                
 fat_sector_num_to_block_num (const fat_fs_info_t *fs_info,           
                              const uint32_t sector_number)           
{                                                                     
  return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
40013774:	c4 0e 20 02 	ldub  [ %i0 + 2 ], %g2                         <== NOT EXECUTED
40013778:	e0 06 20 20 	ld  [ %i0 + 0x20 ], %l0                        <== NOT EXECUTED
4001377c:	84 20 40 02 	sub  %g1, %g2, %g2                             <== NOT EXECUTED
40013780:	10 bf ff b8 	b  40013660 <fat_cluster_set+0x58>             <== NOT EXECUTED
40013784:	a1 34 00 02 	srl  %l0, %g2, %l0                             <== NOT EXECUTED
                                                                      

40013788 <fat_cluster_write>: const uint32_t start_cln, const uint32_t offset, const uint32_t count, const void *buff, const bool overwrite_cluster) {
40013788:	9d e3 bf 98 	save  %sp, -104, %sp                           
    ssize_t             rc               = RC_OK;                     
    uint32_t            bytes_to_write   = MIN(count, (fs_info->vol.bpc - offset));
4001378c:	c2 16 20 06 	lduh  [ %i0 + 6 ], %g1                         
40013790:	82 20 40 1a 	sub  %g1, %i2, %g1                             
40013794:	80 a6 c0 01 	cmp  %i3, %g1                                  
40013798:	38 80 00 02 	bgu,a   400137a0 <fat_cluster_write+0x18>      <== NEVER TAKEN
4001379c:	b6 10 00 01 	mov  %g1, %i3                                  <== NOT EXECUTED
fat_cluster_num_to_block_num (const fat_fs_info_t *fs_info,           
                              uint32_t             cln)               
{                                                                     
    uint32_t blk;                                                     
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
400137a0:	80 a6 60 00 	cmp  %i1, 0                                    
400137a4:	32 80 00 06 	bne,a   400137bc <fat_cluster_write+0x34>      
400137a8:	c2 0e 20 0c 	ldub  [ %i0 + 0xc ], %g1                       
400137ac:	c2 0e 20 0e 	ldub  [ %i0 + 0xe ], %g1                       
400137b0:	80 88 60 03 	btst  3, %g1                                   
400137b4:	12 80 00 52 	bne  400138fc <fat_cluster_write+0x174>        <== ALWAYS TAKEN
400137b8:	c2 0e 20 0c 	ldub  [ %i0 + 0xc ], %g1                       
400137bc:	e2 0e 20 02 	ldub  [ %i0 + 2 ], %l1                         
400137c0:	c6 06 20 34 	ld  [ %i0 + 0x34 ], %g3                        
        blk = fat_sector_num_to_block_num(fs_info, fs_info->vol.rdir_loc);
    else                                                              
    {                                                                 
        cln -= FAT_RSRVD_CLN;                                         
        blk = cln << (fs_info->vol.bpc_log2 - fs_info->vol.bytes_per_block_log2);
400137c4:	c4 0e 20 08 	ldub  [ %i0 + 8 ], %g2                         
400137c8:	a2 20 40 11 	sub  %g1, %l1, %l1                             
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
        blk = fat_sector_num_to_block_num(fs_info, fs_info->vol.rdir_loc);
    else                                                              
    {                                                                 
        cln -= FAT_RSRVD_CLN;                                         
400137cc:	b2 06 7f fe 	add  %i1, -2, %i1                              
400137d0:	a3 30 c0 11 	srl  %g3, %l1, %l1                             
        blk = cln << (fs_info->vol.bpc_log2 - fs_info->vol.bytes_per_block_log2);
400137d4:	84 20 80 01 	sub  %g2, %g1, %g2                             
400137d8:	b3 2e 40 02 	sll  %i1, %g2, %i1                             
        blk += fat_sector_num_to_block_num(fs_info, fs_info->vol.data_fsec);
400137dc:	a2 04 40 19 	add  %l1, %i1, %l1                             
    const bool                            overwrite_cluster)          
{                                                                     
    ssize_t             rc               = RC_OK;                     
    uint32_t            bytes_to_write   = MIN(count, (fs_info->vol.bpc - offset));
    uint32_t            cur_blk          = fat_cluster_num_to_block_num(fs_info, start_cln);
    uint32_t            blocks_in_offset = (offset >> fs_info->vol.bytes_per_block_log2);
400137e0:	85 36 80 01 	srl  %i2, %g1, %g2                             
    uint32_t            ofs_blk          = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
400137e4:	83 28 80 01 	sll  %g2, %g1, %g1                             
    ssize_t             bytes_written    = 0;                         
400137e8:	a4 10 20 00 	clr  %l2                                       
{                                                                     
    ssize_t             rc               = RC_OK;                     
    uint32_t            bytes_to_write   = MIN(count, (fs_info->vol.bpc - offset));
    uint32_t            cur_blk          = fat_cluster_num_to_block_num(fs_info, start_cln);
    uint32_t            blocks_in_offset = (offset >> fs_info->vol.bytes_per_block_log2);
    uint32_t            ofs_blk          = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
400137ec:	b4 26 80 01 	sub  %i2, %g1, %i2                             
    ssize_t             bytes_written    = 0;                         
    uint8_t             *buffer          = (uint8_t*)buff;            
    ssize_t             ret;                                          
    uint32_t            c;                                            
                                                                      
    cur_blk += blocks_in_offset;                                      
400137f0:	a2 00 80 11 	add  %g2, %l1, %l1                             
    const uint32_t                        offset,                     
    const uint32_t                        count,                      
    const void                           *buff,                       
    const bool                            overwrite_cluster)          
{                                                                     
    ssize_t             rc               = RC_OK;                     
400137f4:	82 10 20 00 	clr  %g1                                       
    ssize_t             ret;                                          
    uint32_t            c;                                            
                                                                      
    cur_blk += blocks_in_offset;                                      
                                                                      
    while (   (RC_OK == rc)                                           
400137f8:	80 a6 e0 00 	cmp  %i3, 0                                    
400137fc:	02 80 00 27 	be  40013898 <fat_cluster_write+0x110>         <== NEVER TAKEN
40013800:	a6 10 20 01 	mov  1, %l3                                    
40013804:	80 a0 60 00 	cmp  %g1, 0                                    
40013808:	32 80 00 3b 	bne,a   400138f4 <fat_cluster_write+0x16c>     <== NEVER TAKEN
4001380c:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
           && (0 < bytes_to_write))                                   
    {                                                                 
      c = MIN(bytes_to_write, (fs_info->vol.bytes_per_block - ofs_blk));
40013810:	c4 16 20 0a 	lduh  [ %i0 + 0xa ], %g2                       
40013814:	82 20 80 1a 	sub  %g2, %i2, %g1                             
40013818:	80 a0 40 1b 	cmp  %g1, %i3                                  
4001381c:	08 80 00 03 	bleu  40013828 <fat_cluster_write+0xa0>        
40013820:	b2 10 00 01 	mov  %g1, %i1                                  
40013824:	b2 10 00 1b 	mov  %i3, %i1                                  
    const uint32_t                        count,                      
    const void                           *buf,                        
    const bool                            overwrite_block)            
{                                                                     
    int                 rc             = RC_OK;                       
    uint32_t            bytes_to_write = MIN(count, (fs_info->vol.bytes_per_block - offset));
40013828:	80 a6 40 01 	cmp  %i1, %g1                                  
4001382c:	08 80 00 03 	bleu  40013838 <fat_cluster_write+0xb0>        <== ALWAYS TAKEN
40013830:	a0 10 00 19 	mov  %i1, %l0                                  
40013834:	a0 10 00 01 	mov  %g1, %l0                                  <== NOT EXECUTED
    uint32_t                              ino                         
    )                                                                 
{                                                                     
                                                                      
    return (ino >= fs_info->uino_base);                               
}                                                                     
40013838:	c2 0e 20 02 	ldub  [ %i0 + 2 ], %g1                         
    int                 rc             = RC_OK;                       
    uint32_t            bytes_to_write = MIN(count, (fs_info->vol.bytes_per_block - offset));
    uint8_t            *blk_buf;                                      
    uint32_t            sec_num        = fat_block_num_to_sector_num(fs_info, start_blk);
                                                                      
    if (0 < bytes_to_write)                                           
4001383c:	80 a4 20 00 	cmp  %l0, 0                                    
40013840:	02 80 00 26 	be  400138d8 <fat_cluster_write+0x150>         <== NEVER TAKEN
40013844:	d2 0e 20 0c 	ldub  [ %i0 + 0xc ], %o1                       
                                                                      
static inline uint32_t                                                
 fat_block_num_to_sector_num (const fat_fs_info_t *fs_info,           
                              const uint32_t block_number)            
{                                                                     
  return block_number << (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
40013848:	92 22 40 01 	sub  %o1, %g1, %o1                             
    {                                                                 
        if (   overwrite_block                                        
            || (bytes_to_write == fs_info->vol.bytes_per_block))      
        {                                                             
            rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &blk_buf);
4001384c:	90 10 00 18 	mov  %i0, %o0                                  
    uint8_t            *blk_buf;                                      
    uint32_t            sec_num        = fat_block_num_to_sector_num(fs_info, start_blk);
                                                                      
    if (0 < bytes_to_write)                                           
    {                                                                 
        if (   overwrite_block                                        
40013850:	80 a7 60 00 	cmp  %i5, 0                                    
40013854:	12 80 00 23 	bne  400138e0 <fat_cluster_write+0x158>        
40013858:	93 2c 40 09 	sll  %l1, %o1, %o1                             
            || (bytes_to_write == fs_info->vol.bytes_per_block))      
4001385c:	80 a0 80 10 	cmp  %g2, %l0                                  
40013860:	02 80 00 20 	be  400138e0 <fat_cluster_write+0x158>         
40013864:	94 10 20 01 	mov  1, %o2                                    
        {                                                             
            rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &blk_buf);
        }                                                             
        else                                                          
            rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &blk_buf);
40013868:	7f ff fe ee 	call  40013420 <fat_buf_access>                
4001386c:	96 07 bf fc 	add  %fp, -4, %o3                              
                                                                      
        if (RC_OK == rc)                                              
40013870:	80 a2 20 00 	cmp  %o0, 0                                    
40013874:	22 80 00 14 	be,a   400138c4 <fat_cluster_write+0x13c>      <== ALWAYS TAKEN
40013878:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
          cur_blk,                                                    
          ofs_blk,                                                    
          c,                                                          
          &buffer[bytes_written],                                     
          overwrite_cluster);                                         
      if (c != ret)                                                   
4001387c:	80 a2 00 19 	cmp  %o0, %i1                                  
40013880:	02 80 00 0b 	be  400138ac <fat_cluster_write+0x124>         <== ALWAYS TAKEN
40013884:	82 10 3f ff 	mov  -1, %g1                                   
40013888:	b4 10 20 00 	clr  %i2                                       <== NOT EXECUTED
    ssize_t             ret;                                          
    uint32_t            c;                                            
                                                                      
    cur_blk += blocks_in_offset;                                      
                                                                      
    while (   (RC_OK == rc)                                           
4001388c:	80 a6 e0 00 	cmp  %i3, 0                                    
40013890:	12 bf ff de 	bne  40013808 <fat_cluster_write+0x80>         <== NEVER TAKEN
40013894:	80 a0 60 00 	cmp  %g1, 0                                    
          bytes_written  += ret;                                      
          ++cur_blk;                                                  
      }                                                               
      ofs_blk = 0;                                                    
    }                                                                 
    if (RC_OK != rc)                                                  
40013898:	80 a0 60 00 	cmp  %g1, 0                                    
4001389c:	12 80 00 16 	bne  400138f4 <fat_cluster_write+0x16c>        <== NEVER TAKEN
400138a0:	b0 10 3f ff 	mov  -1, %i0                                   
400138a4:	81 c7 e0 08 	ret                                            
400138a8:	91 e8 00 12 	restore  %g0, %l2, %o0                         
          overwrite_cluster);                                         
      if (c != ret)                                                   
        rc = -1;                                                      
      else                                                            
      {                                                               
          bytes_to_write -= ret;                                      
400138ac:	b6 26 c0 08 	sub  %i3, %o0, %i3                             
          bytes_written  += ret;                                      
400138b0:	a4 04 80 08 	add  %l2, %o0, %l2                             
          ++cur_blk;                                                  
400138b4:	a2 04 60 01 	inc  %l1                                       
400138b8:	82 10 20 00 	clr  %g1                                       
400138bc:	10 bf ff f4 	b  4001388c <fat_cluster_write+0x104>          
400138c0:	b4 10 20 00 	clr  %i2                                       
        else                                                          
            rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &blk_buf);
                                                                      
        if (RC_OK == rc)                                              
        {                                                             
            memcpy(blk_buf + offset, buf, bytes_to_write);            
400138c4:	92 07 00 12 	add  %i4, %l2, %o1                             
400138c8:	90 02 00 1a 	add  %o0, %i2, %o0                             
400138cc:	40 00 25 56 	call  4001ce24 <memcpy>                        
400138d0:	94 10 00 10 	mov  %l0, %o2                                  
}                                                                     
                                                                      
static inline void                                                    
fat_buf_mark_modified(fat_fs_info_t *fs_info)                         
{                                                                     
    fs_info->c.modified = true;                                       
400138d4:	e6 2e 20 88 	stb  %l3, [ %i0 + 0x88 ]                       
        }                                                             
    }                                                                 
    if (RC_OK != rc)                                                  
        return rc;                                                    
    else                                                              
        return bytes_to_write;                                        
400138d8:	10 bf ff e9 	b  4001387c <fat_cluster_write+0xf4>           
400138dc:	90 10 00 10 	mov  %l0, %o0                                  
    if (0 < bytes_to_write)                                           
    {                                                                 
        if (   overwrite_block                                        
            || (bytes_to_write == fs_info->vol.bytes_per_block))      
        {                                                             
            rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &blk_buf);
400138e0:	94 10 20 02 	mov  2, %o2                                    
400138e4:	7f ff fe cf 	call  40013420 <fat_buf_access>                
400138e8:	96 07 bf fc 	add  %fp, -4, %o3                              
        }                                                             
        else                                                          
            rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &blk_buf);
                                                                      
        if (RC_OK == rc)                                              
400138ec:	10 bf ff e2 	b  40013874 <fat_cluster_write+0xec>           
400138f0:	80 a2 20 00 	cmp  %o0, 0                                    
    }                                                                 
    if (RC_OK != rc)                                                  
      return rc;                                                      
    else                                                              
      return bytes_written;                                           
}                                                                     
400138f4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400138f8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
static inline uint32_t                                                
 fat_sector_num_to_block_num (const fat_fs_info_t *fs_info,           
                              const uint32_t sector_number)           
{                                                                     
  return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
400138fc:	c4 0e 20 02 	ldub  [ %i0 + 2 ], %g2                         
40013900:	e2 06 20 20 	ld  [ %i0 + 0x20 ], %l1                        
40013904:	84 20 40 02 	sub  %g1, %g2, %g2                             
40013908:	10 bf ff b6 	b  400137e0 <fat_cluster_write+0x58>           
4001390c:	a3 34 40 02 	srl  %l1, %g2, %l1                             
                                                                      

40012a90 <fat_file_close>: int fat_file_close( fat_fs_info_t *fs_info, fat_file_fd_t *fat_fd ) {
40012a90:	9d e3 bf a0 	save  %sp, -96, %sp                            
                                                                      
    /*                                                                
     * 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)                                        
40012a94:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
40012a98:	80 a0 60 01 	cmp  %g1, 1                                    
40012a9c:	08 80 00 06 	bleu  40012ab4 <fat_file_close+0x24>           
40012aa0:	82 00 7f ff 	add  %g1, -1, %g1                              
    {                                                                 
        fat_fd->links_num--;                                          
        return rc;                                                    
40012aa4:	90 10 20 00 	clr  %o0                                       
     * 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)                                        
    {                                                                 
        fat_fd->links_num--;                                          
40012aa8:	c2 26 60 08 	st  %g1, [ %i1 + 8 ]                           
     * flush any modified "cached" buffer back to disk                
     */                                                               
    rc = fat_buf_release(fs_info);                                    
                                                                      
    return rc;                                                        
}                                                                     
40012aac:	81 c7 e0 08 	ret                                            
40012ab0:	91 e8 00 08 	restore  %g0, %o0, %o0                         
        return rc;                                                    
    }                                                                 
                                                                      
    key = fat_construct_key(fs_info, &fat_fd->dir_pos.sname);         
                                                                      
    if (fat_fd->flags & FAT_FILE_REMOVED)                             
40012ab4:	c2 0e 60 30 	ldub  [ %i1 + 0x30 ], %g1                      
40012ab8:	80 88 60 01 	btst  1, %g1                                   
40012abc:	22 80 00 15 	be,a   40012b10 <fat_file_close+0x80>          
40012ac0:	d2 06 60 0c 	ld  [ %i1 + 0xc ], %o1                         
    {                                                                 
        rc = fat_file_truncate(fs_info, fat_fd, 0);                   
40012ac4:	90 10 00 18 	mov  %i0, %o0                                  
40012ac8:	92 10 00 19 	mov  %i1, %o1                                  
40012acc:	7f ff ff b0 	call  4001298c <fat_file_truncate>             
40012ad0:	94 10 20 00 	clr  %o2                                       
        if ( rc != RC_OK )                                            
40012ad4:	80 a2 20 00 	cmp  %o0, 0                                    
40012ad8:	12 bf ff f5 	bne  40012aac <fat_file_close+0x1c>            <== NEVER TAKEN
40012adc:	01 00 00 00 	nop                                            
 */                                                                   
RTEMS_INLINE_ROUTINE void rtems_chain_extract(                        
  rtems_chain_node *the_node                                          
)                                                                     
{                                                                     
  _Chain_Extract( the_node );                                         
40012ae0:	40 00 0f 88 	call  40016900 <_Chain_Extract>                
40012ae4:	90 10 00 19 	mov  %i1, %o0                                  
            return rc;                                                
                                                                      
        _hash_delete(fs_info->rhash, key, fat_fd->ino, fat_fd);       
                                                                      
        if ( fat_ino_is_unique(fs_info, fat_fd->ino) )                
40012ae8:	d2 06 60 0c 	ld  [ %i1 + 0xc ], %o1                         
40012aec:	40 00 06 7a 	call  400144d4 <fat_ino_is_unique>             
40012af0:	90 10 00 18 	mov  %i0, %o0                                  
40012af4:	80 8a 20 ff 	btst  0xff, %o0                                
40012af8:	32 80 00 11 	bne,a   40012b3c <fat_file_close+0xac>         <== NEVER TAKEN
40012afc:	d2 06 60 0c 	ld  [ %i1 + 0xc ], %o1                         <== NOT EXECUTED
            fat_fd->links_num = 0;                                    
        }                                                             
        else                                                          
        {                                                             
            _hash_delete(fs_info->vhash, key, fat_fd->ino, fat_fd);   
            free(fat_fd);                                             
40012b00:	7f ff c8 2b 	call  40004bac <free>                          
40012b04:	90 10 00 19 	mov  %i1, %o0                                  
        }                                                             
    }                                                                 
    /*                                                                
     * flush any modified "cached" buffer back to disk                
     */                                                               
    rc = fat_buf_release(fs_info);                                    
40012b08:	40 00 01 cf 	call  40013244 <fat_buf_release>               
40012b0c:	81 e8 00 00 	restore                                        
                                                                      
        free(fat_fd);                                                 
    }                                                                 
    else                                                              
    {                                                                 
        if (fat_ino_is_unique(fs_info, fat_fd->ino))                  
40012b10:	40 00 06 71 	call  400144d4 <fat_ino_is_unique>             
40012b14:	90 10 00 18 	mov  %i0, %o0                                  
40012b18:	80 8a 20 ff 	btst  0xff, %o0                                
40012b1c:	02 80 00 05 	be  40012b30 <fat_file_close+0xa0>             
40012b20:	01 00 00 00 	nop                                            
        {                                                             
            fat_fd->links_num = 0;                                    
40012b24:	c0 26 60 08 	clr  [ %i1 + 8 ]                               
        }                                                             
    }                                                                 
    /*                                                                
     * flush any modified "cached" buffer back to disk                
     */                                                               
    rc = fat_buf_release(fs_info);                                    
40012b28:	40 00 01 c7 	call  40013244 <fat_buf_release>               
40012b2c:	81 e8 00 00 	restore                                        
40012b30:	40 00 0f 74 	call  40016900 <_Chain_Extract>                
40012b34:	90 10 00 19 	mov  %i1, %o0                                  
40012b38:	30 bf ff f2 	b,a   40012b00 <fat_file_close+0x70>           
            return rc;                                                
                                                                      
        _hash_delete(fs_info->rhash, key, fat_fd->ino, fat_fd);       
                                                                      
        if ( fat_ino_is_unique(fs_info, fat_fd->ino) )                
            fat_free_unique_ino(fs_info, fat_fd->ino);                
40012b3c:	40 00 06 5b 	call  400144a8 <fat_free_unique_ino>           <== NOT EXECUTED
40012b40:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40012b44:	30 bf ff ef 	b,a   40012b00 <fat_file_close+0x70>           <== NOT EXECUTED
                                                                      

40012c1c <fat_file_extend>: fat_file_fd_t *fat_fd, bool zero_fill, uint32_t new_length, uint32_t *a_length ) {
40012c1c:	9d e3 bf 90 	save  %sp, -112, %sp                           
    uint32_t       last_cl = 0;                                       
    uint32_t       bytes_remain = 0;                                  
    uint32_t       cls_added;                                         
    ssize_t        bytes_written;                                     
                                                                      
    *a_length = new_length;                                           
40012c20:	f6 27 00 00 	st  %i3, [ %i4 ]                               
                                                                      
    if (new_length <= fat_fd->fat_file_size)                          
40012c24:	c2 06 60 18 	ld  [ %i1 + 0x18 ], %g1                        
    uint32_t                              new_length,                 
    uint32_t                             *a_length                    
    )                                                                 
{                                                                     
    int            rc = RC_OK;                                        
    uint32_t       chain = 0;                                         
40012c28:	c0 27 bf f0 	clr  [ %fp + -16 ]                             
    uint32_t       bytes2add = 0;                                     
    uint32_t       cls2add = 0;                                       
    uint32_t       old_last_cl;                                       
    uint32_t       last_cl = 0;                                       
40012c2c:	c0 27 bf f8 	clr  [ %fp + -8 ]                              
    uint32_t       cls_added;                                         
    ssize_t        bytes_written;                                     
                                                                      
    *a_length = new_length;                                           
                                                                      
    if (new_length <= fat_fd->fat_file_size)                          
40012c30:	80 a6 c0 01 	cmp  %i3, %g1                                  
40012c34:	08 80 00 16 	bleu  40012c8c <fat_file_extend+0x70>          
40012c38:	ba 10 00 18 	mov  %i0, %i5                                  
        return RC_OK;                                                 
                                                                      
    if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&                               
40012c3c:	c4 06 60 20 	ld  [ %i1 + 0x20 ], %g2                        
40012c40:	80 a0 a0 01 	cmp  %g2, 1                                    
40012c44:	22 80 00 56 	be,a   40012d9c <fat_file_extend+0x180>        
40012c48:	c4 06 60 24 	ld  [ %i1 + 0x24 ], %g2                        
        (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))                
        rtems_set_errno_and_return_minus_one( ENOSPC );               
                                                                      
    bytes_remain = (fs_info->vol.bpc -                                
                   (fat_fd->fat_file_size & (fs_info->vol.bpc - 1))) &
40012c4c:	e0 17 60 06 	lduh  [ %i5 + 6 ], %l0                         
                   (fs_info->vol.bpc - 1);                            
                                                                      
    bytes2add = new_length - fat_fd->fat_file_size;                   
40012c50:	86 26 c0 01 	sub  %i3, %g1, %g3                             
    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 -                                
                   (fat_fd->fat_file_size & (fs_info->vol.bpc - 1))) &
40012c54:	84 04 3f ff 	add  %l0, -1, %g2                              
40012c58:	a4 08 80 01 	and  %g2, %g1, %l2                             
                                                                      
    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 -                                
40012c5c:	a0 24 00 12 	sub  %l0, %l2, %l0                             
40012c60:	a0 0c 00 02 	and  %l0, %g2, %l0                             
                   (fat_fd->fat_file_size & (fs_info->vol.bpc - 1))) &
                   (fs_info->vol.bpc - 1);                            
                                                                      
    bytes2add = new_length - fat_fd->fat_file_size;                   
                                                                      
    if (bytes2add > bytes_remain)                                     
40012c64:	80 a4 00 03 	cmp  %l0, %g3                                  
40012c68:	1a 80 00 03 	bcc  40012c74 <fat_file_extend+0x58>           
40012c6c:	a2 10 20 00 	clr  %l1                                       
        bytes2add -= bytes_remain;                                    
40012c70:	a2 20 c0 10 	sub  %g3, %l0, %l1                             
    else                                                              
        bytes2add = 0;                                                
                                                                      
    if (zero_fill && bytes_remain > 0) {                              
40012c74:	80 a4 20 00 	cmp  %l0, 0                                    
40012c78:	12 80 00 3c 	bne  40012d68 <fat_file_extend+0x14c>          
40012c7c:	80 a6 a0 00 	cmp  %i2, 0                                    
    /*                                                                
     * 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)                                               
40012c80:	80 a4 60 00 	cmp  %l1, 0                                    
40012c84:	32 80 00 04 	bne,a   40012c94 <fat_file_extend+0x78>        
40012c88:	c2 0f 60 08 	ldub  [ %i5 + 8 ], %g1                         
    ssize_t        bytes_written;                                     
                                                                      
    *a_length = new_length;                                           
                                                                      
    if (new_length <= fat_fd->fat_file_size)                          
        return RC_OK;                                                 
40012c8c:	81 c7 e0 08 	ret                                            
40012c90:	91 e8 20 00 	restore  %g0, 0, %o0                           
     * file ) - return                                                
     */                                                               
    if (bytes2add == 0)                                               
        return RC_OK;                                                 
                                                                      
    cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;         
40012c94:	a4 04 7f ff 	add  %l1, -1, %l2                              
                                                                      
    rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,     
40012c98:	90 10 00 1d 	mov  %i5, %o0                                  
     * file ) - return                                                
     */                                                               
    if (bytes2add == 0)                                               
        return RC_OK;                                                 
                                                                      
    cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;         
40012c9c:	a5 34 80 01 	srl  %l2, %g1, %l2                             
                                                                      
    rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,     
40012ca0:	92 07 bf f0 	add  %fp, -16, %o1                             
     * file ) - return                                                
     */                                                               
    if (bytes2add == 0)                                               
        return RC_OK;                                                 
                                                                      
    cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;         
40012ca4:	a4 04 a0 01 	inc  %l2                                       
                                                                      
    rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,     
40012ca8:	96 07 bf fc 	add  %fp, -4, %o3                              
40012cac:	94 10 00 12 	mov  %l2, %o2                                  
40012cb0:	98 07 bf f8 	add  %fp, -8, %o4                              
40012cb4:	40 00 1e 90 	call  4001a6f4 <fat_scan_fat_for_free_clusters>
40012cb8:	9a 10 00 1a 	mov  %i2, %o5                                  
                                        &cls_added, &last_cl, zero_fill);
                                                                      
    /* this means that low level I/O error occured */                 
    if (rc != RC_OK)                                                  
40012cbc:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40012cc0:	12 80 00 28 	bne  40012d60 <fat_file_extend+0x144>          <== NEVER TAKEN
40012cc4:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
        return rc;                                                    
                                                                      
    /* this means that no space left on device */                     
    if ((cls_added == 0) && (bytes_remain == 0))                      
40012cc8:	80 94 00 01 	orcc  %l0, %g1, %g0                            
40012ccc:	02 80 00 3b 	be  40012db8 <fat_file_extend+0x19c>           <== NEVER TAKEN
40012cd0:	80 a4 80 01 	cmp  %l2, %g1                                  
        rtems_set_errno_and_return_minus_one(ENOSPC);                 
                                                                      
    /*  check wether we satisfied request for 'cls2add' clusters */   
    if (cls2add != cls_added)                                         
40012cd4:	02 80 00 09 	be  40012cf8 <fat_file_extend+0xdc>            <== ALWAYS TAKEN
40012cd8:	a4 24 80 01 	sub  %l2, %g1, %l2                             
    {                                                                 
        new_length -= bytes2add & (fs_info->vol.bpc - 1);             
40012cdc:	c6 17 60 06 	lduh  [ %i5 + 6 ], %g3                         <== NOT EXECUTED
        new_length -= (cls2add - cls_added) << fs_info->vol.bpc_log2; 
40012ce0:	c4 0f 60 08 	ldub  [ %i5 + 8 ], %g2                         <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(ENOSPC);                 
                                                                      
    /*  check wether we satisfied request for 'cls2add' clusters */   
    if (cls2add != cls_added)                                         
    {                                                                 
        new_length -= bytes2add & (fs_info->vol.bpc - 1);             
40012ce4:	86 00 ff ff 	add  %g3, -1, %g3                              <== NOT EXECUTED
40012ce8:	a2 0c 40 03 	and  %l1, %g3, %l1                             <== NOT EXECUTED
        new_length -= (cls2add - cls_added) << fs_info->vol.bpc_log2; 
40012cec:	a5 2c 80 02 	sll  %l2, %g2, %l2                             <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(ENOSPC);                 
                                                                      
    /*  check wether we satisfied request for 'cls2add' clusters */   
    if (cls2add != cls_added)                                         
    {                                                                 
        new_length -= bytes2add & (fs_info->vol.bpc - 1);             
40012cf0:	b6 26 c0 11 	sub  %i3, %l1, %i3                             <== NOT EXECUTED
        new_length -= (cls2add - cls_added) << fs_info->vol.bpc_log2; 
40012cf4:	b6 26 c0 12 	sub  %i3, %l2, %i3                             <== NOT EXECUTED
    }                                                                 
                                                                      
    /* add new chain to the end of existed */                         
    if ( fat_fd->fat_file_size == 0 )                                 
40012cf8:	d6 06 60 18 	ld  [ %i1 + 0x18 ], %o3                        
40012cfc:	80 a2 e0 00 	cmp  %o3, 0                                    
40012d00:	32 80 00 43 	bne,a   40012e0c <fat_file_extend+0x1f0>       
40012d04:	d2 06 60 3c 	ld  [ %i1 + 0x3c ], %o1                        
    {                                                                 
        fat_fd->map.disk_cln = fat_fd->cln = chain;                   
40012d08:	c4 07 bf f0 	ld  [ %fp + -16 ], %g2                         
        fat_fd->map.file_cln = 0;                                     
40012d0c:	c0 26 60 34 	clr  [ %i1 + 0x34 ]                            
    }                                                                 
                                                                      
    /* add new chain to the end of existed */                         
    if ( fat_fd->fat_file_size == 0 )                                 
    {                                                                 
        fat_fd->map.disk_cln = fat_fd->cln = chain;                   
40012d10:	c4 26 60 1c 	st  %g2, [ %i1 + 0x1c ]                        
40012d14:	c4 26 60 38 	st  %g2, [ %i1 + 0x38 ]                        
        }                                                             
        fat_buf_release(fs_info);                                     
    }                                                                 
                                                                      
    /* update number of the last cluster of the file if it changed */ 
    if (cls_added != 0)                                               
40012d18:	80 a0 60 00 	cmp  %g1, 0                                    
40012d1c:	22 80 00 39 	be,a   40012e00 <fat_file_extend+0x1e4>        <== NEVER TAKEN
40012d20:	f6 27 00 00 	st  %i3, [ %i4 ]                               <== NOT EXECUTED
    {                                                                 
        fat_fd->map.last_cln = last_cl;                               
40012d24:	c4 07 bf f8 	ld  [ %fp + -8 ], %g2                          
        if (fat_fd->fat_file_type == FAT_DIRECTORY)                   
40012d28:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1                        
40012d2c:	80 a0 60 00 	cmp  %g1, 0                                    
40012d30:	12 80 00 33 	bne  40012dfc <fat_file_extend+0x1e0>          
40012d34:	c4 26 60 3c 	st  %g2, [ %i1 + 0x3c ]                        
        {                                                             
            rc = fat_init_clusters_chain(fs_info, chain);             
40012d38:	d2 07 bf f0 	ld  [ %fp + -16 ], %o1                         
40012d3c:	40 00 05 80 	call  4001433c <fat_init_clusters_chain>       
40012d40:	90 10 00 1d 	mov  %i5, %o0                                  
            if ( rc != RC_OK )                                        
40012d44:	82 92 20 00 	orcc  %o0, 0, %g1                              
40012d48:	22 80 00 2e 	be,a   40012e00 <fat_file_extend+0x1e4>        <== ALWAYS TAKEN
40012d4c:	f6 27 00 00 	st  %i3, [ %i4 ]                               
            {                                                         
                fat_free_fat_clusters_chain(fs_info, chain);          
40012d50:	d2 07 bf f0 	ld  [ %fp + -16 ], %o1                         <== NOT EXECUTED
40012d54:	b0 10 00 01 	mov  %g1, %i0                                  <== NOT EXECUTED
40012d58:	40 00 1e 2f 	call  4001a614 <fat_free_fat_clusters_chain>   <== NOT EXECUTED
40012d5c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40012d60:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40012d64:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    if (bytes2add > bytes_remain)                                     
        bytes2add -= bytes_remain;                                    
    else                                                              
        bytes2add = 0;                                                
                                                                      
    if (zero_fill && bytes_remain > 0) {                              
40012d68:	02 bf ff c7 	be  40012c84 <fat_file_extend+0x68>            
40012d6c:	80 a4 60 00 	cmp  %l1, 0                                    
        uint32_t start = fat_fd->fat_file_size;                       
        uint32_t cl_start = start >> fs_info->vol.bpc_log2;           
40012d70:	d4 0f 60 08 	ldub  [ %i5 + 8 ], %o2                         
        uint32_t ofs = start & (fs_info->vol.bpc - 1);                
        uint32_t cur_cln;                                             
                                                                      
        rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);     
40012d74:	90 10 00 1d 	mov  %i5, %o0                                  
40012d78:	92 10 00 19 	mov  %i1, %o1                                  
40012d7c:	95 30 40 0a 	srl  %g1, %o2, %o2                             
40012d80:	7f ff fd 9b 	call  400123ec <fat_file_lseek>                
40012d84:	96 07 bf fc 	add  %fp, -4, %o3                              
        if (rc != RC_OK)                                              
40012d88:	b0 92 60 00 	orcc  %o1, 0, %i0                              
40012d8c:	02 80 00 11 	be  40012dd0 <fat_file_extend+0x1b4>           <== ALWAYS TAKEN
40012d90:	d2 07 bf fc 	ld  [ %fp + -4 ], %o1                          
                                                                      
    *a_length = new_length;                                           
    fat_fd->fat_file_size = new_length;                               
                                                                      
    return RC_OK;                                                     
}                                                                     
40012d94:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40012d98:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    *a_length = new_length;                                           
                                                                      
    if (new_length <= fat_fd->fat_file_size)                          
        return RC_OK;                                                 
                                                                      
    if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&                               
40012d9c:	80 a0 a0 00 	cmp  %g2, 0                                    
40012da0:	32 bf ff ac 	bne,a   40012c50 <fat_file_extend+0x34>        <== NEVER TAKEN
40012da4:	e0 17 60 06 	lduh  [ %i5 + 6 ], %l0                         <== NOT EXECUTED
        (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))                
40012da8:	c4 0e 20 0e 	ldub  [ %i0 + 0xe ], %g2                       
    *a_length = new_length;                                           
                                                                      
    if (new_length <= fat_fd->fat_file_size)                          
        return RC_OK;                                                 
                                                                      
    if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&                               
40012dac:	80 88 a0 03 	btst  3, %g2                                   
40012db0:	22 bf ff a8 	be,a   40012c50 <fat_file_extend+0x34>         <== NEVER TAKEN
40012db4:	e0 17 60 06 	lduh  [ %i5 + 6 ], %l0                         <== NOT EXECUTED
    if (rc != RC_OK)                                                  
        return rc;                                                    
                                                                      
    /* this means that no space left on device */                     
    if ((cls_added == 0) && (bytes_remain == 0))                      
        rtems_set_errno_and_return_minus_one(ENOSPC);                 
40012db8:	40 00 25 76 	call  4001c390 <__errno>                       
40012dbc:	b0 10 3f ff 	mov  -1, %i0                                   
40012dc0:	82 10 20 1c 	mov  0x1c, %g1                                 
40012dc4:	c2 22 00 00 	st  %g1, [ %o0 ]                               
40012dc8:	81 c7 e0 08 	ret                                            
40012dcc:	81 e8 00 00 	restore                                        
                                                                      
        rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);     
        if (rc != RC_OK)                                              
            return rc;                                                
                                                                      
        bytes_written = fat_cluster_set (fs_info, cur_cln, ofs, bytes_remain, 0);
40012dd0:	90 10 00 1d 	mov  %i5, %o0                                  
40012dd4:	94 10 00 12 	mov  %l2, %o2                                  
40012dd8:	96 10 00 10 	mov  %l0, %o3                                  
40012ddc:	98 10 20 00 	clr  %o4                                       
40012de0:	40 00 02 0a 	call  40013608 <fat_cluster_set>               
40012de4:	b0 10 3f ff 	mov  -1, %i0                                   
        if (bytes_remain != bytes_written)                            
40012de8:	80 a2 00 10 	cmp  %o0, %l0                                  
40012dec:	02 bf ff a6 	be  40012c84 <fat_file_extend+0x68>            <== ALWAYS TAKEN
40012df0:	80 a4 60 00 	cmp  %l1, 0                                    
                                                                      
    *a_length = new_length;                                           
    fat_fd->fat_file_size = new_length;                               
                                                                      
    return RC_OK;                                                     
}                                                                     
40012df4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40012df8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                return rc;                                            
            }                                                         
        }                                                             
    }                                                                 
                                                                      
    *a_length = new_length;                                           
40012dfc:	f6 27 00 00 	st  %i3, [ %i4 ]                               
    fat_fd->fat_file_size = new_length;                               
40012e00:	f6 26 60 18 	st  %i3, [ %i1 + 0x18 ]                        
                                                                      
    return RC_OK;                                                     
}                                                                     
40012e04:	81 c7 e0 08 	ret                                            
40012e08:	81 e8 00 00 	restore                                        
        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)              
40012e0c:	80 a2 7f ff 	cmp  %o1, -1                                   
40012e10:	22 80 00 0d 	be,a   40012e44 <fat_file_extend+0x228>        <== NEVER TAKEN
40012e14:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
        {                                                             
            old_last_cl = fat_fd->map.last_cln;                       
40012e18:	d2 27 bf f4 	st  %o1, [ %fp + -12 ]                         
                fat_free_fat_clusters_chain(fs_info, chain);          
                return rc;                                            
            }                                                         
        }                                                             
                                                                      
        rc = fat_set_fat_cluster(fs_info, old_last_cl, chain);        
40012e1c:	d4 07 bf f0 	ld  [ %fp + -16 ], %o2                         
40012e20:	40 00 1d 4b 	call  4001a34c <fat_set_fat_cluster>           
40012e24:	90 10 00 1d 	mov  %i5, %o0                                  
        if ( rc != RC_OK )                                            
40012e28:	82 92 20 00 	orcc  %o0, 0, %g1                              
40012e2c:	12 bf ff ca 	bne  40012d54 <fat_file_extend+0x138>          <== NEVER TAKEN
40012e30:	d2 07 bf f0 	ld  [ %fp + -16 ], %o1                         
        {                                                             
            fat_free_fat_clusters_chain(fs_info, chain);              
            return rc;                                                
        }                                                             
        fat_buf_release(fs_info);                                     
40012e34:	40 00 01 04 	call  40013244 <fat_buf_release>               
40012e38:	90 10 00 1d 	mov  %i5, %o0                                  
40012e3c:	10 bf ff b7 	b  40012d18 <fat_file_extend+0xfc>             
40012e40:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
        {                                                             
            old_last_cl = fat_fd->map.last_cln;                       
        }                                                             
        else                                                          
        {                                                             
            rc = fat_file_ioctl(fs_info, fat_fd, F_CLU_NUM,           
40012e44:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40012e48:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
40012e4c:	96 02 ff ff 	add  %o3, -1, %o3                              <== NOT EXECUTED
40012e50:	7f ff ff 3e 	call  40012b48 <fat_file_ioctl>                <== NOT EXECUTED
40012e54:	98 07 bf f4 	add  %fp, -12, %o4                             <== NOT EXECUTED
40012e58:	d2 07 bf f4 	ld  [ %fp + -12 ], %o1                         <== NOT EXECUTED
                                (fat_fd->fat_file_size - 1), &old_last_cl);
            if ( rc != RC_OK )                                        
40012e5c:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40012e60:	02 bf ff ef 	be  40012e1c <fat_file_extend+0x200>           <== NOT EXECUTED
40012e64:	82 10 00 08 	mov  %o0, %g1                                  <== NOT EXECUTED
        if (fat_fd->fat_file_type == FAT_DIRECTORY)                   
        {                                                             
            rc = fat_init_clusters_chain(fs_info, chain);             
            if ( rc != RC_OK )                                        
            {                                                         
                fat_free_fat_clusters_chain(fs_info, chain);          
40012e68:	10 bf ff bb 	b  40012d54 <fat_file_extend+0x138>            <== NOT EXECUTED
40012e6c:	d2 07 bf f0 	ld  [ %fp + -16 ], %o1                         <== NOT EXECUTED
                                                                      

40012b48 <fat_file_ioctl>: fat_file_ioctl( fat_fs_info_t *fs_info, fat_file_fd_t *fat_fd, int cmd, ...) {
40012b48:	9d e3 bf 98 	save  %sp, -104, %sp                           
    uint32_t       cl_start = 0;                                      
    uint32_t       pos = 0;                                           
    uint32_t      *ret;                                               
    va_list        ap;                                                
                                                                      
    va_start(ap, cmd);                                                
40012b4c:	82 07 a0 50 	add  %fp, 0x50, %g1                            
40012b50:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]                        
40012b54:	f8 27 a0 54 	st  %i4, [ %fp + 0x54 ]                        
40012b58:	fa 27 a0 58 	st  %i5, [ %fp + 0x58 ]                        
    fat_file_fd_t                        *fat_fd,                     
    int                                   cmd,                        
    ...)                                                              
{                                                                     
    int            rc = RC_OK;                                        
    uint32_t       cur_cln = 0;                                       
40012b5c:	c0 27 bf f8 	clr  [ %fp + -8 ]                              
    uint32_t      *ret;                                               
    va_list        ap;                                                
                                                                      
    va_start(ap, cmd);                                                
                                                                      
    switch (cmd)                                                      
40012b60:	80 a6 a0 01 	cmp  %i2, 1                                    
40012b64:	02 80 00 08 	be  40012b84 <fat_file_ioctl+0x3c>             <== ALWAYS TAKEN
40012b68:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
                                                                      
            *ret = cur_cln;                                           
            break;                                                    
                                                                      
        default:                                                      
            errno = EINVAL;                                           
40012b6c:	40 00 26 09 	call  4001c390 <__errno>                       <== NOT EXECUTED
40012b70:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40012b74:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
40012b78:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
            rc = -1;                                                  
            break;                                                    
    }                                                                 
    va_end(ap);                                                       
    return rc;                                                        
}                                                                     
40012b7c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40012b80:	81 e8 00 00 	restore                                        <== 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 ) {                     
40012b84:	c4 06 60 18 	ld  [ %i1 + 0x18 ], %g2                        
                                                                      
    switch (cmd)                                                      
    {                                                                 
        case F_CLU_NUM:                                               
            pos = va_arg(ap, uint32_t);                               
            ret = va_arg(ap, uint32_t *);                             
40012b88:	86 07 a0 58 	add  %fp, 0x58, %g3                            
40012b8c:	c6 27 bf fc 	st  %g3, [ %fp + -4 ]                          
                                                                      
            /* sanity check */                                        
            if ( pos >= fat_fd->fat_file_size ) {                     
40012b90:	80 a6 c0 02 	cmp  %i3, %g2                                  
40012b94:	1a 80 00 1c 	bcc  40012c04 <fat_file_ioctl+0xbc>            <== NEVER TAKEN
40012b98:	ba 10 00 1c 	mov  %i4, %i5                                  
                va_end(ap);                                           
                rtems_set_errno_and_return_minus_one( EIO );          
            }                                                         
                                                                      
            if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&                       
40012b9c:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
40012ba0:	80 a0 60 01 	cmp  %g1, 1                                    
40012ba4:	22 80 00 0e 	be,a   40012bdc <fat_file_ioctl+0x94>          
40012ba8:	c2 06 60 24 	ld  [ %i1 + 0x24 ], %g1                        
                *ret  = 0;                                            
                rc = RC_OK;                                           
                break;                                                
            }                                                         
                                                                      
            cl_start = pos >> fs_info->vol.bpc_log2;                  
40012bac:	d4 0e 20 08 	ldub  [ %i0 + 8 ], %o2                         
                                                                      
            rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln); 
40012bb0:	90 10 00 18 	mov  %i0, %o0                                  
40012bb4:	92 10 00 19 	mov  %i1, %o1                                  
40012bb8:	95 36 c0 0a 	srl  %i3, %o2, %o2                             
40012bbc:	7f ff fe 0c 	call  400123ec <fat_file_lseek>                
40012bc0:	96 07 bf f8 	add  %fp, -8, %o3                              
            if ( rc != RC_OK )                                        
40012bc4:	b0 92 60 00 	orcc  %o1, 0, %i0                              
40012bc8:	12 bf ff ed 	bne  40012b7c <fat_file_ioctl+0x34>            <== NEVER TAKEN
40012bcc:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
                break;                                                
                                                                      
            *ret = cur_cln;                                           
40012bd0:	c2 27 40 00 	st  %g1, [ %i5 ]                               
            break;                                                    
40012bd4:	81 c7 e0 08 	ret                                            
40012bd8:	81 e8 00 00 	restore                                        
            if ( pos >= fat_fd->fat_file_size ) {                     
                va_end(ap);                                           
                rtems_set_errno_and_return_minus_one( EIO );          
            }                                                         
                                                                      
            if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&                       
40012bdc:	80 a0 60 00 	cmp  %g1, 0                                    
40012be0:	32 bf ff f4 	bne,a   40012bb0 <fat_file_ioctl+0x68>         <== NEVER TAKEN
40012be4:	d4 0e 20 08 	ldub  [ %i0 + 8 ], %o2                         <== NOT EXECUTED
                (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))        
40012be8:	c2 0e 20 0e 	ldub  [ %i0 + 0xe ], %g1                       
            if ( pos >= fat_fd->fat_file_size ) {                     
                va_end(ap);                                           
                rtems_set_errno_and_return_minus_one( EIO );          
            }                                                         
                                                                      
            if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&                       
40012bec:	80 88 60 03 	btst  3, %g1                                   
40012bf0:	22 bf ff f0 	be,a   40012bb0 <fat_file_ioctl+0x68>          
40012bf4:	d4 0e 20 08 	ldub  [ %i0 + 8 ], %o2                         
                (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))        
            {                                                         
                /* cluster 0 (zero) reserved for root dir */          
                *ret  = 0;                                            
40012bf8:	c0 27 00 00 	clr  [ %i4 ]                                   
                rc = RC_OK;                                           
                break;                                                
40012bfc:	81 c7 e0 08 	ret                                            
40012c00:	91 e8 20 00 	restore  %g0, 0, %o0                           
            ret = va_arg(ap, uint32_t *);                             
                                                                      
            /* sanity check */                                        
            if ( pos >= fat_fd->fat_file_size ) {                     
                va_end(ap);                                           
                rtems_set_errno_and_return_minus_one( EIO );          
40012c04:	40 00 25 e3 	call  4001c390 <__errno>                       <== NOT EXECUTED
40012c08:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40012c0c:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
40012c10:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
40012c14:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40012c18:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

400123ec <fat_file_lseek>: fat_fs_info_t *fs_info, fat_file_fd_t *fat_fd, uint32_t file_cln, uint32_t *disk_cln ) {
400123ec:	9d e3 bf 98 	save  %sp, -104, %sp                           
    int rc = RC_OK;                                                   
                                                                      
    if (file_cln == fat_fd->map.file_cln)                             
400123f0:	f8 06 60 34 	ld  [ %i1 + 0x34 ], %i4                        
400123f4:	80 a7 00 1a 	cmp  %i4, %i2                                  
400123f8:	22 80 00 26 	be,a   40012490 <fat_file_lseek+0xa4>          
400123fc:	c2 06 60 38 	ld  [ %i1 + 0x38 ], %g1                        
    {                                                                 
        uint32_t   cur_cln;                                           
        uint32_t   count;                                             
        uint32_t   i;                                                 
                                                                      
        if (file_cln > fat_fd->map.file_cln)                          
40012400:	2a 80 00 19 	bcs,a   40012464 <fat_file_lseek+0x78>         
40012404:	c2 06 60 38 	ld  [ %i1 + 0x38 ], %g1                        
            cur_cln = fat_fd->map.disk_cln;                           
            count = file_cln - fat_fd->map.file_cln;                  
        }                                                             
        else                                                          
        {                                                             
            cur_cln = fat_fd->cln;                                    
40012408:	c2 06 60 1c 	ld  [ %i1 + 0x1c ], %g1                        
4001240c:	b8 10 00 1a 	mov  %i2, %i4                                  
40012410:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
            count = file_cln;                                         
        }                                                             
                                                                      
        /* skip over the clusters */                                  
        for (i = 0; i < count; i++)                                   
40012414:	80 a7 20 00 	cmp  %i4, 0                                    
40012418:	12 80 00 07 	bne  40012434 <fat_file_lseek+0x48>            
4001241c:	ba 10 20 00 	clr  %i5                                       
                return rc;                                            
        }                                                             
                                                                      
        /* update cache */                                            
        fat_fd->map.file_cln = file_cln;                              
        fat_fd->map.disk_cln = cur_cln;                               
40012420:	10 80 00 14 	b  40012470 <fat_file_lseek+0x84>              
40012424:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
            cur_cln = fat_fd->cln;                                    
            count = file_cln;                                         
        }                                                             
                                                                      
        /* skip over the clusters */                                  
        for (i = 0; i < count; i++)                                   
40012428:	80 a7 40 1c 	cmp  %i5, %i4                                  
4001242c:	02 80 00 11 	be  40012470 <fat_file_lseek+0x84>             
40012430:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
        {                                                             
            rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);     
40012434:	d2 07 bf fc 	ld  [ %fp + -4 ], %o1                          
40012438:	90 10 00 18 	mov  %i0, %o0                                  
4001243c:	40 00 1f 40 	call  4001a13c <fat_get_fat_cluster>           
40012440:	94 07 bf fc 	add  %fp, -4, %o2                              
            if ( rc != RC_OK )                                        
40012444:	80 a2 20 00 	cmp  %o0, 0                                    
40012448:	22 bf ff f8 	be,a   40012428 <fat_file_lseek+0x3c>          <== ALWAYS TAKEN
4001244c:	ba 07 60 01 	inc  %i5                                       
                return rc;                                            
40012450:	86 10 00 08 	mov  %o0, %g3                                  <== NOT EXECUTED
40012454:	85 3a 20 1f 	sra  %o0, 0x1f, %g2                            <== NOT EXECUTED
        fat_fd->map.disk_cln = cur_cln;                               
                                                                      
        *disk_cln = cur_cln;                                          
    }                                                                 
    return RC_OK;                                                     
}                                                                     
40012458:	b2 10 00 03 	mov  %g3, %i1                                  <== NOT EXECUTED
4001245c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40012460:	91 e8 00 02 	restore  %g0, %g2, %o0                         <== NOT EXECUTED
        uint32_t   i;                                                 
                                                                      
        if (file_cln > fat_fd->map.file_cln)                          
        {                                                             
            cur_cln = fat_fd->map.disk_cln;                           
            count = file_cln - fat_fd->map.file_cln;                  
40012464:	b8 26 80 1c 	sub  %i2, %i4, %i4                             
        uint32_t   count;                                             
        uint32_t   i;                                                 
                                                                      
        if (file_cln > fat_fd->map.file_cln)                          
        {                                                             
            cur_cln = fat_fd->map.disk_cln;                           
40012468:	10 bf ff eb 	b  40012414 <fat_file_lseek+0x28>              
4001246c:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
            if ( rc != RC_OK )                                        
                return rc;                                            
        }                                                             
                                                                      
        /* update cache */                                            
        fat_fd->map.file_cln = file_cln;                              
40012470:	f4 26 60 34 	st  %i2, [ %i1 + 0x34 ]                        
        fat_fd->map.disk_cln = cur_cln;                               
40012474:	c2 26 60 38 	st  %g1, [ %i1 + 0x38 ]                        
                                                                      
        *disk_cln = cur_cln;                                          
    }                                                                 
    return RC_OK;                                                     
40012478:	84 10 20 00 	clr  %g2                                       
4001247c:	86 10 20 00 	clr  %g3                                       
                                                                      
        /* update cache */                                            
        fat_fd->map.file_cln = file_cln;                              
        fat_fd->map.disk_cln = cur_cln;                               
                                                                      
        *disk_cln = cur_cln;                                          
40012480:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
    }                                                                 
    return RC_OK;                                                     
}                                                                     
40012484:	b0 10 00 02 	mov  %g2, %i0                                  
40012488:	81 c7 e0 08 	ret                                            
4001248c:	93 e8 00 03 	restore  %g0, %g3, %o1                         
        fat_fd->map.file_cln = file_cln;                              
        fat_fd->map.disk_cln = cur_cln;                               
                                                                      
        *disk_cln = cur_cln;                                          
    }                                                                 
    return RC_OK;                                                     
40012490:	84 10 20 00 	clr  %g2                                       
40012494:	86 10 20 00 	clr  %g3                                       
    )                                                                 
{                                                                     
    int rc = RC_OK;                                                   
                                                                      
    if (file_cln == fat_fd->map.file_cln)                             
        *disk_cln = fat_fd->map.disk_cln;                             
40012498:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
        fat_fd->map.disk_cln = cur_cln;                               
                                                                      
        *disk_cln = cur_cln;                                          
    }                                                                 
    return RC_OK;                                                     
}                                                                     
4001249c:	b0 10 00 02 	mov  %g2, %i0                                  
400124a0:	81 c7 e0 08 	ret                                            
400124a4:	93 e8 00 03 	restore  %g0, %g3, %o1                         
                                                                      

400130d4 <fat_file_mark_removed>: void fat_file_mark_removed( fat_fs_info_t *fs_info, fat_file_fd_t *fat_fd ) {
400130d4:	9d e3 bf a0 	save  %sp, -96, %sp                            
400130d8:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
fat_cluster_num_to_sector512_num(                                     
    const fat_fs_info_t *fs_info,                                     
    uint32_t             cln                                          
    )                                                                 
{                                                                     
    if (cln == 1)                                                     
400130dc:	80 a0 60 01 	cmp  %g1, 1                                    
400130e0:	02 80 00 26 	be  40013178 <fat_file_mark_removed+0xa4>      <== NEVER TAKEN
400130e4:	80 a0 60 00 	cmp  %g1, 0                                    
fat_cluster_num_to_sector_num(                                        
    const fat_fs_info_t *fs_info,                                     
    uint32_t             cln                                          
    )                                                                 
{                                                                     
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
400130e8:	32 80 00 1f 	bne,a   40013164 <fat_file_mark_removed+0x90>  <== NEVER TAKEN
400130ec:	c6 0e 20 05 	ldub  [ %i0 + 5 ], %g3                         <== NOT EXECUTED
400130f0:	c4 0e 20 0e 	ldub  [ %i0 + 0xe ], %g2                       
400130f4:	80 88 a0 03 	btst  3, %g2                                   
400130f8:	22 80 00 1b 	be,a   40013164 <fat_file_mark_removed+0x90>   <== NEVER TAKEN
400130fc:	c6 0e 20 05 	ldub  [ %i0 + 5 ], %g3                         <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
40013100:	fa 06 20 20 	ld  [ %i0 + 0x20 ], %i5                        
    )                                                                 
{                                                                     
    if (cln == 1)                                                     
        return 1;                                                     
                                                                      
    return (fat_cluster_num_to_sector_num(fs_info, cln) <<            
40013104:	c4 0e 20 03 	ldub  [ %i0 + 3 ], %g2                         
40013108:	bb 2f 40 02 	sll  %i5, %g2, %i5                             
              (pos->ofs >> FAT_SECTOR512_BITS)) << 4)              +  
4001310c:	c4 06 60 24 	ld  [ %i1 + 0x24 ], %g2                        
40013110:	90 10 00 19 	mov  %i1, %o0                                  
40013114:	87 30 a0 09 	srl  %g2, 9, %g3                               
              ((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );  
40013118:	85 30 a0 05 	srl  %g2, 5, %g2                               
4001311c:	84 08 a0 0f 	and  %g2, 0xf, %g2                             
static inline uint32_t                                                
fat_construct_key(                                                    
    const fat_fs_info_t                  *fs_info,                    
    fat_pos_t                            *pos)                        
{                                                                     
    return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +  
40013120:	ba 07 40 03 	add  %i5, %g3, %i5                             
              (pos->ofs >> FAT_SECTOR512_BITS)) << 4)              +  
40013124:	bb 2f 60 04 	sll  %i5, 4, %i5                               
40013128:	40 00 0d f6 	call  40016900 <_Chain_Extract>                
4001312c:	ba 07 40 02 	add  %i5, %g2, %i5                             
 */                                                                   
static inline void                                                    
_hash_insert(rtems_chain_control *hash, uint32_t   key1, uint32_t   key2,
             fat_file_fd_t *el)                                       
{                                                                     
    rtems_chain_append((hash) + ((key1) % FAT_HASH_MODULE), &(el)->link);
40013130:	d0 06 20 70 	ld  [ %i0 + 0x70 ], %o0                        
40013134:	82 0f 60 01 	and  %i5, 1, %g1                               
40013138:	85 28 60 02 	sll  %g1, 2, %g2                               
4001313c:	83 28 60 04 	sll  %g1, 4, %g1                               
40013140:	82 20 40 02 	sub  %g1, %g2, %g1                             
RTEMS_INLINE_ROUTINE void rtems_chain_append(                         
  rtems_chain_control *the_chain,                                     
  rtems_chain_node    *the_node                                       
)                                                                     
{                                                                     
  _Chain_Append( the_chain, the_node );                               
40013144:	92 10 00 19 	mov  %i1, %o1                                  
40013148:	7f ff db 7d 	call  40009f3c <_Chain_Append>                 
4001314c:	90 02 00 01 	add  %o0, %g1, %o0                             
                                                                      
    _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;                                
40013150:	c2 0e 60 30 	ldub  [ %i1 + 0x30 ], %g1                      
40013154:	82 10 60 01 	or  %g1, 1, %g1                                
40013158:	c2 2e 60 30 	stb  %g1, [ %i1 + 0x30 ]                       
4001315c:	81 c7 e0 08 	ret                                            
40013160:	81 e8 00 00 	restore                                        
    )                                                                 
{                                                                     
    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) +        
40013164:	c4 06 20 34 	ld  [ %i0 + 0x34 ], %g2                        <== NOT EXECUTED
40013168:	ba 00 7f fe 	add  %g1, -2, %i5                              <== NOT EXECUTED
4001316c:	bb 2f 40 03 	sll  %i5, %g3, %i5                             <== NOT EXECUTED
40013170:	10 bf ff e5 	b  40013104 <fat_file_mark_removed+0x30>       <== NOT EXECUTED
40013174:	ba 07 40 02 	add  %i5, %g2, %i5                             <== NOT EXECUTED
    const fat_fs_info_t *fs_info,                                     
    uint32_t             cln                                          
    )                                                                 
{                                                                     
    if (cln == 1)                                                     
        return 1;                                                     
40013178:	10 bf ff e5 	b  4001310c <fat_file_mark_removed+0x38>       <== NOT EXECUTED
4001317c:	ba 10 20 01 	mov  1, %i5                                    <== NOT EXECUTED
                                                                      

400124a8 <fat_file_open>: fat_file_open( fat_fs_info_t *fs_info, fat_dir_pos_t *dir_pos, fat_file_fd_t **fat_fd ) {
400124a8:	9d e3 bf a0 	save  %sp, -96, %sp                            
static inline uint32_t                                                
fat_construct_key(                                                    
    const fat_fs_info_t                  *fs_info,                    
    fat_pos_t                            *pos)                        
{                                                                     
    return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +  
400124ac:	c2 06 40 00 	ld  [ %i1 ], %g1                               
fat_cluster_num_to_sector512_num(                                     
    const fat_fs_info_t *fs_info,                                     
    uint32_t             cln                                          
    )                                                                 
{                                                                     
    if (cln == 1)                                                     
400124b0:	80 a0 60 01 	cmp  %g1, 1                                    
400124b4:	02 80 00 9c 	be  40012724 <fat_file_open+0x27c>             
400124b8:	80 a0 60 00 	cmp  %g1, 0                                    
fat_cluster_num_to_sector_num(                                        
    const fat_fs_info_t *fs_info,                                     
    uint32_t             cln                                          
    )                                                                 
{                                                                     
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
400124bc:	32 80 00 7b 	bne,a   400126a8 <fat_file_open+0x200>         
400124c0:	c6 0e 20 05 	ldub  [ %i0 + 5 ], %g3                         
400124c4:	c4 0e 20 0e 	ldub  [ %i0 + 0xe ], %g2                       
400124c8:	80 88 a0 03 	btst  3, %g2                                   
400124cc:	22 80 00 77 	be,a   400126a8 <fat_file_open+0x200>          <== NEVER TAKEN
400124d0:	c6 0e 20 05 	ldub  [ %i0 + 5 ], %g3                         <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
400124d4:	fa 06 20 20 	ld  [ %i0 + 0x20 ], %i5                        
    )                                                                 
{                                                                     
    if (cln == 1)                                                     
        return 1;                                                     
                                                                      
    return (fat_cluster_num_to_sector_num(fs_info, cln) <<            
400124d8:	c4 0e 20 03 	ldub  [ %i0 + 3 ], %g2                         
400124dc:	bb 2f 40 02 	sll  %i5, %g2, %i5                             
              (pos->ofs >> FAT_SECTOR512_BITS)) << 4)              +  
400124e0:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
    uint32_t                               key2,                      
    fat_file_fd_t                          **ret                      
    )                                                                 
{                                                                     
    uint32_t          mod = (key1) % FAT_HASH_MODULE;                 
    rtems_chain_node *the_node = rtems_chain_first(hash + mod);       
400124e4:	de 06 20 6c 	ld  [ %i0 + 0x6c ], %o7                        
400124e8:	85 30 60 09 	srl  %g1, 9, %g2                               
              ((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );  
400124ec:	83 30 60 05 	srl  %g1, 5, %g1                               
400124f0:	82 08 60 0f 	and  %g1, 0xf, %g1                             
static inline uint32_t                                                
fat_construct_key(                                                    
    const fat_fs_info_t                  *fs_info,                    
    fat_pos_t                            *pos)                        
{                                                                     
    return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +  
400124f4:	ba 07 40 02 	add  %i5, %g2, %i5                             
              (pos->ofs >> FAT_SECTOR512_BITS)) << 4)              +  
400124f8:	bb 2f 60 04 	sll  %i5, 4, %i5                               
static inline uint32_t                                                
fat_construct_key(                                                    
    const fat_fs_info_t                  *fs_info,                    
    fat_pos_t                            *pos)                        
{                                                                     
    return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +  
400124fc:	ba 07 40 01 	add  %i5, %g1, %i5                             
    uint32_t                               key1,                      
    uint32_t                               key2,                      
    fat_file_fd_t                          **ret                      
    )                                                                 
{                                                                     
    uint32_t          mod = (key1) % FAT_HASH_MODULE;                 
40012500:	82 0f 60 01 	and  %i5, 1, %g1                               
    rtems_chain_node *the_node = rtems_chain_first(hash + mod);       
40012504:	85 28 60 02 	sll  %g1, 2, %g2                               
40012508:	b7 28 60 04 	sll  %g1, 4, %i3                               
4001250c:	b6 26 c0 02 	sub  %i3, %g2, %i3                             
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return _Chain_Head( the_chain )->next;                              
40012510:	c2 03 c0 1b 	ld  [ %o7 + %i3 ], %g1                         
40012514:	9e 03 c0 1b 	add  %o7, %i3, %o7                             
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(                             
  const Chain_Control *the_chain,                                     
  const Chain_Node    *the_node                                       
)                                                                     
{                                                                     
  return (the_node == _Chain_Immutable_tail( the_chain ));            
40012518:	9e 03 e0 04 	add  %o7, 4, %o7                               
                                                                      
    for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )          
4001251c:	80 a0 40 0f 	cmp  %g1, %o7                                  
40012520:	22 80 00 1e 	be,a   40012598 <fat_file_open+0xf0>           
40012524:	c4 06 20 70 	ld  [ %i0 + 0x70 ], %g2                        
40012528:	c4 00 60 20 	ld  [ %g1 + 0x20 ], %g2                        
fat_cluster_num_to_sector512_num(                                     
    const fat_fs_info_t *fs_info,                                     
    uint32_t             cln                                          
    )                                                                 
{                                                                     
    if (cln == 1)                                                     
4001252c:	80 a0 a0 01 	cmp  %g2, 1                                    
40012530:	02 80 00 6d 	be  400126e4 <fat_file_open+0x23c>             
40012534:	80 a0 a0 00 	cmp  %g2, 0                                    
fat_cluster_num_to_sector_num(                                        
    const fat_fs_info_t *fs_info,                                     
    uint32_t             cln                                          
    )                                                                 
{                                                                     
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
40012538:	32 80 00 61 	bne,a   400126bc <fat_file_open+0x214>         
4001253c:	c8 0e 20 05 	ldub  [ %i0 + 5 ], %g4                         
40012540:	c6 0e 20 0e 	ldub  [ %i0 + 0xe ], %g3                       
40012544:	80 88 e0 03 	btst  3, %g3                                   
40012548:	22 80 00 5d 	be,a   400126bc <fat_file_open+0x214>          <== NEVER TAKEN
4001254c:	c8 0e 20 05 	ldub  [ %i0 + 5 ], %g4                         <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
40012550:	f8 06 20 20 	ld  [ %i0 + 0x20 ], %i4                        
    )                                                                 
{                                                                     
    if (cln == 1)                                                     
        return 1;                                                     
                                                                      
    return (fat_cluster_num_to_sector_num(fs_info, cln) <<            
40012554:	c6 0e 20 03 	ldub  [ %i0 + 3 ], %g3                         
40012558:	b9 2f 00 03 	sll  %i4, %g3, %i4                             
              (pos->ofs >> FAT_SECTOR512_BITS)) << 4)              +  
4001255c:	c6 00 60 24 	ld  [ %g1 + 0x24 ], %g3                        
              ((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );  
40012560:	85 30 e0 05 	srl  %g3, 5, %g2                               
fat_construct_key(                                                    
    const fat_fs_info_t                  *fs_info,                    
    fat_pos_t                            *pos)                        
{                                                                     
    return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +  
              (pos->ofs >> FAT_SECTOR512_BITS)) << 4)              +  
40012564:	89 30 e0 09 	srl  %g3, 9, %g4                               
              ((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );  
40012568:	84 08 a0 0f 	and  %g2, 0xf, %g2                             
static inline uint32_t                                                
fat_construct_key(                                                    
    const fat_fs_info_t                  *fs_info,                    
    fat_pos_t                            *pos)                        
{                                                                     
    return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +  
4001256c:	86 07 00 04 	add  %i4, %g4, %g3                             
              (pos->ofs >> FAT_SECTOR512_BITS)) << 4)              +  
40012570:	87 28 e0 04 	sll  %g3, 4, %g3                               
static inline uint32_t                                                
fat_construct_key(                                                    
    const fat_fs_info_t                  *fs_info,                    
    fat_pos_t                            *pos)                        
{                                                                     
    return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +  
40012574:	86 00 c0 02 	add  %g3, %g2, %g3                             
    {                                                                 
        fat_file_fd_t *ffd = (fat_file_fd_t *)the_node;               
        uint32_t       ck =  fat_construct_key(fs_info, &ffd->dir_pos.sname);
                                                                      
        if ( (key1) == ck)                                            
40012578:	80 a7 40 03 	cmp  %i5, %g3                                  
4001257c:	22 80 00 55 	be,a   400126d0 <fat_file_open+0x228>          
40012580:	c4 00 60 08 	ld  [ %g1 + 8 ], %g2                           
            {                                                         
                *ret = (void *)the_node;                              
                return 0;                                             
            }                                                         
        }                                                             
        the_node = the_node->next;                                    
40012584:	c2 00 40 00 	ld  [ %g1 ], %g1                               
    )                                                                 
{                                                                     
    uint32_t          mod = (key1) % FAT_HASH_MODULE;                 
    rtems_chain_node *the_node = rtems_chain_first(hash + mod);       
                                                                      
    for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )          
40012588:	80 a3 c0 01 	cmp  %o7, %g1                                  
4001258c:	32 bf ff e8 	bne,a   4001252c <fat_file_open+0x84>          
40012590:	c4 00 60 20 	ld  [ %g1 + 0x20 ], %g2                        
    uint32_t                               key2,                      
    fat_file_fd_t                          **ret                      
    )                                                                 
{                                                                     
    uint32_t          mod = (key1) % FAT_HASH_MODULE;                 
    rtems_chain_node *the_node = rtems_chain_first(hash + mod);       
40012594:	c4 06 20 70 	ld  [ %i0 + 0x70 ], %g2                        
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return _Chain_Head( the_chain )->next;                              
40012598:	c2 00 80 1b 	ld  [ %g2 + %i3 ], %g1                         
4001259c:	84 00 80 1b 	add  %g2, %i3, %g2                             
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(                             
  const Chain_Control *the_chain,                                     
  const Chain_Node    *the_node                                       
)                                                                     
{                                                                     
  return (the_node == _Chain_Immutable_tail( the_chain ));            
400125a0:	9e 00 a0 04 	add  %g2, 4, %o7                               
                                                                      
    for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )          
400125a4:	80 a0 40 0f 	cmp  %g1, %o7                                  
400125a8:	02 80 00 1e 	be  40012620 <fat_file_open+0x178>             <== ALWAYS TAKEN
400125ac:	a0 10 3f ff 	mov  -1, %l0                                   
400125b0:	c4 00 60 20 	ld  [ %g1 + 0x20 ], %g2                        <== NOT EXECUTED
fat_cluster_num_to_sector512_num(                                     
    const fat_fs_info_t *fs_info,                                     
    uint32_t             cln                                          
    )                                                                 
{                                                                     
    if (cln == 1)                                                     
400125b4:	80 a0 a0 01 	cmp  %g2, 1                                    <== NOT EXECUTED
400125b8:	02 80 00 59 	be  4001271c <fat_file_open+0x274>             <== NOT EXECUTED
400125bc:	80 a0 a0 00 	cmp  %g2, 0                                    <== NOT EXECUTED
fat_cluster_num_to_sector_num(                                        
    const fat_fs_info_t *fs_info,                                     
    uint32_t             cln                                          
    )                                                                 
{                                                                     
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
400125c0:	32 80 00 4b 	bne,a   400126ec <fat_file_open+0x244>         <== NOT EXECUTED
400125c4:	c6 0e 20 05 	ldub  [ %i0 + 5 ], %g3                         <== NOT EXECUTED
400125c8:	c6 0e 20 0e 	ldub  [ %i0 + 0xe ], %g3                       <== NOT EXECUTED
400125cc:	80 88 e0 03 	btst  3, %g3                                   <== NOT EXECUTED
400125d0:	22 80 00 47 	be,a   400126ec <fat_file_open+0x244>          <== NOT EXECUTED
400125d4:	c6 0e 20 05 	ldub  [ %i0 + 5 ], %g3                         <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
400125d8:	f8 06 20 20 	ld  [ %i0 + 0x20 ], %i4                        <== NOT EXECUTED
    )                                                                 
{                                                                     
    if (cln == 1)                                                     
        return 1;                                                     
                                                                      
    return (fat_cluster_num_to_sector_num(fs_info, cln) <<            
400125dc:	c8 0e 20 03 	ldub  [ %i0 + 3 ], %g4                         <== NOT EXECUTED
400125e0:	b9 2f 00 04 	sll  %i4, %g4, %i4                             <== NOT EXECUTED
              (pos->ofs >> FAT_SECTOR512_BITS)) << 4)              +  
400125e4:	c6 00 60 24 	ld  [ %g1 + 0x24 ], %g3                        <== NOT EXECUTED
              ((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );  
400125e8:	85 30 e0 05 	srl  %g3, 5, %g2                               <== NOT EXECUTED
fat_construct_key(                                                    
    const fat_fs_info_t                  *fs_info,                    
    fat_pos_t                            *pos)                        
{                                                                     
    return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +  
              (pos->ofs >> FAT_SECTOR512_BITS)) << 4)              +  
400125ec:	89 30 e0 09 	srl  %g3, 9, %g4                               <== NOT EXECUTED
              ((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );  
400125f0:	84 08 a0 0f 	and  %g2, 0xf, %g2                             <== NOT EXECUTED
static inline uint32_t                                                
fat_construct_key(                                                    
    const fat_fs_info_t                  *fs_info,                    
    fat_pos_t                            *pos)                        
{                                                                     
    return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +  
400125f4:	86 07 00 04 	add  %i4, %g4, %g3                             <== NOT EXECUTED
              (pos->ofs >> FAT_SECTOR512_BITS)) << 4)              +  
400125f8:	87 28 e0 04 	sll  %g3, 4, %g3                               <== NOT EXECUTED
static inline uint32_t                                                
fat_construct_key(                                                    
    const fat_fs_info_t                  *fs_info,                    
    fat_pos_t                            *pos)                        
{                                                                     
    return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +  
400125fc:	86 00 c0 02 	add  %g3, %g2, %g3                             <== NOT EXECUTED
    {                                                                 
        fat_file_fd_t *ffd = (fat_file_fd_t *)the_node;               
        uint32_t       ck =  fat_construct_key(fs_info, &ffd->dir_pos.sname);
                                                                      
        if ( (key1) == ck)                                            
40012600:	80 a7 40 03 	cmp  %i5, %g3                                  <== NOT EXECUTED
40012604:	02 80 00 3f 	be  40012700 <fat_file_open+0x258>             <== NOT EXECUTED
40012608:	80 a7 60 00 	cmp  %i5, 0                                    <== NOT EXECUTED
            {                                                         
                *ret = (void *)the_node;                              
                return 0;                                             
            }                                                         
        }                                                             
        the_node = the_node->next;                                    
4001260c:	c2 00 40 00 	ld  [ %g1 ], %g1                               <== NOT EXECUTED
    )                                                                 
{                                                                     
    uint32_t          mod = (key1) % FAT_HASH_MODULE;                 
    rtems_chain_node *the_node = rtems_chain_first(hash + mod);       
                                                                      
    for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )          
40012610:	80 a0 40 0f 	cmp  %g1, %o7                                  <== NOT EXECUTED
40012614:	32 bf ff e8 	bne,a   400125b4 <fat_file_open+0x10c>         <== NOT EXECUTED
40012618:	c4 00 60 20 	ld  [ %g1 + 0x20 ], %g2                        <== NOT EXECUTED
                return 0;                                             
            }                                                         
        }                                                             
        the_node = the_node->next;                                    
    }                                                                 
    return -1;                                                        
4001261c:	a0 10 3f ff 	mov  -1, %l0                                   <== NOT EXECUTED
    }                                                                 
                                                                      
    /* access "removed-but-still-open" hash table */                  
    rc = _hash_search(fs_info, fs_info->rhash, key, key, &lfat_fd);   
                                                                      
    lfat_fd = (*fat_fd) = (fat_file_fd_t*)malloc(sizeof(fat_file_fd_t));
40012620:	7f ff ca b6 	call  400050f8 <malloc>                        
40012624:	90 10 20 44 	mov  0x44, %o0                                 
40012628:	d0 26 80 00 	st  %o0, [ %i2 ]                               
    if ( lfat_fd == NULL )                                            
4001262c:	80 a2 20 00 	cmp  %o0, 0                                    
40012630:	02 80 00 46 	be  40012748 <fat_file_open+0x2a0>             <== NEVER TAKEN
40012634:	b8 10 00 08 	mov  %o0, %i4                                  
        rtems_set_errno_and_return_minus_one( ENOMEM );               
                                                                      
    memset(lfat_fd, 0, sizeof(fat_file_fd_t));                        
40012638:	92 10 20 00 	clr  %o1                                       
4001263c:	40 00 2a 37 	call  4001cf18 <memset>                        
40012640:	94 10 20 44 	mov  0x44, %o2                                 
                                                                      
    lfat_fd->links_num = 1;                                           
    lfat_fd->flags &= ~FAT_FILE_REMOVED;                              
40012644:	de 0f 20 30 	ldub  [ %i4 + 0x30 ], %o7                      
    lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;                      
                                                                      
    lfat_fd->dir_pos = *dir_pos;                                      
40012648:	c8 06 40 00 	ld  [ %i1 ], %g4                               
4001264c:	c6 06 60 04 	ld  [ %i1 + 4 ], %g3                           
40012650:	c4 06 60 08 	ld  [ %i1 + 8 ], %g2                           
40012654:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
        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;                              
40012658:	b2 0b ff fe 	and  %o7, -2, %i1                              
    lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;                      
                                                                      
    lfat_fd->dir_pos = *dir_pos;                                      
4001265c:	c8 27 20 20 	st  %g4, [ %i4 + 0x20 ]                        
    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;                                           
40012660:	9e 10 20 01 	mov  1, %o7                                    
    lfat_fd->flags &= ~FAT_FILE_REMOVED;                              
40012664:	f2 2f 20 30 	stb  %i1, [ %i4 + 0x30 ]                       
    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;                                           
40012668:	de 27 20 08 	st  %o7, [ %i4 + 8 ]                           
    lfat_fd->flags &= ~FAT_FILE_REMOVED;                              
    lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;                      
4001266c:	b2 10 3f ff 	mov  -1, %i1                                   
                                                                      
    lfat_fd->dir_pos = *dir_pos;                                      
40012670:	c6 27 20 24 	st  %g3, [ %i4 + 0x24 ]                        
                                                                      
    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;                      
40012674:	f2 27 20 3c 	st  %i1, [ %i4 + 0x3c ]                        
                                                                      
    lfat_fd->dir_pos = *dir_pos;                                      
40012678:	c4 27 20 28 	st  %g2, [ %i4 + 0x28 ]                        
                                                                      
    if ( rc != RC_OK )                                                
4001267c:	80 a4 20 00 	cmp  %l0, 0                                    
40012680:	02 80 00 2b 	be  4001272c <fat_file_open+0x284>             <== NEVER TAKEN
40012684:	c2 27 20 2c 	st  %g1, [ %i4 + 0x2c ]                        
        lfat_fd->ino = key;                                           
40012688:	fa 27 20 0c 	st  %i5, [ %i4 + 0xc ]                         
 */                                                                   
static inline void                                                    
_hash_insert(rtems_chain_control *hash, uint32_t   key1, uint32_t   key2,
             fat_file_fd_t *el)                                       
{                                                                     
    rtems_chain_append((hash) + ((key1) % FAT_HASH_MODULE), &(el)->link);
4001268c:	d0 06 20 6c 	ld  [ %i0 + 0x6c ], %o0                        
RTEMS_INLINE_ROUTINE void rtems_chain_append(                         
  rtems_chain_control *the_chain,                                     
  rtems_chain_node    *the_node                                       
)                                                                     
{                                                                     
  _Chain_Append( the_chain, the_node );                               
40012690:	92 10 00 1c 	mov  %i4, %o1                                  
40012694:	90 02 00 1b 	add  %o0, %i3, %o0                             
40012698:	7f ff de 29 	call  40009f3c <_Chain_Append>                 
4001269c:	b0 10 20 00 	clr  %i0                                       
400126a0:	81 c7 e0 08 	ret                                            
400126a4:	81 e8 00 00 	restore                                        
    )                                                                 
{                                                                     
    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) +        
400126a8:	c4 06 20 34 	ld  [ %i0 + 0x34 ], %g2                        
400126ac:	ba 00 7f fe 	add  %g1, -2, %i5                              
400126b0:	bb 2f 40 03 	sll  %i5, %g3, %i5                             
400126b4:	10 bf ff 89 	b  400124d8 <fat_file_open+0x30>               
400126b8:	ba 07 40 02 	add  %i5, %g2, %i5                             
400126bc:	c6 06 20 34 	ld  [ %i0 + 0x34 ], %g3                        
400126c0:	b8 00 bf fe 	add  %g2, -2, %i4                              
400126c4:	b9 2f 00 04 	sll  %i4, %g4, %i4                             
400126c8:	10 bf ff a3 	b  40012554 <fat_file_open+0xac>               
400126cc:	b8 07 00 03 	add  %i4, %g3, %i4                             
    /* access "valid" hash table */                                   
    rc = _hash_search(fs_info, fs_info->vhash, key, 0, &lfat_fd);     
    if ( rc == RC_OK )                                                
    {                                                                 
        /* return pointer to fat_file_descriptor allocated before */  
        (*fat_fd) = lfat_fd;                                          
400126d0:	c2 26 80 00 	st  %g1, [ %i2 ]                               
        lfat_fd->links_num++;                                         
400126d4:	84 00 a0 01 	inc  %g2                                       
400126d8:	c4 20 60 08 	st  %g2, [ %g1 + 8 ]                           
400126dc:	81 c7 e0 08 	ret                                            
400126e0:	91 e8 20 00 	restore  %g0, 0, %o0                           
    const fat_fs_info_t *fs_info,                                     
    uint32_t             cln                                          
    )                                                                 
{                                                                     
    if (cln == 1)                                                     
        return 1;                                                     
400126e4:	10 bf ff 9e 	b  4001255c <fat_file_open+0xb4>               
400126e8:	b8 10 20 01 	mov  1, %i4                                    
    )                                                                 
{                                                                     
    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) +        
400126ec:	c8 06 20 34 	ld  [ %i0 + 0x34 ], %g4                        <== NOT EXECUTED
400126f0:	b8 00 bf fe 	add  %g2, -2, %i4                              <== NOT EXECUTED
400126f4:	b9 2f 00 03 	sll  %i4, %g3, %i4                             <== NOT EXECUTED
400126f8:	10 bf ff b9 	b  400125dc <fat_file_open+0x134>              <== NOT EXECUTED
400126fc:	b8 07 00 04 	add  %i4, %g4, %i4                             <== NOT EXECUTED
        fat_file_fd_t *ffd = (fat_file_fd_t *)the_node;               
        uint32_t       ck =  fat_construct_key(fs_info, &ffd->dir_pos.sname);
                                                                      
        if ( (key1) == ck)                                            
        {                                                             
            if ( ((key2) == 0) || ((key2) == ffd->ino) )              
40012700:	02 bf ff c8 	be  40012620 <fat_file_open+0x178>             <== NOT EXECUTED
40012704:	a0 10 20 00 	clr  %l0                                       <== NOT EXECUTED
40012708:	c4 00 60 0c 	ld  [ %g1 + 0xc ], %g2                         <== NOT EXECUTED
4001270c:	80 a7 40 02 	cmp  %i5, %g2                                  <== NOT EXECUTED
40012710:	32 bf ff c0 	bne,a   40012610 <fat_file_open+0x168>         <== NOT EXECUTED
40012714:	c2 00 40 00 	ld  [ %g1 ], %g1                               <== NOT EXECUTED
40012718:	30 bf ff c2 	b,a   40012620 <fat_file_open+0x178>           <== NOT EXECUTED
    const fat_fs_info_t *fs_info,                                     
    uint32_t             cln                                          
    )                                                                 
{                                                                     
    if (cln == 1)                                                     
        return 1;                                                     
4001271c:	10 bf ff b2 	b  400125e4 <fat_file_open+0x13c>              <== NOT EXECUTED
40012720:	b8 10 20 01 	mov  1, %i4                                    <== NOT EXECUTED
40012724:	10 bf ff 6f 	b  400124e0 <fat_file_open+0x38>               
40012728:	ba 10 20 01 	mov  1, %i5                                    
                                                                      
    if ( rc != RC_OK )                                                
        lfat_fd->ino = key;                                           
    else                                                              
    {                                                                 
        lfat_fd->ino = fat_get_unique_ino(fs_info);                   
4001272c:	40 00 07 23 	call  400143b8 <fat_get_unique_ino>            <== NOT EXECUTED
40012730:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
                                                                      
        if ( lfat_fd->ino == 0 )                                      
40012734:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40012738:	12 bf ff d5 	bne  4001268c <fat_file_open+0x1e4>            <== NOT EXECUTED
4001273c:	d0 27 20 0c 	st  %o0, [ %i4 + 0xc ]                         <== NOT EXECUTED
        {                                                             
            free((*fat_fd));                                          
40012740:	7f ff c9 1b 	call  40004bac <free>                          <== NOT EXECUTED
40012744:	d0 06 80 00 	ld  [ %i2 ], %o0                               <== 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 );           
40012748:	40 00 27 12 	call  4001c390 <__errno>                       <== NOT EXECUTED
4001274c:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40012750:	82 10 20 0c 	mov  0xc, %g1                                  <== NOT EXECUTED
40012754:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
40012758:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001275c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40012778 <fat_file_read>: fat_file_fd_t *fat_fd, uint32_t start, uint32_t count, uint8_t *buf ) {
40012778:	9d e3 bf 98 	save  %sp, -104, %sp                           
    int            rc = RC_OK;                                        
    ssize_t        ret = 0;                                           
    uint32_t       cmpltd = 0;                                        
    uint32_t       cur_cln = 0;                                       
4001277c:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
    fat_file_fd_t                        *fat_fd,                     
    uint32_t                              start,                      
    uint32_t                              count,                      
    uint8_t                              *buf                         
)                                                                     
{                                                                     
40012780:	ba 10 00 18 	mov  %i0, %i5                                  
    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)                                                   
40012784:	80 a6 e0 00 	cmp  %i3, 0                                    
40012788:	02 80 00 7f 	be  40012984 <fat_file_read+0x20c>             <== NEVER TAKEN
4001278c:	b0 10 20 00 	clr  %i0                                       
                                                                      
    /*                                                                
     * >= because start is offset and computed from 0 and file_size   
     * computed from 1                                                
     */                                                               
    if ( start >= fat_fd->fat_file_size )                             
40012790:	c2 06 60 18 	ld  [ %i1 + 0x18 ], %g1                        
40012794:	80 a0 40 1a 	cmp  %g1, %i2                                  
40012798:	08 80 00 7b 	bleu  40012984 <fat_file_read+0x20c>           
4001279c:	80 a6 c0 01 	cmp  %i3, %g1                                  
        return FAT_EOF;                                               
                                                                      
    if ((count > fat_fd->fat_file_size) ||                            
400127a0:	08 80 00 4c 	bleu  400128d0 <fat_file_read+0x158>           <== ALWAYS TAKEN
400127a4:	84 20 40 1b 	sub  %g1, %i3, %g2                             
        (start > fat_fd->fat_file_size - count))                      
        count = fat_fd->fat_file_size - start;                        
400127a8:	b6 20 40 1a 	sub  %g1, %i2, %i3                             <== NOT EXECUTED
                                                                      
    if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&                               
400127ac:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
400127b0:	80 a0 60 01 	cmp  %g1, 1                                    
400127b4:	22 80 00 4c 	be,a   400128e4 <fat_file_read+0x16c>          
400127b8:	c2 06 60 24 	ld  [ %i1 + 0x24 ], %g1                        
            return -1;                                                
                                                                      
        return ret;                                                   
    }                                                                 
                                                                      
    cl_start = start >> fs_info->vol.bpc_log2;                        
400127bc:	e4 0f 60 08 	ldub  [ %i5 + 8 ], %l2                         
    save_ofs = ofs = start & (fs_info->vol.bpc - 1);                  
400127c0:	e0 17 60 06 	lduh  [ %i5 + 6 ], %l0                         
            return -1;                                                
                                                                      
        return ret;                                                   
    }                                                                 
                                                                      
    cl_start = start >> fs_info->vol.bpc_log2;                        
400127c4:	a5 36 80 12 	srl  %i2, %l2, %l2                             
    save_ofs = ofs = start & (fs_info->vol.bpc - 1);                  
                                                                      
    rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);         
400127c8:	90 10 00 1d 	mov  %i5, %o0                                  
400127cc:	92 10 00 19 	mov  %i1, %o1                                  
400127d0:	94 10 00 12 	mov  %l2, %o2                                  
400127d4:	7f ff ff 06 	call  400123ec <fat_file_lseek>                
400127d8:	96 07 bf fc 	add  %fp, -4, %o3                              
    if (rc != RC_OK)                                                  
400127dc:	b0 92 60 00 	orcc  %o1, 0, %i0                              
400127e0:	12 80 00 69 	bne  40012984 <fat_file_read+0x20c>            <== NEVER TAKEN
400127e4:	a1 2c 20 10 	sll  %l0, 0x10, %l0                            
        return rc;                                                    
                                                                      
    while (count > 0)                                                 
400127e8:	a6 10 20 00 	clr  %l3                                       
                                                                      
        return ret;                                                   
    }                                                                 
                                                                      
    cl_start = start >> fs_info->vol.bpc_log2;                        
    save_ofs = ofs = start & (fs_info->vol.bpc - 1);                  
400127ec:	a1 34 20 10 	srl  %l0, 0x10, %l0                            
                                                                      
    rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);         
    if (rc != RC_OK)                                                  
        return rc;                                                    
                                                                      
    while (count > 0)                                                 
400127f0:	a2 10 20 00 	clr  %l1                                       
                                                                      
        return ret;                                                   
    }                                                                 
                                                                      
    cl_start = start >> fs_info->vol.bpc_log2;                        
    save_ofs = ofs = start & (fs_info->vol.bpc - 1);                  
400127f4:	a0 04 3f ff 	add  %l0, -1, %l0                              
                                                                      
    rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);         
    if (rc != RC_OK)                                                  
        return rc;                                                    
                                                                      
    while (count > 0)                                                 
400127f8:	80 a6 e0 00 	cmp  %i3, 0                                    
400127fc:	02 80 00 5b 	be  40012968 <fat_file_read+0x1f0>             <== NEVER TAKEN
40012800:	b4 0e 80 10 	and  %i2, %l0, %i2                             
40012804:	c6 0f 60 02 	ldub  [ %i5 + 2 ], %g3                         
40012808:	c8 17 40 00 	lduh  [ %i5 ], %g4                             
4001280c:	10 80 00 20 	b  4001288c <fat_file_read+0x114>              
40012810:	94 10 00 1a 	mov  %i2, %o2                                  
fat_cluster_num_to_sector_num(                                        
    const fat_fs_info_t *fs_info,                                     
    uint32_t             cln                                          
    )                                                                 
{                                                                     
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
40012814:	80 8e 20 03 	btst  3, %i0                                   <== NOT EXECUTED
40012818:	22 80 00 27 	be,a   400128b4 <fat_file_read+0x13c>          <== NOT EXECUTED
4001281c:	de 0f 60 05 	ldub  [ %i5 + 5 ], %o7                         <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
40012820:	d2 07 60 20 	ld  [ %i5 + 0x20 ], %o1                        <== NOT EXECUTED
    {                                                                 
        c = MIN(count, (fs_info->vol.bpc - ofs));                     
                                                                      
        sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);        
        sec += (ofs >> fs_info->vol.sec_log2);                        
40012824:	87 32 80 03 	srl  %o2, %g3, %g3                             
        byte = ofs & (fs_info->vol.bps - 1);                          
40012828:	85 29 20 10 	sll  %g4, 0x10, %g2                            
4001282c:	85 30 a0 10 	srl  %g2, 0x10, %g2                            
40012830:	84 00 bf ff 	add  %g2, -1, %g2                              
                                                                      
        ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd);   
40012834:	98 07 00 11 	add  %i4, %l1, %o4                             
40012838:	94 0a 80 02 	and  %o2, %g2, %o2                             
4001283c:	92 02 40 03 	add  %o1, %g3, %o1                             
40012840:	96 10 00 10 	mov  %l0, %o3                                  
40012844:	40 00 03 25 	call  400134d8 <_fat_block_read>               
40012848:	90 10 00 1d 	mov  %i5, %o0                                  
            return -1;                                                
                                                                      
        count -= c;                                                   
        cmpltd += c;                                                  
        save_cln = cur_cln;                                           
        rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);         
4001284c:	94 07 bf fc 	add  %fp, -4, %o2                              
        sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);        
        sec += (ofs >> fs_info->vol.sec_log2);                        
        byte = ofs & (fs_info->vol.bps - 1);                          
                                                                      
        ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd);   
        if ( ret < 0 )                                                
40012850:	80 a2 20 00 	cmp  %o0, 0                                    
40012854:	06 80 00 3d 	bl  40012948 <fat_file_read+0x1d0>             <== NEVER TAKEN
40012858:	90 10 00 1d 	mov  %i5, %o0                                  
            return -1;                                                
                                                                      
        count -= c;                                                   
        cmpltd += c;                                                  
        save_cln = cur_cln;                                           
4001285c:	e6 07 bf fc 	ld  [ %fp + -4 ], %l3                          
                                                                      
        ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd);   
        if ( ret < 0 )                                                
            return -1;                                                
                                                                      
        count -= c;                                                   
40012860:	b6 26 c0 10 	sub  %i3, %l0, %i3                             
        cmpltd += c;                                                  
        save_cln = cur_cln;                                           
        rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);         
40012864:	92 10 00 13 	mov  %l3, %o1                                  
40012868:	40 00 1e 35 	call  4001a13c <fat_get_fat_cluster>           
4001286c:	a2 04 40 10 	add  %l1, %l0, %l1                             
        if ( rc != RC_OK )                                            
40012870:	80 a2 20 00 	cmp  %o0, 0                                    
40012874:	12 80 00 15 	bne  400128c8 <fat_file_read+0x150>            <== NEVER TAKEN
40012878:	80 a6 e0 00 	cmp  %i3, 0                                    
                                                                      
    rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);         
    if (rc != RC_OK)                                                  
        return rc;                                                    
                                                                      
    while (count > 0)                                                 
4001287c:	02 80 00 3a 	be  40012964 <fat_file_read+0x1ec>             
40012880:	94 10 20 00 	clr  %o2                                       
40012884:	c6 0f 60 02 	ldub  [ %i5 + 2 ], %g3                         
40012888:	c8 17 40 00 	lduh  [ %i5 ], %g4                             
    {                                                                 
        c = MIN(count, (fs_info->vol.bpc - ofs));                     
4001288c:	e0 17 60 06 	lduh  [ %i5 + 6 ], %l0                         
40012890:	a0 24 00 0a 	sub  %l0, %o2, %l0                             
40012894:	80 a4 00 1b 	cmp  %l0, %i3                                  
40012898:	08 80 00 03 	bleu  400128a4 <fat_file_read+0x12c>           
4001289c:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
400128a0:	a0 10 00 1b 	mov  %i3, %l0                                  
fat_cluster_num_to_sector_num(                                        
    const fat_fs_info_t *fs_info,                                     
    uint32_t             cln                                          
    )                                                                 
{                                                                     
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
400128a4:	80 a0 a0 00 	cmp  %g2, 0                                    
400128a8:	22 bf ff db 	be,a   40012814 <fat_file_read+0x9c>           <== NEVER TAKEN
400128ac:	f0 0f 60 0e 	ldub  [ %i5 + 0xe ], %i0                       <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
                                                                      
    return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +        
400128b0:	de 0f 60 05 	ldub  [ %i5 + 5 ], %o7                         
400128b4:	f0 07 60 34 	ld  [ %i5 + 0x34 ], %i0                        
400128b8:	92 00 bf fe 	add  %g2, -2, %o1                              
400128bc:	93 2a 40 0f 	sll  %o1, %o7, %o1                             
400128c0:	10 bf ff d9 	b  40012824 <fat_file_read+0xac>               
400128c4:	92 02 40 18 	add  %o1, %i0, %o1                             
    fat_fd->map.file_cln = cl_start +                                 
                           ((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
    fat_fd->map.disk_cln = save_cln;                                  
                                                                      
    return cmpltd;                                                    
}                                                                     
400128c8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400128cc:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
     * computed from 1                                                
     */                                                               
    if ( start >= fat_fd->fat_file_size )                             
        return FAT_EOF;                                               
                                                                      
    if ((count > fat_fd->fat_file_size) ||                            
400128d0:	80 a6 80 02 	cmp  %i2, %g2                                  
400128d4:	28 bf ff b7 	bleu,a   400127b0 <fat_file_read+0x38>         
400128d8:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
        (start > fat_fd->fat_file_size - count))                      
        count = fat_fd->fat_file_size - start;                        
400128dc:	10 bf ff b4 	b  400127ac <fat_file_read+0x34>               
400128e0:	b6 20 40 1a 	sub  %g1, %i2, %i3                             
                                                                      
    if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&                               
400128e4:	80 a0 60 00 	cmp  %g1, 0                                    
400128e8:	32 bf ff b6 	bne,a   400127c0 <fat_file_read+0x48>          <== NEVER TAKEN
400128ec:	e4 0f 60 08 	ldub  [ %i5 + 8 ], %l2                         <== NOT EXECUTED
        (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))                
400128f0:	c2 0f 60 0e 	ldub  [ %i5 + 0xe ], %g1                       
                                                                      
    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)) &&                               
400128f4:	80 88 60 03 	btst  3, %g1                                   
400128f8:	22 bf ff b2 	be,a   400127c0 <fat_file_read+0x48>           
400128fc:	e4 0f 60 08 	ldub  [ %i5 + 8 ], %l2                         
        (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))                
    {                                                                 
        sec = fat_cluster_num_to_sector_num(fs_info, fat_fd->cln);    
40012900:	c2 06 60 1c 	ld  [ %i1 + 0x1c ], %g1                        
fat_cluster_num_to_sector_num(                                        
    const fat_fs_info_t *fs_info,                                     
    uint32_t             cln                                          
    )                                                                 
{                                                                     
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
40012904:	80 a0 60 00 	cmp  %g1, 0                                    
40012908:	32 80 00 12 	bne,a   40012950 <fat_file_read+0x1d8>         <== NEVER TAKEN
4001290c:	c6 0f 60 05 	ldub  [ %i5 + 5 ], %g3                         <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
40012910:	d2 07 60 20 	ld  [ %i5 + 0x20 ], %o1                        
        sec += (start >> fs_info->vol.sec_log2);                      
40012914:	c2 0f 60 02 	ldub  [ %i5 + 2 ], %g1                         
        byte = start & (fs_info->vol.bps - 1);                        
40012918:	d4 17 40 00 	lduh  [ %i5 ], %o2                             
                                                                      
    if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&                               
        (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))                
    {                                                                 
        sec = fat_cluster_num_to_sector_num(fs_info, fat_fd->cln);    
        sec += (start >> fs_info->vol.sec_log2);                      
4001291c:	83 36 80 01 	srl  %i2, %g1, %g1                             
        byte = start & (fs_info->vol.bps - 1);                        
40012920:	94 02 bf ff 	add  %o2, -1, %o2                              
                                                                      
        ret = _fat_block_read(fs_info, sec, byte, count, buf);        
40012924:	90 10 00 1d 	mov  %i5, %o0                                  
40012928:	92 02 40 01 	add  %o1, %g1, %o1                             
4001292c:	94 0e 80 0a 	and  %i2, %o2, %o2                             
40012930:	96 10 00 1b 	mov  %i3, %o3                                  
40012934:	40 00 02 e9 	call  400134d8 <_fat_block_read>               
40012938:	98 10 00 1c 	mov  %i4, %o4                                  
        if ( ret < 0 )                                                
4001293c:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40012940:	16 80 00 11 	bge  40012984 <fat_file_read+0x20c>            <== ALWAYS TAKEN
40012944:	01 00 00 00 	nop                                            
        sec += (ofs >> fs_info->vol.sec_log2);                        
        byte = ofs & (fs_info->vol.bps - 1);                          
                                                                      
        ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd);   
        if ( ret < 0 )                                                
            return -1;                                                
40012948:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001294c:	91 e8 3f ff 	restore  %g0, -1, %o0                          <== NOT EXECUTED
                                                                      
    return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +        
40012950:	c4 07 60 34 	ld  [ %i5 + 0x34 ], %g2                        <== NOT EXECUTED
40012954:	92 00 7f fe 	add  %g1, -2, %o1                              <== NOT EXECUTED
40012958:	93 2a 40 03 	sll  %o1, %g3, %o1                             <== NOT EXECUTED
4001295c:	10 bf ff ee 	b  40012914 <fat_file_read+0x19c>              <== NOT EXECUTED
40012960:	92 02 40 02 	add  %o1, %g2, %o1                             <== NOT EXECUTED
40012964:	b0 10 00 11 	mov  %l1, %i0                                  
    }                                                                 
                                                                      
    /* update cache */                                                
    /* XXX: check this - I'm not sure :( */                           
    fat_fd->map.file_cln = cl_start +                                 
                           ((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
40012968:	c2 0f 60 08 	ldub  [ %i5 + 8 ], %g1                         
4001296c:	b4 06 bf ff 	add  %i2, -1, %i2                              
    fat_fd->map.disk_cln = save_cln;                                  
40012970:	e6 26 60 38 	st  %l3, [ %i1 + 0x38 ]                        
    }                                                                 
                                                                      
    /* update cache */                                                
    /* XXX: check this - I'm not sure :( */                           
    fat_fd->map.file_cln = cl_start +                                 
                           ((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
40012974:	a2 06 80 11 	add  %i2, %l1, %l1                             
40012978:	a3 34 40 01 	srl  %l1, %g1, %l1                             
        ofs = 0;                                                      
    }                                                                 
                                                                      
    /* update cache */                                                
    /* XXX: check this - I'm not sure :( */                           
    fat_fd->map.file_cln = cl_start +                                 
4001297c:	a4 04 40 12 	add  %l1, %l2, %l2                             
40012980:	e4 26 60 34 	st  %l2, [ %i1 + 0x34 ]                        
40012984:	81 c7 e0 08 	ret                                            
40012988:	81 e8 00 00 	restore                                        
                                                                      

40013180 <fat_file_size>: int fat_file_size( fat_fs_info_t *fs_info, fat_file_fd_t *fat_fd ) {
40013180:	9d e3 bf 98 	save  %sp, -104, %sp                           
    int            rc = RC_OK;                                        
    uint32_t       cur_cln = fat_fd->cln;                             
40013184:	f8 06 60 1c 	ld  [ %i1 + 0x1c ], %i4                        
    uint32_t       save_cln = 0;                                      
                                                                      
    /* Have we requested root dir size for FAT12/16? */               
    if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&                               
40013188:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
4001318c:	80 a0 60 01 	cmp  %g1, 1                                    
40013190:	02 80 00 21 	be  40013214 <fat_file_size+0x94>              
40013194:	f8 27 bf fc 	st  %i4, [ %fp + -4 ]                          
        return rc;                                                    
    }                                                                 
                                                                      
    fat_fd->fat_file_size = 0;                                        
                                                                      
    while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)      
40013198:	c4 06 20 10 	ld  [ %i0 + 0x10 ], %g2                        
4001319c:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
400131a0:	84 0f 00 02 	and  %i4, %g2, %g2                             
400131a4:	80 a0 80 01 	cmp  %g2, %g1                                  
400131a8:	0a 80 00 0e 	bcs  400131e0 <fat_file_size+0x60>             <== ALWAYS TAKEN
400131ac:	c0 26 60 18 	clr  [ %i1 + 0x18 ]                            
    fat_file_fd_t                        *fat_fd                      
    )                                                                 
{                                                                     
    int            rc = RC_OK;                                        
    uint32_t       cur_cln = fat_fd->cln;                             
    uint32_t       save_cln = 0;                                      
400131b0:	10 80 00 15 	b  40013204 <fat_file_size+0x84>               <== NOT EXECUTED
400131b4:	b8 10 20 00 	clr  %i4                                       <== NOT EXECUTED
        save_cln = cur_cln;                                           
        rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);         
        if ( rc != RC_OK )                                            
            return rc;                                                
                                                                      
        fat_fd->fat_file_size += fs_info->vol.bpc;                    
400131b8:	f6 06 60 18 	ld  [ %i1 + 0x18 ], %i3                        
        return rc;                                                    
    }                                                                 
                                                                      
    fat_fd->fat_file_size = 0;                                        
                                                                      
    while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)      
400131bc:	c6 06 20 10 	ld  [ %i0 + 0x10 ], %g3                        
400131c0:	c4 06 20 14 	ld  [ %i0 + 0x14 ], %g2                        
400131c4:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
        save_cln = cur_cln;                                           
        rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);         
        if ( rc != RC_OK )                                            
            return rc;                                                
                                                                      
        fat_fd->fat_file_size += fs_info->vol.bpc;                    
400131c8:	88 06 c0 04 	add  %i3, %g4, %g4                             
        return rc;                                                    
    }                                                                 
                                                                      
    fat_fd->fat_file_size = 0;                                        
                                                                      
    while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)      
400131cc:	86 08 40 03 	and  %g1, %g3, %g3                             
400131d0:	80 a0 c0 02 	cmp  %g3, %g2                                  
400131d4:	1a 80 00 0c 	bcc  40013204 <fat_file_size+0x84>             <== ALWAYS TAKEN
400131d8:	c8 26 60 18 	st  %g4, [ %i1 + 0x18 ]                        
400131dc:	b8 10 00 01 	mov  %g1, %i4                                  <== NOT EXECUTED
    {                                                                 
        save_cln = cur_cln;                                           
        rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);         
400131e0:	92 10 00 1c 	mov  %i4, %o1                                  
400131e4:	90 10 00 18 	mov  %i0, %o0                                  
400131e8:	40 00 1b d5 	call  4001a13c <fat_get_fat_cluster>           
400131ec:	94 07 bf fc 	add  %fp, -4, %o2                              
        if ( rc != RC_OK )                                            
400131f0:	80 a2 20 00 	cmp  %o0, 0                                    
400131f4:	22 bf ff f1 	be,a   400131b8 <fat_file_size+0x38>           <== ALWAYS TAKEN
400131f8:	c8 16 20 06 	lduh  [ %i0 + 6 ], %g4                         
                                                                      
        fat_fd->fat_file_size += fs_info->vol.bpc;                    
    }                                                                 
    fat_fd->map.last_cln = save_cln;                                  
    return rc;                                                        
}                                                                     
400131fc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40013200:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
        if ( rc != RC_OK )                                            
            return rc;                                                
                                                                      
        fat_fd->fat_file_size += fs_info->vol.bpc;                    
    }                                                                 
    fat_fd->map.last_cln = save_cln;                                  
40013204:	90 10 20 00 	clr  %o0                                       
40013208:	f8 26 60 3c 	st  %i4, [ %i1 + 0x3c ]                        
    return rc;                                                        
}                                                                     
4001320c:	81 c7 e0 08 	ret                                            
40013210:	91 e8 00 08 	restore  %g0, %o0, %o0                         
    int            rc = RC_OK;                                        
    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)) &&                               
40013214:	c2 06 60 24 	ld  [ %i1 + 0x24 ], %g1                        
40013218:	80 a0 60 00 	cmp  %g1, 0                                    
4001321c:	32 bf ff e0 	bne,a   4001319c <fat_file_size+0x1c>          <== NEVER TAKEN
40013220:	c4 06 20 10 	ld  [ %i0 + 0x10 ], %g2                        <== NOT EXECUTED
        (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))                
40013224:	c2 0e 20 0e 	ldub  [ %i0 + 0xe ], %g1                       
    int            rc = RC_OK;                                        
    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)) &&                               
40013228:	80 88 60 03 	btst  3, %g1                                   
4001322c:	22 bf ff dc 	be,a   4001319c <fat_file_size+0x1c>           <== ALWAYS TAKEN
40013230:	c4 06 20 10 	ld  [ %i0 + 0x10 ], %g2                        
        (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))                
    {                                                                 
        fat_fd->fat_file_size = fs_info->vol.rdir_size;               
40013234:	c2 06 20 2c 	ld  [ %i0 + 0x2c ], %g1                        <== NOT EXECUTED
        return rc;                                                    
40013238:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
                                                                      
    /* 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)))                
    {                                                                 
        fat_fd->fat_file_size = fs_info->vol.rdir_size;               
4001323c:	10 bf ff f0 	b  400131fc <fat_file_size+0x7c>               <== NOT EXECUTED
40013240:	c2 26 60 18 	st  %g1, [ %i1 + 0x18 ]                        <== NOT EXECUTED
                                                                      

4001298c <fat_file_truncate>: fat_file_truncate( fat_fs_info_t *fs_info, fat_file_fd_t *fat_fd, uint32_t new_length ) {
4001298c:	9d e3 bf 98 	save  %sp, -104, %sp                           
    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 )                        
40012990:	c2 06 60 18 	ld  [ %i1 + 0x18 ], %g1                        
    )                                                                 
{                                                                     
    int            rc = RC_OK;                                        
    uint32_t       cur_cln = 0;                                       
    uint32_t       cl_start = 0;                                      
    uint32_t       new_last_cln = FAT_UNDEFINED_VALUE;                
40012994:	84 10 3f ff 	mov  -1, %g2                                   
    fat_file_fd_t                        *fat_fd,                     
    uint32_t                              new_length                  
    )                                                                 
{                                                                     
    int            rc = RC_OK;                                        
    uint32_t       cur_cln = 0;                                       
40012998:	c0 27 bf f8 	clr  [ %fp + -8 ]                              
    uint32_t       cl_start = 0;                                      
    uint32_t       new_last_cln = FAT_UNDEFINED_VALUE;                
                                                                      
                                                                      
    if ( new_length >= fat_fd->fat_file_size )                        
4001299c:	80 a0 40 1a 	cmp  %g1, %i2                                  
400129a0:	08 80 00 26 	bleu  40012a38 <fat_file_truncate+0xac>        
400129a4:	c4 27 bf fc 	st  %g2, [ %fp + -4 ]                          
        return rc;                                                    
                                                                      
    assert(fat_fd->fat_file_size);                                    
400129a8:	80 a0 60 00 	cmp  %g1, 0                                    
400129ac:	02 80 00 31 	be  40012a70 <fat_file_truncate+0xe4>          <== NEVER TAKEN
400129b0:	11 10 00 b3 	sethi  %hi(0x4002cc00), %o0                    
                                                                      
    cl_start = (new_length + fs_info->vol.bpc - 1) >> fs_info->vol.bpc_log2;
400129b4:	c4 0e 20 08 	ldub  [ %i0 + 8 ], %g2                         
400129b8:	c6 16 20 06 	lduh  [ %i0 + 6 ], %g3                         
400129bc:	86 00 ff ff 	add  %g3, -1, %g3                              
400129c0:	b4 00 c0 1a 	add  %g3, %i2, %i2                             
400129c4:	b5 36 80 02 	srl  %i2, %g2, %i2                             
                                                                      
    if ((cl_start << fs_info->vol.bpc_log2) >= fat_fd->fat_file_size) 
400129c8:	85 2e 80 02 	sll  %i2, %g2, %g2                             
400129cc:	80 a0 40 02 	cmp  %g1, %g2                                  
400129d0:	08 80 00 1a 	bleu  40012a38 <fat_file_truncate+0xac>        
400129d4:	80 a6 a0 00 	cmp  %i2, 0                                    
        return RC_OK;                                                 
                                                                      
    if (cl_start != 0)                                                
400129d8:	02 80 00 09 	be  400129fc <fat_file_truncate+0x70>          
400129dc:	90 10 00 18 	mov  %i0, %o0                                  
    {                                                                 
        rc = fat_file_lseek(fs_info, fat_fd, cl_start - 1, &new_last_cln);
400129e0:	92 10 00 19 	mov  %i1, %o1                                  
400129e4:	94 06 bf ff 	add  %i2, -1, %o2                              
400129e8:	7f ff fe 81 	call  400123ec <fat_file_lseek>                
400129ec:	96 07 bf fc 	add  %fp, -4, %o3                              
        if (rc != RC_OK)                                              
400129f0:	80 a2 60 00 	cmp  %o1, 0                                    
400129f4:	12 80 00 12 	bne  40012a3c <fat_file_truncate+0xb0>         <== NEVER TAKEN
400129f8:	90 10 00 18 	mov  %i0, %o0                                  
            return rc;                                                
                                                                      
    }                                                                 
                                                                      
    rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);         
400129fc:	92 10 00 19 	mov  %i1, %o1                                  
40012a00:	94 10 00 1a 	mov  %i2, %o2                                  
40012a04:	7f ff fe 7a 	call  400123ec <fat_file_lseek>                
40012a08:	96 07 bf f8 	add  %fp, -8, %o3                              
    if (rc != RC_OK)                                                  
40012a0c:	80 a2 60 00 	cmp  %o1, 0                                    
40012a10:	12 80 00 0b 	bne  40012a3c <fat_file_truncate+0xb0>         <== NEVER TAKEN
40012a14:	01 00 00 00 	nop                                            
        return rc;                                                    
                                                                      
    rc = fat_free_fat_clusters_chain(fs_info, cur_cln);               
40012a18:	d2 07 bf f8 	ld  [ %fp + -8 ], %o1                          
40012a1c:	40 00 1e fe 	call  4001a614 <fat_free_fat_clusters_chain>   
40012a20:	90 10 00 18 	mov  %i0, %o0                                  
    if (rc != RC_OK)                                                  
40012a24:	92 92 20 00 	orcc  %o0, 0, %o1                              
40012a28:	12 80 00 05 	bne  40012a3c <fat_file_truncate+0xb0>         <== NEVER TAKEN
40012a2c:	80 a6 a0 00 	cmp  %i2, 0                                    
        return rc;                                                    
                                                                      
    if (cl_start != 0)                                                
40012a30:	12 80 00 05 	bne  40012a44 <fat_file_truncate+0xb8>         
40012a34:	d2 07 bf fc 	ld  [ %fp + -4 ], %o1                          
    uint32_t       cl_start = 0;                                      
    uint32_t       new_last_cln = FAT_UNDEFINED_VALUE;                
                                                                      
                                                                      
    if ( new_length >= fat_fd->fat_file_size )                        
        return rc;                                                    
40012a38:	92 10 20 00 	clr  %o1                                       
        fat_fd->map.file_cln = cl_start - 1;                          
        fat_fd->map.disk_cln = new_last_cln;                          
        fat_fd->map.last_cln = new_last_cln;                          
    }                                                                 
    return RC_OK;                                                     
}                                                                     
40012a3c:	81 c7 e0 08 	ret                                            
40012a40:	91 e8 00 09 	restore  %g0, %o1, %o0                         
    if (rc != RC_OK)                                                  
        return rc;                                                    
                                                                      
    if (cl_start != 0)                                                
    {                                                                 
        rc = fat_set_fat_cluster(fs_info, new_last_cln, FAT_GENFAT_EOC);
40012a44:	90 10 00 18 	mov  %i0, %o0                                  
40012a48:	40 00 1e 41 	call  4001a34c <fat_set_fat_cluster>           
40012a4c:	94 10 3f ff 	mov  -1, %o2                                   
        if ( rc != RC_OK )                                            
40012a50:	92 92 20 00 	orcc  %o0, 0, %o1                              
40012a54:	12 bf ff fa 	bne  40012a3c <fat_file_truncate+0xb0>         <== NEVER TAKEN
40012a58:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
            return rc;                                                
        fat_fd->map.file_cln = cl_start - 1;                          
40012a5c:	b4 06 bf ff 	add  %i2, -1, %i2                              
        fat_fd->map.disk_cln = new_last_cln;                          
40012a60:	c2 26 60 38 	st  %g1, [ %i1 + 0x38 ]                        
    if (cl_start != 0)                                                
    {                                                                 
        rc = fat_set_fat_cluster(fs_info, new_last_cln, FAT_GENFAT_EOC);
        if ( rc != RC_OK )                                            
            return rc;                                                
        fat_fd->map.file_cln = cl_start - 1;                          
40012a64:	f4 26 60 34 	st  %i2, [ %i1 + 0x34 ]                        
        fat_fd->map.disk_cln = new_last_cln;                          
        fat_fd->map.last_cln = new_last_cln;                          
40012a68:	10 bf ff f5 	b  40012a3c <fat_file_truncate+0xb0>           
40012a6c:	c2 26 60 3c 	st  %g1, [ %i1 + 0x3c ]                        
                                                                      
                                                                      
    if ( new_length >= fat_fd->fat_file_size )                        
        return rc;                                                    
                                                                      
    assert(fat_fd->fat_file_size);                                    
40012a70:	15 10 00 b3 	sethi  %hi(0x4002cc00), %o2                    <== NOT EXECUTED
40012a74:	17 10 00 b3 	sethi  %hi(0x4002cc00), %o3                    <== NOT EXECUTED
40012a78:	90 12 20 c0 	or  %o0, 0xc0, %o0                             <== NOT EXECUTED
40012a7c:	92 10 22 d1 	mov  0x2d1, %o1                                <== NOT EXECUTED
40012a80:	94 12 a1 20 	or  %o2, 0x120, %o2                            <== NOT EXECUTED
40012a84:	7f ff c7 e6 	call  40004a1c <__assert_func>                 <== NOT EXECUTED
40012a88:	96 12 e1 08 	or  %o3, 0x108, %o3                            <== NOT EXECUTED
                                                                      

40012e70 <fat_file_write>: fat_file_fd_t *fat_fd, uint32_t start, uint32_t count, const uint8_t *buf ) {
40012e70:	9d e3 bf 98 	save  %sp, -104, %sp                           
    int            rc = RC_OK;                                        
    ssize_t        ret;                                               
    uint32_t       cmpltd = 0;                                        
    uint32_t       byte;                                              
    uint32_t       c = 0;                                             
40012e74:	c0 27 bf f8 	clr  [ %fp + -8 ]                              
    fat_file_fd_t                        *fat_fd,                     
    uint32_t                              start,                      
    uint32_t                              count,                      
    const uint8_t                        *buf                         
    )                                                                 
{                                                                     
40012e78:	a0 10 00 18 	mov  %i0, %l0                                  
    int            rc = RC_OK;                                        
    ssize_t        ret;                                               
    uint32_t       cmpltd = 0;                                        
    uint32_t       byte;                                              
    uint32_t       c = 0;                                             
    bool           zero_fill = start > fat_fd->fat_file_size;         
40012e7c:	c2 06 60 18 	ld  [ %i1 + 0x18 ], %g1                        
    uint32_t       file_cln_initial = fat_fd->map.file_cln;           
40012e80:	e4 06 60 34 	ld  [ %i1 + 0x34 ], %l2                        
    uint32_t       cln;                                               
                                                                      
                                                                      
    if ( count == 0 )                                                 
40012e84:	80 a6 e0 00 	cmp  %i3, 0                                    
40012e88:	02 80 00 5d 	be  40012ffc <fat_file_write+0x18c>            <== NEVER TAKEN
40012e8c:	b0 10 20 00 	clr  %i0                                       
        return cmpltd;                                                
                                                                      
    if (start >= fat_fd->size_limit)                                  
40012e90:	fa 06 60 14 	ld  [ %i1 + 0x14 ], %i5                        
40012e94:	80 a6 80 1d 	cmp  %i2, %i5                                  
40012e98:	1a 80 00 89 	bcc  400130bc <fat_file_write+0x24c>           <== NEVER TAKEN
40012e9c:	ba 27 40 1a 	sub  %i5, %i2, %i5                             
40012ea0:	80 a7 40 1b 	cmp  %i5, %i3                                  
    int            rc = RC_OK;                                        
    ssize_t        ret;                                               
    uint32_t       cmpltd = 0;                                        
    uint32_t       byte;                                              
    uint32_t       c = 0;                                             
    bool           zero_fill = start > fat_fd->fat_file_size;         
40012ea4:	18 80 00 58 	bgu  40013004 <fat_file_write+0x194>           <== ALWAYS TAKEN
40012ea8:	80 a0 40 1a 	cmp  %g1, %i2                                  
        rtems_set_errno_and_return_minus_one(EFBIG);                  
                                                                      
    if (count > fat_fd->size_limit - start)                           
        count = fat_fd->size_limit - start;                           
                                                                      
    rc = fat_file_extend(fs_info, fat_fd, zero_fill, start + count, &c);
40012eac:	b6 07 40 1a 	add  %i5, %i2, %i3                             <== NOT EXECUTED
40012eb0:	94 40 20 00 	addx  %g0, 0, %o2                              <== NOT EXECUTED
40012eb4:	90 10 00 10 	mov  %l0, %o0                                  <== NOT EXECUTED
40012eb8:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
40012ebc:	96 10 00 1b 	mov  %i3, %o3                                  <== NOT EXECUTED
40012ec0:	7f ff ff 57 	call  40012c1c <fat_file_extend>               <== NOT EXECUTED
40012ec4:	98 07 bf f8 	add  %fp, -8, %o4                              <== NOT EXECUTED
    if (RC_OK == rc)                                                  
40012ec8:	b0 92 20 00 	orcc  %o0, 0, %i0                              <== NOT EXECUTED
40012ecc:	12 80 00 4c 	bne  40012ffc <fat_file_write+0x18c>           <== NOT EXECUTED
40012ed0:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          <== NOT EXECUTED
    {                                                                 
        /*                                                            
         * check whether there was enough room on device to locate    
         * file of 'start + count' bytes                              
         */                                                           
        if (c != (start + count))                                     
40012ed4:	80 a6 c0 01 	cmp  %i3, %g1                                  <== NOT EXECUTED
40012ed8:	32 80 00 02 	bne,a   40012ee0 <fat_file_write+0x70>         <== NEVER TAKEN
40012edc:	ba 20 40 1a 	sub  %g1, %i2, %i5                             <== NOT EXECUTED
 */                                                                   
static bool                                                           
 fat_is_fat12_or_fat16_root_dir (const fat_file_fd_t *fat_fd,         
                                 const uint8_t volume_type)           
{                                                                     
    return (FAT_FD_OF_ROOT_DIR(fat_fd)) && (volume_type & (FAT_FAT12 | FAT_FAT16));
40012ee0:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
40012ee4:	80 a0 60 01 	cmp  %g1, 1                                    
40012ee8:	02 80 00 5b 	be  40013054 <fat_file_write+0x1e4>            
40012eec:	c4 0c 20 0e 	ldub  [ %l0 + 0xe ], %g2                       
{                                                                     
    int            rc = RC_OK;                                        
    uint32_t       cmpltd = 0;                                        
    uint32_t       cur_cln = 0;                                       
    uint32_t       save_cln = 0; /* FIXME: This might be incorrect, cf. below */
    uint32_t       start_cln = start >> fs_info->vol.bpc_log2;        
40012ef0:	f6 0c 20 08 	ldub  [ %l0 + 8 ], %i3                         
     const uint8_t                        *buf,                       
     const uint32_t                        file_cln_initial)          
{                                                                     
    int            rc = RC_OK;                                        
    uint32_t       cmpltd = 0;                                        
    uint32_t       cur_cln = 0;                                       
40012ef4:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
    uint32_t       save_cln = 0; /* FIXME: This might be incorrect, cf. below */
    uint32_t       start_cln = start >> fs_info->vol.bpc_log2;        
40012ef8:	ab 36 80 1b 	srl  %i2, %i3, %l5                             
    uint32_t       file_cln_cnt;                                      
    ssize_t        ret;                                               
    uint32_t       c;                                                 
    bool           overwrite_cluster = false;                         
                                                                      
    rc = fat_file_lseek(fs_info, fat_fd, start_cln, &cur_cln);        
40012efc:	90 10 00 10 	mov  %l0, %o0                                  
40012f00:	92 10 00 19 	mov  %i1, %o1                                  
40012f04:	94 10 00 15 	mov  %l5, %o2                                  
40012f08:	7f ff fd 39 	call  400123ec <fat_file_lseek>                
40012f0c:	96 07 bf fc 	add  %fp, -4, %o3                              
    if (RC_OK == rc)                                                  
40012f10:	80 a2 60 00 	cmp  %o1, 0                                    
40012f14:	12 80 00 38 	bne  40012ff4 <fat_file_write+0x184>           <== NEVER TAKEN
40012f18:	b0 92 60 00 	orcc  %o1, 0, %i0                              
    {                                                                 
        file_cln_cnt = cur_cln - fat_fd->cln;                         
40012f1c:	c2 06 60 1c 	ld  [ %i1 + 0x1c ], %g1                        
40012f20:	ec 07 bf fc 	ld  [ %fp + -4 ], %l6                          
    int            rc = RC_OK;                                        
    uint32_t       cmpltd = 0;                                        
    uint32_t       cur_cln = 0;                                       
    uint32_t       save_cln = 0; /* FIXME: This might be incorrect, cf. below */
    uint32_t       start_cln = start >> fs_info->vol.bpc_log2;        
    uint32_t       ofs_cln = start - (start_cln << fs_info->vol.bpc_log2);
40012f24:	b7 2d 40 1b 	sll  %l5, %i3, %i3                             
    bool           overwrite_cluster = false;                         
                                                                      
    rc = fat_file_lseek(fs_info, fat_fd, start_cln, &cur_cln);        
    if (RC_OK == rc)                                                  
    {                                                                 
        file_cln_cnt = cur_cln - fat_fd->cln;                         
40012f28:	ac 25 80 01 	sub  %l6, %g1, %l6                             
    int            rc = RC_OK;                                        
    uint32_t       cmpltd = 0;                                        
    uint32_t       cur_cln = 0;                                       
    uint32_t       save_cln = 0; /* FIXME: This might be incorrect, cf. below */
    uint32_t       start_cln = start >> fs_info->vol.bpc_log2;        
    uint32_t       ofs_cln = start - (start_cln << fs_info->vol.bpc_log2);
40012f2c:	b4 26 80 1b 	sub  %i2, %i3, %i2                             
    bool           overwrite_cluster = false;                         
                                                                      
    rc = fat_file_lseek(fs_info, fat_fd, start_cln, &cur_cln);        
    if (RC_OK == rc)                                                  
    {                                                                 
        file_cln_cnt = cur_cln - fat_fd->cln;                         
40012f30:	b0 10 20 00 	clr  %i0                                       
    int            rc = RC_OK;                                        
    uint32_t       cmpltd = 0;                                        
    uint32_t       cur_cln = 0;                                       
    uint32_t       save_cln = 0; /* FIXME: This might be incorrect, cf. below */
    uint32_t       start_cln = start >> fs_info->vol.bpc_log2;        
    uint32_t       ofs_cln = start - (start_cln << fs_info->vol.bpc_log2);
40012f34:	a2 10 00 1a 	mov  %i2, %l1                                  
    uint32_t       ofs_cln_save = ofs_cln;                            
    uint32_t       bytes_to_write = count;                            
    uint32_t       file_cln_cnt;                                      
    ssize_t        ret;                                               
    uint32_t       c;                                                 
    bool           overwrite_cluster = false;                         
40012f38:	a6 10 20 00 	clr  %l3                                       
     const uint32_t                        file_cln_initial)          
{                                                                     
    int            rc = RC_OK;                                        
    uint32_t       cmpltd = 0;                                        
    uint32_t       cur_cln = 0;                                       
    uint32_t       save_cln = 0; /* FIXME: This might be incorrect, cf. below */
40012f3c:	a8 10 20 00 	clr  %l4                                       
     const uint32_t                        count,                     
     const uint8_t                        *buf,                       
     const uint32_t                        file_cln_initial)          
{                                                                     
    int            rc = RC_OK;                                        
    uint32_t       cmpltd = 0;                                        
40012f40:	b6 10 20 00 	clr  %i3                                       
                                                                      
    rc = fat_file_lseek(fs_info, fat_fd, start_cln, &cur_cln);        
    if (RC_OK == rc)                                                  
    {                                                                 
        file_cln_cnt = cur_cln - fat_fd->cln;                         
        while (   (RC_OK == rc)                                       
40012f44:	80 a7 60 00 	cmp  %i5, 0                                    
40012f48:	22 80 00 21 	be,a   40012fcc <fat_file_write+0x15c>         <== NEVER TAKEN
40012f4c:	c2 0c 20 08 	ldub  [ %l0 + 8 ], %g1                         <== NOT EXECUTED
40012f50:	80 a6 20 00 	cmp  %i0, 0                                    
40012f54:	32 80 00 1e 	bne,a   40012fcc <fat_file_write+0x15c>        <== NEVER TAKEN
40012f58:	c2 0c 20 08 	ldub  [ %l0 + 8 ], %g1                         <== NOT EXECUTED
               && (bytes_to_write > 0))                               
        {                                                             
            c = MIN(bytes_to_write, (fs_info->vol.bpc - ofs_cln));    
40012f5c:	d6 14 20 06 	lduh  [ %l0 + 6 ], %o3                         
40012f60:	96 22 c0 11 	sub  %o3, %l1, %o3                             
40012f64:	80 a2 c0 1d 	cmp  %o3, %i5                                  
40012f68:	38 80 00 02 	bgu,a   40012f70 <fat_file_write+0x100>        
40012f6c:	96 10 00 1d 	mov  %i5, %o3                                  
                                                                      
            if (file_cln_initial < file_cln_cnt)                      
40012f70:	80 a4 80 16 	cmp  %l2, %l6                                  
40012f74:	2a 80 00 02 	bcs,a   40012f7c <fat_file_write+0x10c>        
40012f78:	a6 10 20 01 	mov  1, %l3                                    
                overwrite_cluster = true;                             
                                                                      
            ret = fat_cluster_write(fs_info,                          
40012f7c:	d2 07 bf fc 	ld  [ %fp + -4 ], %o1                          
40012f80:	90 10 00 10 	mov  %l0, %o0                                  
40012f84:	94 10 00 11 	mov  %l1, %o2                                  
40012f88:	98 07 00 1b 	add  %i4, %i3, %o4                             
40012f8c:	9a 0c e0 01 	and  %l3, 1, %o5                               
40012f90:	40 00 01 fe 	call  40013788 <fat_cluster_write>             
40012f94:	b0 10 3f ff 	mov  -1, %i0                                   
                                      cur_cln,                        
                                      ofs_cln,                        
                                      c,                              
                                      &buf[cmpltd],                   
                                      overwrite_cluster);             
            if (0 > ret)                                              
40012f98:	80 a2 20 00 	cmp  %o0, 0                                    
40012f9c:	06 bf ff eb 	bl  40012f48 <fat_file_write+0xd8>             <== NEVER TAKEN
40012fa0:	80 a7 60 00 	cmp  %i5, 0                                    
              rc = -1;                                                
                                                                      
            if (RC_OK == rc)                                          
            {                                                         
                ++file_cln_cnt;                                       
40012fa4:	ac 05 a0 01 	inc  %l6                                       
                bytes_to_write -= ret;                                
                cmpltd += ret;                                        
40012fa8:	b6 06 c0 08 	add  %i3, %o0, %i3                             
                save_cln = cur_cln;                                   
                if (0 < bytes_to_write)                               
40012fac:	ba a7 40 08 	subcc  %i5, %o0, %i5                           
40012fb0:	12 80 00 22 	bne  40013038 <fat_file_write+0x1c8>           
40012fb4:	e8 07 bf fc 	ld  [ %fp + -4 ], %l4                          
40012fb8:	b0 10 20 00 	clr  %i0                                       
                                                                      
    rc = fat_file_lseek(fs_info, fat_fd, start_cln, &cur_cln);        
    if (RC_OK == rc)                                                  
    {                                                                 
        file_cln_cnt = cur_cln - fat_fd->cln;                         
        while (   (RC_OK == rc)                                       
40012fbc:	80 a7 60 00 	cmp  %i5, 0                                    
40012fc0:	12 bf ff e4 	bne  40012f50 <fat_file_write+0xe0>            <== NEVER TAKEN
40012fc4:	a2 10 20 00 	clr  %l1                                       
        }                                                             
                                                                      
        /* update cache */                                            
        /* XXX: check this - I'm not sure :( */                       
        fat_fd->map.file_cln = start_cln +                            
                               ((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2);
40012fc8:	c2 0c 20 08 	ldub  [ %l0 + 8 ], %g1                         
40012fcc:	b4 06 bf ff 	add  %i2, -1, %i2                              
        fat_fd->map.disk_cln = save_cln;                              
40012fd0:	e8 26 60 38 	st  %l4, [ %i1 + 0x38 ]                        
        }                                                             
                                                                      
        /* update cache */                                            
        /* XXX: check this - I'm not sure :( */                       
        fat_fd->map.file_cln = start_cln +                            
                               ((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2);
40012fd4:	b4 06 80 1b 	add  %i2, %i3, %i2                             
40012fd8:	b5 36 80 01 	srl  %i2, %g1, %i2                             
            }                                                         
        }                                                             
                                                                      
        /* update cache */                                            
        /* XXX: check this - I'm not sure :( */                       
        fat_fd->map.file_cln = start_cln +                            
40012fdc:	aa 06 80 15 	add  %i2, %l5, %l5                             
                               ((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2);
        fat_fd->map.disk_cln = save_cln;                              
    }                                                                 
                                                                      
    if (RC_OK != rc)                                                  
40012fe0:	92 96 20 00 	orcc  %i0, 0, %o1                              
40012fe4:	12 80 00 03 	bne  40012ff0 <fat_file_write+0x180>           <== NEVER TAKEN
40012fe8:	ea 26 60 34 	st  %l5, [ %i1 + 0x34 ]                        
      return rc;                                                      
    else                                                              
      return cmpltd;                                                  
40012fec:	92 10 00 1b 	mov  %i3, %o1                                  
                                                       fat_fd,        
                                                       start,         
                                                       count,         
                                                       buf,           
                                                       file_cln_initial);
            if (0 > ret)                                              
40012ff0:	b0 92 60 00 	orcc  %o1, 0, %i0                              
40012ff4:	06 80 00 30 	bl  400130b4 <fat_file_write+0x244>            <== NEVER TAKEN
40012ff8:	01 00 00 00 	nop                                            
    }                                                                 
    if (RC_OK != rc)                                                  
        return rc;                                                    
    else                                                              
        return cmpltd;                                                
}                                                                     
40012ffc:	81 c7 e0 08 	ret                                            
40013000:	81 e8 00 00 	restore                                        
40013004:	ba 10 00 1b 	mov  %i3, %i5                                  
        rtems_set_errno_and_return_minus_one(EFBIG);                  
                                                                      
    if (count > fat_fd->size_limit - start)                           
        count = fat_fd->size_limit - start;                           
                                                                      
    rc = fat_file_extend(fs_info, fat_fd, zero_fill, start + count, &c);
40013008:	94 40 20 00 	addx  %g0, 0, %o2                              
4001300c:	b6 07 40 1a 	add  %i5, %i2, %i3                             
40013010:	90 10 00 10 	mov  %l0, %o0                                  
40013014:	92 10 00 19 	mov  %i1, %o1                                  
40013018:	96 10 00 1b 	mov  %i3, %o3                                  
4001301c:	7f ff ff 00 	call  40012c1c <fat_file_extend>               
40013020:	98 07 bf f8 	add  %fp, -8, %o4                              
    if (RC_OK == rc)                                                  
40013024:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40013028:	12 bf ff f5 	bne  40012ffc <fat_file_write+0x18c>           
4001302c:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
    {                                                                 
        /*                                                            
         * check whether there was enough room on device to locate    
         * file of 'start + count' bytes                              
         */                                                           
        if (c != (start + count))                                     
40013030:	10 bf ff aa 	b  40012ed8 <fat_file_write+0x68>              
40013034:	80 a6 c0 01 	cmp  %i3, %g1                                  
                ++file_cln_cnt;                                       
                bytes_to_write -= ret;                                
                cmpltd += ret;                                        
                save_cln = cur_cln;                                   
                if (0 < bytes_to_write)                               
                  rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
40013038:	90 10 00 10 	mov  %l0, %o0                                  
4001303c:	92 10 00 14 	mov  %l4, %o1                                  
40013040:	94 07 bf fc 	add  %fp, -4, %o2                              
40013044:	40 00 1c 3e 	call  4001a13c <fat_get_fat_cluster>           
40013048:	a2 10 20 00 	clr  %l1                                       
4001304c:	10 bf ff be 	b  40012f44 <fat_file_write+0xd4>              
40013050:	b0 10 00 08 	mov  %o0, %i0                                  
 */                                                                   
static bool                                                           
 fat_is_fat12_or_fat16_root_dir (const fat_file_fd_t *fat_fd,         
                                 const uint8_t volume_type)           
{                                                                     
    return (FAT_FD_OF_ROOT_DIR(fat_fd)) && (volume_type & (FAT_FAT12 | FAT_FAT16));
40013054:	c2 06 60 24 	ld  [ %i1 + 0x24 ], %g1                        
40013058:	80 a0 60 00 	cmp  %g1, 0                                    
4001305c:	32 bf ff a6 	bne,a   40012ef4 <fat_file_write+0x84>         <== NEVER TAKEN
40013060:	f6 0c 20 08 	ldub  [ %l0 + 8 ], %i3                         <== NOT EXECUTED
40013064:	80 88 a0 03 	btst  3, %g2                                   
40013068:	22 bf ff a3 	be,a   40012ef4 <fat_file_write+0x84>          
4001306c:	f6 0c 20 08 	ldub  [ %l0 + 8 ], %i3                         
            count = c - start;                                        
                                                                      
        /* for the root directory of FAT12 and FAT16 we need this special handling */
        if (fat_is_fat12_or_fat16_root_dir(fat_fd, fs_info->vol.type))
        {                                                             
            cln = fat_fd->cln;                                        
40013070:	c2 06 60 1c 	ld  [ %i1 + 0x1c ], %g1                        
            cln += (start >> fs_info->vol.bpc_log2);                  
40013074:	d2 0c 20 08 	ldub  [ %l0 + 8 ], %o1                         
            byte = start & (fs_info->vol.bpc -1);                     
40013078:	d4 14 20 06 	lduh  [ %l0 + 6 ], %o2                         
                                                                      
        /* for the root directory of FAT12 and FAT16 we need this special handling */
        if (fat_is_fat12_or_fat16_root_dir(fat_fd, fs_info->vol.type))
        {                                                             
            cln = fat_fd->cln;                                        
            cln += (start >> fs_info->vol.bpc_log2);                  
4001307c:	93 36 80 09 	srl  %i2, %o1, %o1                             
            byte = start & (fs_info->vol.bpc -1);                     
40013080:	94 02 bf ff 	add  %o2, -1, %o2                              
                                                                      
            ret = fat_cluster_write(fs_info,                          
40013084:	90 10 00 10 	mov  %l0, %o0                                  
40013088:	92 02 40 01 	add  %o1, %g1, %o1                             
4001308c:	94 0e 80 0a 	and  %i2, %o2, %o2                             
40013090:	96 10 00 1d 	mov  %i5, %o3                                  
40013094:	98 10 00 1c 	mov  %i4, %o4                                  
40013098:	40 00 01 bc 	call  40013788 <fat_cluster_write>             
4001309c:	9a 10 20 00 	clr  %o5                                       
                                      cln,                            
                                      byte,                           
                                      count,                          
                                      buf,                            
                                      false);                         
            if (0 > ret)                                              
400130a0:	80 a2 20 00 	cmp  %o0, 0                                    
400130a4:	06 80 00 04 	bl  400130b4 <fat_file_write+0x244>            <== NEVER TAKEN
400130a8:	01 00 00 00 	nop                                            
              rc = -1;                                                
            else                                                      
              cmpltd = ret;                                           
400130ac:	81 c7 e0 08 	ret                                            
400130b0:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                       start,         
                                                       count,         
                                                       buf,           
                                                       file_cln_initial);
            if (0 > ret)                                              
              rc = -1;                                                
400130b4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400130b8:	91 e8 3f ff 	restore  %g0, -1, %o0                          <== NOT EXECUTED
                                                                      
    if ( count == 0 )                                                 
        return cmpltd;                                                
                                                                      
    if (start >= fat_fd->size_limit)                                  
        rtems_set_errno_and_return_minus_one(EFBIG);                  
400130bc:	40 00 24 b5 	call  4001c390 <__errno>                       <== NOT EXECUTED
400130c0:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
400130c4:	82 10 20 1b 	mov  0x1b, %g1                                 <== NOT EXECUTED
400130c8:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
400130cc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400130d0:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4001a614 <fat_free_fat_clusters_chain>: int fat_free_fat_clusters_chain( fat_fs_info_t *fs_info, uint32_t chain ) {
4001a614:	9d e3 bf 98 	save  %sp, -104, %sp                           
    int            rc = RC_OK, rc1 = RC_OK;                           
    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)      
4001a618:	c4 06 20 10 	ld  [ %i0 + 0x10 ], %g2                        
4001a61c:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
    uint32_t                              chain                       
    )                                                                 
{                                                                     
    int            rc = RC_OK, rc1 = RC_OK;                           
    uint32_t       cur_cln = chain;                                   
    uint32_t       next_cln = 0;                                      
4001a620:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
    uint32_t       freed_cls_cnt = 0;                                 
                                                                      
    while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)      
4001a624:	84 0e 40 02 	and  %i1, %g2, %g2                             
4001a628:	80 a0 80 01 	cmp  %g2, %g1                                  
4001a62c:	1a 80 00 25 	bcc  4001a6c0 <fat_free_fat_clusters_chain+0xac><== NEVER TAKEN
4001a630:	ba 10 00 18 	mov  %i0, %i5                                  
4001a634:	b8 10 00 19 	mov  %i1, %i4                                  
4001a638:	b6 10 20 00 	clr  %i3                                       
4001a63c:	10 80 00 0e 	b  4001a674 <fat_free_fat_clusters_chain+0x60> 
4001a640:	b4 10 20 00 	clr  %i2                                       
                                                                      
            fat_buf_release(fs_info);                                 
            return rc;                                                
        }                                                             
                                                                      
        rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE);  
4001a644:	7f ff ff 42 	call  4001a34c <fat_set_fat_cluster>           
4001a648:	01 00 00 00 	nop                                            
        if ( rc != RC_OK )                                            
4001a64c:	80 a2 20 00 	cmp  %o0, 0                                    
4001a650:	02 80 00 03 	be  4001a65c <fat_free_fat_clusters_chain+0x48><== ALWAYS TAKEN
4001a654:	f8 07 bf fc 	ld  [ %fp + -4 ], %i4                          
4001a658:	b4 10 00 08 	mov  %o0, %i2                                  <== NOT EXECUTED
    int            rc = RC_OK, rc1 = RC_OK;                           
    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)      
4001a65c:	c4 07 60 10 	ld  [ %i5 + 0x10 ], %g2                        
4001a660:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
4001a664:	84 0f 00 02 	and  %i4, %g2, %g2                             
4001a668:	80 a0 80 01 	cmp  %g2, %g1                                  
4001a66c:	1a 80 00 17 	bcc  4001a6c8 <fat_free_fat_clusters_chain+0xb4>
4001a670:	b6 06 e0 01 	inc  %i3                                       
    {                                                                 
        rc = fat_get_fat_cluster(fs_info, cur_cln, &next_cln);        
4001a674:	92 10 00 1c 	mov  %i4, %o1                                  
4001a678:	94 07 bf fc 	add  %fp, -4, %o2                              
4001a67c:	7f ff fe b0 	call  4001a13c <fat_get_fat_cluster>           
4001a680:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
            fat_buf_release(fs_info);                                 
            return rc;                                                
        }                                                             
                                                                      
        rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE);  
4001a684:	92 10 00 1c 	mov  %i4, %o1                                  
    uint32_t       next_cln = 0;                                      
    uint32_t       freed_cls_cnt = 0;                                 
                                                                      
    while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)      
    {                                                                 
        rc = fat_get_fat_cluster(fs_info, cur_cln, &next_cln);        
4001a688:	b0 10 00 08 	mov  %o0, %i0                                  
                                                                      
            fat_buf_release(fs_info);                                 
            return rc;                                                
        }                                                             
                                                                      
        rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE);  
4001a68c:	94 10 20 00 	clr  %o2                                       
    uint32_t       freed_cls_cnt = 0;                                 
                                                                      
    while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)      
    {                                                                 
        rc = fat_get_fat_cluster(fs_info, cur_cln, &next_cln);        
        if ( rc != RC_OK )                                            
4001a690:	80 a6 20 00 	cmp  %i0, 0                                    
4001a694:	02 bf ff ec 	be  4001a644 <fat_free_fat_clusters_chain+0x30><== ALWAYS TAKEN
4001a698:	90 10 00 1d 	mov  %i5, %o0                                  
        {                                                             
              if(fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)        
4001a69c:	c2 07 60 44 	ld  [ %i5 + 0x44 ], %g1                        <== NOT EXECUTED
4001a6a0:	80 a0 7f ff 	cmp  %g1, -1                                   <== NOT EXECUTED
4001a6a4:	02 80 00 03 	be  4001a6b0 <fat_free_fat_clusters_chain+0x9c><== NOT EXECUTED
4001a6a8:	82 06 c0 01 	add  %i3, %g1, %g1                             <== NOT EXECUTED
                fs_info->vol.free_cls += freed_cls_cnt;               
4001a6ac:	c2 27 60 44 	st  %g1, [ %i5 + 0x44 ]                        <== NOT EXECUTED
                                                                      
            fat_buf_release(fs_info);                                 
4001a6b0:	7f ff e2 e5 	call  40013244 <fat_buf_release>               <== NOT EXECUTED
4001a6b4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001a6b8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001a6bc:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    )                                                                 
{                                                                     
    int            rc = RC_OK, rc1 = RC_OK;                           
    uint32_t       cur_cln = chain;                                   
    uint32_t       next_cln = 0;                                      
    uint32_t       freed_cls_cnt = 0;                                 
4001a6c0:	b6 10 20 00 	clr  %i3                                       <== NOT EXECUTED
fat_free_fat_clusters_chain(                                          
    fat_fs_info_t                        *fs_info,                    
    uint32_t                              chain                       
    )                                                                 
{                                                                     
    int            rc = RC_OK, rc1 = RC_OK;                           
4001a6c4:	b4 10 20 00 	clr  %i2                                       <== NOT EXECUTED
        freed_cls_cnt++;                                              
        cur_cln = next_cln;                                           
    }                                                                 
                                                                      
        fs_info->vol.next_cl = chain;                                 
        if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)             
4001a6c8:	c2 07 60 44 	ld  [ %i5 + 0x44 ], %g1                        
4001a6cc:	80 a0 7f ff 	cmp  %g1, -1                                   
4001a6d0:	02 80 00 04 	be  4001a6e0 <fat_free_fat_clusters_chain+0xcc><== ALWAYS TAKEN
4001a6d4:	f2 27 60 4c 	st  %i1, [ %i5 + 0x4c ]                        
            fs_info->vol.free_cls += freed_cls_cnt;                   
4001a6d8:	82 06 c0 01 	add  %i3, %g1, %g1                             <== NOT EXECUTED
4001a6dc:	c2 27 60 44 	st  %g1, [ %i5 + 0x44 ]                        <== NOT EXECUTED
                                                                      
    fat_buf_release(fs_info);                                         
4001a6e0:	b0 10 00 1a 	mov  %i2, %i0                                  
4001a6e4:	7f ff e2 d8 	call  40013244 <fat_buf_release>               
4001a6e8:	90 10 00 1d 	mov  %i5, %o0                                  
    if (rc1 != RC_OK)                                                 
        return rc1;                                                   
                                                                      
    return RC_OK;                                                     
}                                                                     
4001a6ec:	81 c7 e0 08 	ret                                            
4001a6f0:	81 e8 00 00 	restore                                        
                                                                      

400144a8 <fat_free_unique_ino>: fat_free_unique_ino( fat_fs_info_t *fs_info, uint32_t ino ) { FAT_SET_UNIQ_INO_FREE((ino - fs_info->uino_base), fs_info->uino);
400144a8:	c4 02 20 80 	ld  [ %o0 + 0x80 ], %g2                        <== NOT EXECUTED
400144ac:	c2 02 20 74 	ld  [ %o0 + 0x74 ], %g1                        <== NOT EXECUTED
400144b0:	92 22 40 02 	sub  %o1, %g2, %o1                             <== NOT EXECUTED
400144b4:	85 32 60 03 	srl  %o1, 3, %g2                               <== NOT EXECUTED
400144b8:	c6 08 40 02 	ldub  [ %g1 + %g2 ], %g3                       <== NOT EXECUTED
400144bc:	92 0a 60 07 	and  %o1, 7, %o1                               <== NOT EXECUTED
400144c0:	88 10 20 01 	mov  1, %g4                                    <== NOT EXECUTED
400144c4:	93 29 00 09 	sll  %g4, %o1, %o1                             <== NOT EXECUTED
400144c8:	92 28 c0 09 	andn  %g3, %o1, %o1                            <== NOT EXECUTED
400144cc:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
400144d0:	d2 28 40 02 	stb  %o1, [ %g1 + %g2 ]                        <== NOT EXECUTED
                                                                      

4001a13c <fat_get_fat_cluster>: fat_get_fat_cluster( fat_fs_info_t *fs_info, uint32_t cln, uint32_t *ret_val ) {
4001a13c:	9d e3 bf 98 	save  %sp, -104, %sp                           
    uint8_t                *sec_buf;                                  
    uint32_t                sec = 0;                                  
    uint32_t                ofs = 0;                                  
                                                                      
    /* sanity check */                                                
    if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )           
4001a140:	80 a6 60 01 	cmp  %i1, 1                                    
4001a144:	08 80 00 27 	bleu  4001a1e0 <fat_get_fat_cluster+0xa4>      <== NEVER TAKEN
4001a148:	ba 10 00 18 	mov  %i0, %i5                                  
4001a14c:	c2 06 20 38 	ld  [ %i0 + 0x38 ], %g1                        
4001a150:	82 00 60 01 	inc  %g1                                       
4001a154:	80 a6 40 01 	cmp  %i1, %g1                                  
4001a158:	18 80 00 22 	bgu  4001a1e0 <fat_get_fat_cluster+0xa4>       <== NEVER TAKEN
4001a15c:	01 00 00 00 	nop                                            
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
4001a160:	c2 0e 20 0e 	ldub  [ %i0 + 0xe ], %g1                       
4001a164:	80 88 60 01 	btst  1, %g1                                   
4001a168:	12 80 00 24 	bne  4001a1f8 <fat_get_fat_cluster+0xbc>       
4001a16c:	f6 0e 20 02 	ldub  [ %i0 + 2 ], %i3                         
4001a170:	82 08 60 02 	and  %g1, 2, %g1                               
4001a174:	80 88 60 ff 	btst  0xff, %g1                                
4001a178:	02 80 00 30 	be  4001a238 <fat_get_fat_cluster+0xfc>        
4001a17c:	c2 06 20 58 	ld  [ %i0 + 0x58 ], %g1                        
4001a180:	b9 2e 60 01 	sll  %i1, 1, %i4                               
4001a184:	b7 37 00 1b 	srl  %i4, %i3, %i3                             
4001a188:	b6 06 c0 01 	add  %i3, %g1, %i3                             
          fs_info->vol.afat_loc;                                      
    ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
4001a18c:	e0 17 40 00 	lduh  [ %i5 ], %l0                             
                                                                      
    rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);    
4001a190:	90 10 00 1d 	mov  %i5, %o0                                  
4001a194:	92 10 00 1b 	mov  %i3, %o1                                  
4001a198:	94 10 20 01 	mov  1, %o2                                    
4001a19c:	7f ff e4 a1 	call  40013420 <fat_buf_access>                
4001a1a0:	96 07 bf fc 	add  %fp, -4, %o3                              
    if (rc != RC_OK)                                                  
4001a1a4:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001a1a8:	12 80 00 57 	bne  4001a304 <fat_get_fat_cluster+0x1c8>      <== NEVER TAKEN
4001a1ac:	01 00 00 00 	nop                                            
        return rc;                                                    
                                                                      
    switch ( fs_info->vol.type )                                      
4001a1b0:	c2 0f 60 0e 	ldub  [ %i5 + 0xe ], %g1                       
    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);
4001a1b4:	a1 2c 20 10 	sll  %l0, 0x10, %l0                            
                                                                      
    rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);    
    if (rc != RC_OK)                                                  
        return rc;                                                    
                                                                      
    switch ( fs_info->vol.type )                                      
4001a1b8:	80 a0 60 02 	cmp  %g1, 2                                    
    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);
4001a1bc:	a1 34 20 10 	srl  %l0, 0x10, %l0                            
4001a1c0:	a0 04 3f ff 	add  %l0, -1, %l0                              
                                                                      
    rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);    
    if (rc != RC_OK)                                                  
        return rc;                                                    
                                                                      
    switch ( fs_info->vol.type )                                      
4001a1c4:	02 80 00 21 	be  4001a248 <fat_get_fat_cluster+0x10c>       
4001a1c8:	b8 0f 00 10 	and  %i4, %l0, %i4                             
4001a1cc:	80 a0 60 04 	cmp  %g1, 4                                    
4001a1d0:	02 80 00 3c 	be  4001a2c0 <fat_get_fat_cluster+0x184>       
4001a1d4:	80 a0 60 01 	cmp  %g1, 1                                    
4001a1d8:	02 80 00 28 	be  4001a278 <fat_get_fat_cluster+0x13c>       <== ALWAYS TAKEN
4001a1dc:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
            *ret_val = *((uint32_t   *)(sec_buf + ofs));              
            *ret_val = CF_LE_L(*ret_val);                             
            break;                                                    
                                                                      
        default:                                                      
            rtems_set_errno_and_return_minus_one(EIO);                
4001a1e0:	40 00 08 6c 	call  4001c390 <__errno>                       <== NOT EXECUTED
4001a1e4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4001a1e8:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
4001a1ec:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4001a1f0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001a1f4:	81 e8 00 00 	restore                                        <== 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) +
4001a1f8:	c2 06 20 58 	ld  [ %i0 + 0x58 ], %g1                        
4001a1fc:	b9 36 60 01 	srl  %i1, 1, %i4                               
          fs_info->vol.afat_loc;                                      
    ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
4001a200:	e0 17 40 00 	lduh  [ %i5 ], %l0                             
                                                                      
    /* 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) +
4001a204:	b8 07 00 19 	add  %i4, %i1, %i4                             
          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, &sec_buf);    
4001a208:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
    /* 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) +
4001a20c:	b7 37 00 1b 	srl  %i4, %i3, %i3                             
          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, &sec_buf);    
4001a210:	94 10 20 01 	mov  1, %o2                                    
                                                                      
    /* 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) +
4001a214:	b6 06 c0 01 	add  %i3, %g1, %i3                             
          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, &sec_buf);    
4001a218:	96 07 bf fc 	add  %fp, -4, %o3                              
4001a21c:	7f ff e4 81 	call  40013420 <fat_buf_access>                
4001a220:	92 10 00 1b 	mov  %i3, %o1                                  
    if (rc != RC_OK)                                                  
4001a224:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001a228:	22 bf ff e3 	be,a   4001a1b4 <fat_get_fat_cluster+0x78>     <== ALWAYS TAKEN
4001a22c:	c2 0f 60 0e 	ldub  [ %i5 + 0xe ], %g1                       
            rtems_set_errno_and_return_minus_one(EIO);                
            break;                                                    
    }                                                                 
                                                                      
    return RC_OK;                                                     
}                                                                     
4001a230:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001a234:	81 e8 00 00 	restore                                        <== 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) +
4001a238:	b9 2e 60 02 	sll  %i1, 2, %i4                               
4001a23c:	b7 37 00 1b 	srl  %i4, %i3, %i3                             
4001a240:	10 bf ff d3 	b  4001a18c <fat_get_fat_cluster+0x50>         
4001a244:	b6 06 c0 01 	add  %i3, %g1, %i3                             
            else                                                      
                *ret_val = (*ret_val) & FAT_FAT12_MASK;               
            break;                                                    
                                                                      
        case FAT_FAT16:                                               
            *ret_val = *((uint16_t   *)(sec_buf + ofs));              
4001a248:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
            *ret_val = CF_LE_W(*ret_val);                             
4001a24c:	07 00 00 3f 	sethi  %hi(0xfc00), %g3                        
            else                                                      
                *ret_val = (*ret_val) & FAT_FAT12_MASK;               
            break;                                                    
                                                                      
        case FAT_FAT16:                                               
            *ret_val = *((uint16_t   *)(sec_buf + ofs));              
4001a250:	c2 10 40 1c 	lduh  [ %g1 + %i4 ], %g1                       
            *ret_val = CF_LE_W(*ret_val);                             
4001a254:	86 10 e3 ff 	or  %g3, 0x3ff, %g3                            
4001a258:	83 28 60 10 	sll  %g1, 0x10, %g1                            
4001a25c:	85 30 60 18 	srl  %g1, 0x18, %g2                            
4001a260:	83 30 60 08 	srl  %g1, 8, %g1                               
4001a264:	82 08 40 03 	and  %g1, %g3, %g1                             
4001a268:	82 10 80 01 	or  %g2, %g1, %g1                              
4001a26c:	c2 26 80 00 	st  %g1, [ %i2 ]                               
            break;                                                    
4001a270:	81 c7 e0 08 	ret                                            
4001a274:	81 e8 00 00 	restore                                        
            /*                                                        
             * we are enforced in complex computations for FAT12 to escape CPU
             * align problems for some architectures                  
             */                                                       
            *ret_val = (*(sec_buf + ofs));                            
            if ( ofs == (fs_info->vol.bps - 1) )                      
4001a278:	c6 17 40 00 	lduh  [ %i5 ], %g3                             
        case FAT_FAT12:                                               
            /*                                                        
             * we are enforced in complex computations for FAT12 to escape CPU
             * align problems for some architectures                  
             */                                                       
            *ret_val = (*(sec_buf + ofs));                            
4001a27c:	c2 08 80 1c 	ldub  [ %g2 + %i4 ], %g1                       
            if ( ofs == (fs_info->vol.bps - 1) )                      
4001a280:	86 00 ff ff 	add  %g3, -1, %g3                              
4001a284:	80 a0 c0 1c 	cmp  %g3, %i4                                  
4001a288:	02 80 00 21 	be  4001a30c <fat_get_fat_cluster+0x1d0>       <== NEVER TAKEN
4001a28c:	c2 26 80 00 	st  %g1, [ %i2 ]                               
                                                                      
                *ret_val |= *sec_buf << 8;                            
            }                                                         
            else                                                      
            {                                                         
                *ret_val |= *(sec_buf + ofs + 1) << 8;                
4001a290:	b8 00 80 1c 	add  %g2, %i4, %i4                             
4001a294:	c4 0f 20 01 	ldub  [ %i4 + 1 ], %g2                         
4001a298:	85 28 a0 08 	sll  %g2, 8, %g2                               
4001a29c:	82 10 80 01 	or  %g2, %g1, %g1                              
4001a2a0:	c2 26 80 00 	st  %g1, [ %i2 ]                               
            }                                                         
                                                                      
            if ( FAT_CLUSTER_IS_ODD(cln) )                            
4001a2a4:	80 8e 60 01 	btst  1, %i1                                   
4001a2a8:	22 80 00 16 	be,a   4001a300 <fat_get_fat_cluster+0x1c4>    
4001a2ac:	82 08 6f ff 	and  %g1, 0xfff, %g1                           
                *ret_val = (*ret_val) >> FAT12_SHIFT;                 
4001a2b0:	83 30 60 04 	srl  %g1, 4, %g1                               
4001a2b4:	c2 26 80 00 	st  %g1, [ %i2 ]                               
4001a2b8:	81 c7 e0 08 	ret                                            
4001a2bc:	81 e8 00 00 	restore                                        
            *ret_val = *((uint16_t   *)(sec_buf + ofs));              
            *ret_val = CF_LE_W(*ret_val);                             
            break;                                                    
                                                                      
        case FAT_FAT32:                                               
            *ret_val = *((uint32_t   *)(sec_buf + ofs));              
4001a2c0:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4001a2c4:	c2 00 40 1c 	ld  [ %g1 + %i4 ], %g1                         
4001a2c8:	89 28 60 18 	sll  %g1, 0x18, %g4                            
  uint32_t value                                                      
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
4001a2cc:	85 30 60 18 	srl  %g1, 0x18, %g2                            
  byte3 = (value >> 16) & 0xff;                                       
  byte2 = (value >> 8)  & 0xff;                                       
4001a2d0:	87 30 60 08 	srl  %g1, 8, %g3                               
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
4001a2d4:	84 11 00 02 	or  %g4, %g2, %g2                              
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
  byte3 = (value >> 16) & 0xff;                                       
  byte2 = (value >> 8)  & 0xff;                                       
4001a2d8:	86 08 e0 ff 	and  %g3, 0xff, %g3                            
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
  byte3 = (value >> 16) & 0xff;                                       
4001a2dc:	83 30 60 10 	srl  %g1, 0x10, %g1                            
  byte2 = (value >> 8)  & 0xff;                                       
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
4001a2e0:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
  byte3 = (value >> 16) & 0xff;                                       
4001a2e4:	82 08 60 ff 	and  %g1, 0xff, %g1                            
  byte2 = (value >> 8)  & 0xff;                                       
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
4001a2e8:	84 10 80 03 	or  %g2, %g3, %g2                              
4001a2ec:	83 28 60 08 	sll  %g1, 8, %g1                               
4001a2f0:	82 10 80 01 	or  %g2, %g1, %g1                              
            *ret_val = CF_LE_L(*ret_val);                             
4001a2f4:	c2 26 80 00 	st  %g1, [ %i2 ]                               
            break;                                                    
4001a2f8:	81 c7 e0 08 	ret                                            
4001a2fc:	81 e8 00 00 	restore                                        
            }                                                         
                                                                      
            if ( FAT_CLUSTER_IS_ODD(cln) )                            
                *ret_val = (*ret_val) >> FAT12_SHIFT;                 
            else                                                      
                *ret_val = (*ret_val) & FAT_FAT12_MASK;               
4001a300:	c2 26 80 00 	st  %g1, [ %i2 ]                               
4001a304:	81 c7 e0 08 	ret                                            
4001a308:	81 e8 00 00 	restore                                        
             * align problems for some architectures                  
             */                                                       
            *ret_val = (*(sec_buf + ofs));                            
            if ( ofs == (fs_info->vol.bps - 1) )                      
            {                                                         
                rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
4001a30c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001a310:	92 06 e0 01 	add  %i3, 1, %o1                               <== NOT EXECUTED
4001a314:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
4001a318:	7f ff e4 42 	call  40013420 <fat_buf_access>                <== NOT EXECUTED
4001a31c:	96 07 bf fc 	add  %fp, -4, %o3                              <== NOT EXECUTED
                                    &sec_buf);                        
                if (rc != RC_OK)                                      
4001a320:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4001a324:	12 80 00 08 	bne  4001a344 <fat_get_fat_cluster+0x208>      <== NOT EXECUTED
4001a328:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          <== NOT EXECUTED
                    return rc;                                        
                                                                      
                *ret_val |= *sec_buf << 8;                            
4001a32c:	c2 06 80 00 	ld  [ %i2 ], %g1                               <== NOT EXECUTED
4001a330:	c4 08 80 00 	ldub  [ %g2 ], %g2                             <== NOT EXECUTED
4001a334:	85 28 a0 08 	sll  %g2, 8, %g2                               <== NOT EXECUTED
4001a338:	82 10 80 01 	or  %g2, %g1, %g1                              <== NOT EXECUTED
4001a33c:	10 bf ff da 	b  4001a2a4 <fat_get_fat_cluster+0x168>        <== NOT EXECUTED
4001a340:	c2 26 80 00 	st  %g1, [ %i2 ]                               <== NOT EXECUTED
            rtems_set_errno_and_return_minus_one(EIO);                
            break;                                                    
    }                                                                 
                                                                      
    return RC_OK;                                                     
}                                                                     
4001a344:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001a348:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
                                                                      

400143b8 <fat_get_unique_ino>: * 0 means FAILED !!! * */ uint32_t fat_get_unique_ino(fat_fs_info_t *fs_info) {
400143b8:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
400143bc:	fa 06 20 7c 	ld  [ %i0 + 0x7c ], %i5                        <== 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))
400143c0:	33 03 ff ff 	sethi  %hi(0xffffc00), %i1                     <== NOT EXECUTED
400143c4:	b2 16 63 ff 	or  %i1, 0x3ff, %i1	! fffffff <RAM_SIZE+0xfbfffff><== NOT EXECUTED
    uint32_t                j = 0;                                    
    bool                    resrc_unsuff = false;                     
                                                                      
    while (!resrc_unsuff)                                             
    {                                                                 
        for (j = 0; j < fs_info->uino_pool_size; j++)                 
400143c8:	80 a7 60 00 	cmp  %i5, 0                                    <== NOT EXECUTED
400143cc:	22 80 00 20 	be,a   4001444c <fat_get_unique_ino+0x94>      <== NOT EXECUTED
400143d0:	c2 06 20 80 	ld  [ %i0 + 0x80 ], %g1                        <== NOT EXECUTED
        {                                                             
            if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino)) 
400143d4:	c6 06 20 74 	ld  [ %i0 + 0x74 ], %g3                        <== NOT EXECUTED
400143d8:	c2 06 20 78 	ld  [ %i0 + 0x78 ], %g1                        <== NOT EXECUTED
400143dc:	85 30 60 03 	srl  %g1, 3, %g2                               <== NOT EXECUTED
400143e0:	c8 48 c0 02 	ldsb  [ %g3 + %g2 ], %g4                       <== NOT EXECUTED
400143e4:	b8 08 60 07 	and  %g1, 7, %i4                               <== NOT EXECUTED
400143e8:	b4 00 c0 02 	add  %g3, %g2, %i2                             <== NOT EXECUTED
400143ec:	89 39 00 1c 	sra  %g4, %i4, %g4                             <== NOT EXECUTED
400143f0:	80 89 20 01 	btst  1, %g4                                   <== NOT EXECUTED
400143f4:	02 80 00 1d 	be  40014468 <fat_get_unique_ino+0xb0>         <== NOT EXECUTED
400143f8:	c4 08 c0 02 	ldub  [ %g3 + %g2 ], %g2                       <== NOT EXECUTED
400143fc:	10 80 00 0a 	b  40014424 <fat_get_unique_ino+0x6c>          <== NOT EXECUTED
40014400:	88 10 20 00 	clr  %g4                                       <== NOT EXECUTED
40014404:	85 30 60 03 	srl  %g1, 3, %g2                               <== NOT EXECUTED
40014408:	f6 48 c0 02 	ldsb  [ %g3 + %g2 ], %i3                       <== NOT EXECUTED
4001440c:	b8 08 60 07 	and  %g1, 7, %i4                               <== NOT EXECUTED
40014410:	b4 00 c0 02 	add  %g3, %g2, %i2                             <== NOT EXECUTED
40014414:	b7 3e c0 1c 	sra  %i3, %i4, %i3                             <== NOT EXECUTED
40014418:	80 8e e0 01 	btst  1, %i3                                   <== NOT EXECUTED
4001441c:	02 80 00 13 	be  40014468 <fat_get_unique_ino+0xb0>         <== NOT EXECUTED
40014420:	c4 08 c0 02 	ldub  [ %g3 + %g2 ], %g2                       <== NOT EXECUTED
            {                                                         
                FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino); 
                return (fs_info->uino_base + fs_info->index);         
            }                                                         
            fs_info->index++;                                         
40014424:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
            if (fs_info->index >= fs_info->uino_pool_size)            
40014428:	80 a0 40 1d 	cmp  %g1, %i5                                  <== NOT EXECUTED
4001442c:	0a 80 00 03 	bcs  40014438 <fat_get_unique_ino+0x80>        <== NOT EXECUTED
40014430:	c2 26 20 78 	st  %g1, [ %i0 + 0x78 ]                        <== NOT EXECUTED
                fs_info->index = 0;                                   
40014434:	c0 26 20 78 	clr  [ %i0 + 0x78 ]                            <== NOT EXECUTED
    uint32_t                j = 0;                                    
    bool                    resrc_unsuff = false;                     
                                                                      
    while (!resrc_unsuff)                                             
    {                                                                 
        for (j = 0; j < fs_info->uino_pool_size; j++)                 
40014438:	88 01 20 01 	inc  %g4                                       <== NOT EXECUTED
4001443c:	80 a1 00 1d 	cmp  %g4, %i5                                  <== NOT EXECUTED
40014440:	32 bf ff f1 	bne,a   40014404 <fat_get_unique_ino+0x4c>     <== NOT EXECUTED
40014444:	c2 06 20 78 	ld  [ %i0 + 0x78 ], %g1                        <== 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))
40014448:	c2 06 20 80 	ld  [ %i0 + 0x80 ], %g1                        <== NOT EXECUTED
4001444c:	93 2f 60 01 	sll  %i5, 1, %o1                               <== NOT EXECUTED
40014450:	82 26 40 01 	sub  %i1, %g1, %g1                             <== NOT EXECUTED
40014454:	80 a2 40 01 	cmp  %o1, %g1                                  <== NOT EXECUTED
40014458:	2a 80 00 0c 	bcs,a   40014488 <fat_get_unique_ino+0xd0>     <== NOT EXECUTED
4001445c:	d0 06 20 74 	ld  [ %i0 + 0x74 ], %o0                        <== NOT EXECUTED
        }                                                             
        else                                                          
            resrc_unsuff = true;                                      
    }                                                                 
    return 0;                                                         
}                                                                     
40014460:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40014464:	91 e8 20 00 	restore  %g0, 0, %o0                           <== NOT EXECUTED
    {                                                                 
        for (j = 0; j < fs_info->uino_pool_size; j++)                 
        {                                                             
            if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino)) 
            {                                                         
                FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino); 
40014468:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
4001446c:	b9 28 40 1c 	sll  %g1, %i4, %i4                             <== NOT EXECUTED
40014470:	84 17 00 02 	or  %i4, %g2, %g2                              <== NOT EXECUTED
40014474:	c4 2e 80 00 	stb  %g2, [ %i2 ]                              <== NOT EXECUTED
                return (fs_info->uino_base + fs_info->index);         
40014478:	c4 06 20 78 	ld  [ %i0 + 0x78 ], %g2                        <== NOT EXECUTED
4001447c:	c2 06 20 80 	ld  [ %i0 + 0x80 ], %g1                        <== NOT EXECUTED
40014480:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40014484:	91 e8 80 01 	restore  %g2, %g1, %o0                         <== 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);
40014488:	7f ff c5 ce 	call  40005bc0 <realloc>                       <== NOT EXECUTED
4001448c:	d2 26 20 7c 	st  %o1, [ %i0 + 0x7c ]                        <== NOT EXECUTED
            if (fs_info->uino != NULL)                                
40014490:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40014494:	02 bf ff f3 	be  40014460 <fat_get_unique_ino+0xa8>         <== NOT EXECUTED
40014498:	d0 26 20 74 	st  %o0, [ %i0 + 0x74 ]                        <== NOT EXECUTED
                fs_info->index = fs_info->uino_pool_size;             
4001449c:	fa 06 20 7c 	ld  [ %i0 + 0x7c ], %i5                        <== NOT EXECUTED
400144a0:	10 bf ff ca 	b  400143c8 <fat_get_unique_ino+0x10>          <== NOT EXECUTED
400144a4:	fa 26 20 78 	st  %i5, [ %i0 + 0x78 ]                        <== NOT EXECUTED
                                                                      

4001433c <fat_init_clusters_chain>: int fat_init_clusters_chain( fat_fs_info_t *fs_info, uint32_t start_cln ) {
4001433c:	9d e3 bf 98 	save  %sp, -104, %sp                           
40014340:	f2 27 bf fc 	st  %i1, [ %fp + -4 ]                          
    int                     rc = RC_OK;                               
    ssize_t                 ret = 0;                                  
    uint32_t                cur_cln = start_cln;                      
                                                                      
    while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)      
40014344:	c4 06 20 10 	ld  [ %i0 + 0x10 ], %g2                        
40014348:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
    {                                                                 
        ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0);
4001434c:	92 10 00 19 	mov  %i1, %o1                                  
40014350:	94 10 20 00 	clr  %o2                                       
{                                                                     
    int                     rc = RC_OK;                               
    ssize_t                 ret = 0;                                  
    uint32_t                cur_cln = start_cln;                      
                                                                      
    while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)      
40014354:	b2 0e 40 02 	and  %i1, %g2, %i1                             
    {                                                                 
        ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0);
40014358:	98 10 20 00 	clr  %o4                                       
{                                                                     
    int                     rc = RC_OK;                               
    ssize_t                 ret = 0;                                  
    uint32_t                cur_cln = start_cln;                      
                                                                      
    while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)      
4001435c:	80 a6 40 01 	cmp  %i1, %g1                                  
40014360:	1a 80 00 10 	bcc  400143a0 <fat_init_clusters_chain+0x64>   
40014364:	90 10 00 18 	mov  %i0, %o0                                  
    {                                                                 
        ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0);
40014368:	7f ff fc a8 	call  40013608 <fat_cluster_set>               
4001436c:	d6 16 20 06 	lduh  [ %i0 + 6 ], %o3                         
        if ( ret != fs_info->vol.bpc )                                
40014370:	c2 16 20 06 	lduh  [ %i0 + 6 ], %g1                         
        {                                                             
            return -1;                                                
        }                                                             
                                                                      
        rc  = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);        
40014374:	94 07 bf fc 	add  %fp, -4, %o2                              
    uint32_t                cur_cln = start_cln;                      
                                                                      
    while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)      
    {                                                                 
        ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0);
        if ( ret != fs_info->vol.bpc )                                
40014378:	80 a0 40 08 	cmp  %g1, %o0                                  
4001437c:	12 80 00 0c 	bne  400143ac <fat_init_clusters_chain+0x70>   <== NEVER TAKEN
40014380:	90 10 00 18 	mov  %i0, %o0                                  
        {                                                             
            return -1;                                                
        }                                                             
                                                                      
        rc  = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);        
40014384:	40 00 17 6e 	call  4001a13c <fat_get_fat_cluster>           
40014388:	d2 07 bf fc 	ld  [ %fp + -4 ], %o1                          
        if ( rc != RC_OK )                                            
4001438c:	80 a2 20 00 	cmp  %o0, 0                                    
40014390:	02 bf ff ed 	be  40014344 <fat_init_clusters_chain+0x8>     <== ALWAYS TAKEN
40014394:	f2 07 bf fc 	ld  [ %fp + -4 ], %i1                          
        }                                                             
                                                                      
    }                                                                 
                                                                      
    return rc;                                                        
}                                                                     
40014398:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001439c:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
            return rc;                                                
        }                                                             
                                                                      
    }                                                                 
                                                                      
    return rc;                                                        
400143a0:	90 10 20 00 	clr  %o0                                       
}                                                                     
400143a4:	81 c7 e0 08 	ret                                            
400143a8:	91 e8 00 08 	restore  %g0, %o0, %o0                         
    while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)      
    {                                                                 
        ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0);
        if ( ret != fs_info->vol.bpc )                                
        {                                                             
            return -1;                                                
400143ac:	90 10 3f ff 	mov  -1, %o0                                   <== NOT EXECUTED
        }                                                             
                                                                      
    }                                                                 
                                                                      
    return rc;                                                        
}                                                                     
400143b0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400143b4:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
                                                                      

40013910 <fat_init_volume_info>: * RC_OK on success, or -1 if error occured * and errno set appropriately */ int fat_init_volume_info(fat_fs_info_t *fs_info, const char *device) {
40013910:	9d e3 bf 10 	save  %sp, -240, %sp                           
    ssize_t             ret = 0;                                      
    struct stat         stat_buf;                                     
    int                 i = 0;                                        
    rtems_bdbuf_buffer *block = NULL;                                 
                                                                      
    vol->fd = open(device, O_RDWR);                                   
40013914:	92 10 20 02 	mov  2, %o1                                    
    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;                                 
40013918:	c0 27 bf a4 	clr  [ %fp + -92 ]                             
                                                                      
    vol->fd = open(device, O_RDWR);                                   
4001391c:	7f ff c8 0c 	call  4000594c <open>                          
40013920:	90 10 00 19 	mov  %i1, %o0                                  
    if (vol->fd < 0)                                                  
40013924:	80 a2 20 00 	cmp  %o0, 0                                    
40013928:	06 80 01 c1 	bl  4001402c <fat_init_volume_info+0x71c>      <== NEVER TAKEN
4001392c:	d0 26 20 60 	st  %o0, [ %i0 + 0x60 ]                        
    {                                                                 
        rtems_set_errno_and_return_minus_one(ENXIO);                  
    }                                                                 
                                                                      
    rc = fstat(vol->fd, &stat_buf);                                   
40013930:	7f ff c4 c9 	call  40004c54 <fstat>                         
40013934:	92 07 bf b8 	add  %fp, -72, %o1                             
    if (rc != 0)                                                      
40013938:	80 a2 20 00 	cmp  %o0, 0                                    
4001393c:	12 80 01 b9 	bne  40014020 <fat_init_volume_info+0x710>     <== NEVER TAKEN
40013940:	c6 07 bf c4 	ld  [ %fp + -60 ], %g3                         
        close(vol->fd);                                               
        rtems_set_errno_and_return_minus_one(ENXIO);                  
    }                                                                 
                                                                      
    /* Must be a block device. */                                     
    if (!S_ISBLK(stat_buf.st_mode))                                   
40013944:	05 00 00 3c 	sethi  %hi(0xf000), %g2                        
40013948:	86 08 c0 02 	and  %g3, %g2, %g3                             
4001394c:	05 00 00 18 	sethi  %hi(0x6000), %g2                        
40013950:	80 a0 c0 02 	cmp  %g3, %g2                                  
40013954:	12 80 01 b4 	bne  40014024 <fat_init_volume_info+0x714>     <== NEVER TAKEN
40013958:	d0 06 20 60 	ld  [ %i0 + 0x60 ], %o0                        
static inline int rtems_disk_fd_get_disk_device(                      
  int fd,                                                             
  rtems_disk_device **dd_ptr                                          
)                                                                     
{                                                                     
  return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);                   
4001395c:	94 06 20 64 	add  %i0, 0x64, %o2                            
40013960:	13 10 01 10 	sethi  %hi(0x40044000), %o1                    
40013964:	40 00 05 c6 	call  4001507c <ioctl>                         
40013968:	92 12 62 09 	or  %o1, 0x209, %o1	! 40044209 <__end+0x15179> 
        rtems_set_errno_and_return_minus_one(ENXIO);                  
    }                                                                 
                                                                      
    /* check that device is registred as block device and lock it */  
    rc = rtems_disk_fd_get_disk_device(vol->fd, &vol->dd);            
    if (rc != 0) {                                                    
4001396c:	80 a2 20 00 	cmp  %o0, 0                                    
40013970:	12 80 01 ac 	bne  40014020 <fat_init_volume_info+0x710>     <== NEVER TAKEN
40013974:	92 10 20 00 	clr  %o1                                       
        rtems_set_errno_and_return_minus_one(ENXIO);                  
    }                                                                 
                                                                      
    /* Read boot record */                                            
    /* FIXME: Asserts FAT_MAX_BPB_SIZE < bdbuf block size */          
    sc = rtems_bdbuf_read( vol->dd, 0, &block);                       
40013978:	d0 06 20 64 	ld  [ %i0 + 0x64 ], %o0                        
4001397c:	7f ff f5 c8 	call  4001109c <rtems_bdbuf_read>              
40013980:	94 07 bf a4 	add  %fp, -92, %o2                             
    if (sc != RTEMS_SUCCESSFUL)                                       
40013984:	80 a2 20 00 	cmp  %o0, 0                                    
40013988:	12 80 01 b5 	bne  4001405c <fat_init_volume_info+0x74c>     <== NEVER TAKEN
4001398c:	d0 07 bf a4 	ld  [ %fp + -92 ], %o0                         
    {                                                                 
        close(vol->fd);                                               
        rtems_set_errno_and_return_minus_one( EIO);                   
    }                                                                 
                                                                      
    memcpy( boot_rec, block->buffer, FAT_MAX_BPB_SIZE);               
40013990:	c4 02 20 1c 	ld  [ %o0 + 0x1c ], %g2                        
40013994:	c2 08 a0 20 	ldub  [ %g2 + 0x20 ], %g1                      
40013998:	f8 08 a0 0b 	ldub  [ %g2 + 0xb ], %i4                       
4001399c:	c2 2f bf 93 	stb  %g1, [ %fp + -109 ]                       
400139a0:	c2 08 a0 21 	ldub  [ %g2 + 0x21 ], %g1                      
400139a4:	f6 08 a0 0c 	ldub  [ %g2 + 0xc ], %i3                       
400139a8:	c2 2f bf 95 	stb  %g1, [ %fp + -107 ]                       
400139ac:	c2 08 a0 22 	ldub  [ %g2 + 0x22 ], %g1                      
400139b0:	ec 08 a0 0d 	ldub  [ %g2 + 0xd ], %l6                       
400139b4:	c2 2f bf 94 	stb  %g1, [ %fp + -108 ]                       
400139b8:	c2 08 a0 23 	ldub  [ %g2 + 0x23 ], %g1                      
400139bc:	e8 08 a0 0e 	ldub  [ %g2 + 0xe ], %l4                       
400139c0:	c2 2f bf 8f 	stb  %g1, [ %fp + -113 ]                       
400139c4:	c2 08 a0 25 	ldub  [ %g2 + 0x25 ], %g1                      
400139c8:	ea 08 a0 0f 	ldub  [ %g2 + 0xf ], %l5                       
400139cc:	c2 2f bf 97 	stb  %g1, [ %fp + -105 ]                       
400139d0:	c2 08 a0 26 	ldub  [ %g2 + 0x26 ], %g1                      
400139d4:	fa 08 a0 10 	ldub  [ %g2 + 0x10 ], %i5                      
400139d8:	c2 2f bf 96 	stb  %g1, [ %fp + -106 ]                       
400139dc:	c2 08 a0 27 	ldub  [ %g2 + 0x27 ], %g1                      
400139e0:	f4 08 a0 11 	ldub  [ %g2 + 0x11 ], %i2                      
400139e4:	c2 2f bf 9f 	stb  %g1, [ %fp + -97 ]                        
400139e8:	c2 08 a0 28 	ldub  [ %g2 + 0x28 ], %g1                      
400139ec:	f2 08 a0 12 	ldub  [ %g2 + 0x12 ], %i1                      
400139f0:	c2 2f bf 87 	stb  %g1, [ %fp + -121 ]                       
400139f4:	c2 08 a0 2c 	ldub  [ %g2 + 0x2c ], %g1                      
400139f8:	e0 08 a0 13 	ldub  [ %g2 + 0x13 ], %l0                      
400139fc:	c2 2f bf 90 	stb  %g1, [ %fp + -112 ]                       
40013a00:	c2 08 a0 2d 	ldub  [ %g2 + 0x2d ], %g1                      
40013a04:	e2 08 a0 14 	ldub  [ %g2 + 0x14 ], %l1                      
40013a08:	e4 08 a0 16 	ldub  [ %g2 + 0x16 ], %l2                      
40013a0c:	e6 08 a0 17 	ldub  [ %g2 + 0x17 ], %l3                      
40013a10:	ee 08 a0 24 	ldub  [ %g2 + 0x24 ], %l7                      
40013a14:	c2 2f bf 7f 	stb  %g1, [ %fp + -129 ]                       
40013a18:	c2 08 a0 2e 	ldub  [ %g2 + 0x2e ], %g1                      
40013a1c:	c2 2f bf 7e 	stb  %g1, [ %fp + -130 ]                       
40013a20:	c2 08 a0 2f 	ldub  [ %g2 + 0x2f ], %g1                      
40013a24:	c2 2f bf 77 	stb  %g1, [ %fp + -137 ]                       
40013a28:	c2 08 a0 30 	ldub  [ %g2 + 0x30 ], %g1                      
40013a2c:	c4 08 a0 31 	ldub  [ %g2 + 0x31 ], %g2                      
40013a30:	c2 2f bf 92 	stb  %g1, [ %fp + -110 ]                       
                                                                      
    sc = rtems_bdbuf_release( block);                                 
40013a34:	7f ff f6 1f 	call  400112b0 <rtems_bdbuf_release>           
40013a38:	c4 2f bf 91 	stb  %g2, [ %fp + -111 ]                       
    if (sc != RTEMS_SUCCESSFUL)                                       
40013a3c:	80 a2 20 00 	cmp  %o0, 0                                    
40013a40:	12 80 01 87 	bne  4001405c <fat_init_volume_info+0x74c>     <== NEVER TAKEN
40013a44:	b6 0e e0 ff 	and  %i3, 0xff, %i3                            
        close(vol->fd);                                               
        rtems_set_errno_and_return_minus_one( EIO );                  
    }                                                                 
                                                                      
    /* Evaluate boot record */                                        
    vol->bps = FAT_GET_BR_BYTES_PER_SECTOR(boot_rec);                 
40013a48:	b8 0f 20 ff 	and  %i4, 0xff, %i4                            
40013a4c:	b7 2e e0 08 	sll  %i3, 8, %i3                               
40013a50:	b8 16 c0 1c 	or  %i3, %i4, %i4                              
40013a54:	f8 36 00 00 	sth  %i4, [ %i0 ]                              
                                                                      
    if ( (vol->bps != 512)  &&                                        
40013a58:	93 2f 20 10 	sll  %i4, 0x10, %o1                            
40013a5c:	85 32 60 10 	srl  %o1, 0x10, %g2                            
40013a60:	80 a0 a4 00 	cmp  %g2, 0x400                                
40013a64:	12 80 00 dc 	bne  40013dd4 <fat_init_volume_info+0x4c4>     <== ALWAYS TAKEN
40013a68:	9a 10 00 1c 	mov  %i4, %o5                                  
         (vol->bps != 4096))                                          
    {                                                                 
        close(vol->fd);                                               
        rtems_set_errno_and_return_minus_one( EINVAL );               
    }                                                                 
    for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
40013a6c:	85 32 60 19 	srl  %o1, 0x19, %g2                            <== NOT EXECUTED
40013a70:	80 88 a0 01 	btst  1, %g2                                   
40013a74:	12 80 00 0a 	bne  40013a9c <fat_init_volume_info+0x18c>     <== ALWAYS TAKEN
40013a78:	c0 2e 20 03 	clrb  [ %i0 + 3 ]                              
 *     RC_OK on success, or -1 if error occured                       
 *     and errno set appropriately                                    
 */                                                                   
int                                                                   
fat_init_volume_info(fat_fs_info_t *fs_info, const char *device)      
{                                                                     
40013a7c:	10 80 00 03 	b  40013a88 <fat_init_volume_info+0x178>       <== NOT EXECUTED
40013a80:	88 10 20 01 	mov  1, %g4                                    <== NOT EXECUTED
         (vol->bps != 4096))                                          
    {                                                                 
        close(vol->fd);                                               
        rtems_set_errno_and_return_minus_one( EINVAL );               
    }                                                                 
    for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
40013a84:	88 10 00 01 	mov  %g1, %g4                                  <== NOT EXECUTED
         i >>= 1, vol->sec_mul++);                                    
40013a88:	85 38 a0 01 	sra  %g2, 1, %g2                               <== NOT EXECUTED
         (vol->bps != 4096))                                          
    {                                                                 
        close(vol->fd);                                               
        rtems_set_errno_and_return_minus_one( EINVAL );               
    }                                                                 
    for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
40013a8c:	80 88 a0 01 	btst  1, %g2                                   <== NOT EXECUTED
40013a90:	02 bf ff fd 	be  40013a84 <fat_init_volume_info+0x174>      <== NOT EXECUTED
40013a94:	82 01 20 01 	add  %g4, 1, %g1                               <== NOT EXECUTED
40013a98:	c8 2e 20 03 	stb  %g4, [ %i0 + 3 ]                          <== NOT EXECUTED
         i >>= 1, vol->sec_mul++);                                    
    for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;               
40013a9c:	c0 2e 20 02 	clrb  [ %i0 + 2 ]                              
40013aa0:	93 32 60 10 	srl  %o1, 0x10, %o1                            
40013aa4:	b6 10 20 01 	mov  1, %i3                                    
40013aa8:	80 8f 20 01 	btst  1, %i4                                   
40013aac:	02 80 00 05 	be  40013ac0 <fat_init_volume_info+0x1b0>      <== ALWAYS TAKEN
40013ab0:	84 10 00 09 	mov  %o1, %g2                                  
40013ab4:	10 80 01 66 	b  4001404c <fat_init_volume_info+0x73c>       <== NOT EXECUTED
40013ab8:	b6 10 20 00 	clr  %i3                                       <== NOT EXECUTED
40013abc:	b6 10 00 01 	mov  %g1, %i3                                  
         i >>= 1, vol->sec_log2++);                                   
40013ac0:	85 38 a0 01 	sra  %g2, 1, %g2                               
        close(vol->fd);                                               
        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;               
40013ac4:	80 88 a0 01 	btst  1, %g2                                   
40013ac8:	02 bf ff fd 	be  40013abc <fat_init_volume_info+0x1ac>      
40013acc:	82 06 e0 01 	add  %i3, 1, %g1                               
40013ad0:	f6 2e 20 02 	stb  %i3, [ %i0 + 2 ]                          
         i >>= 1, vol->sec_log2++);                                   
                                                                      
    vol->bytes_per_block = vol->bps;                                  
    vol->bytes_per_block_log2 = vol->sec_log2;                        
    vol->sectors_per_block = 1;                                       
40013ad4:	84 10 20 01 	mov  1, %g2                                    
    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->bytes_per_block = vol->bps;                                  
40013ad8:	da 36 20 0a 	sth  %o5, [ %i0 + 0xa ]                        
    vol->bytes_per_block_log2 = vol->sec_log2;                        
40013adc:	f6 2e 20 0c 	stb  %i3, [ %i0 + 0xc ]                        
    vol->sectors_per_block = 1;                                       
40013ae0:	c4 2e 20 09 	stb  %g2, [ %i0 + 9 ]                          
    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)                                                
40013ae4:	b8 8d a0 ff 	andcc  %l6, 0xff, %i4                          
40013ae8:	02 80 01 45 	be  40013ffc <fat_init_volume_info+0x6ec>      <== NEVER TAKEN
40013aec:	ec 2e 20 04 	stb  %l6, [ %i0 + 4 ]                          
    {                                                                 
        close(vol->fd);                                               
        rtems_set_errno_and_return_minus_one(EINVAL);                 
    }                                                                 
                                                                      
    for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;               
40013af0:	c0 2e 20 05 	clrb  [ %i0 + 5 ]                              
40013af4:	80 8d a0 01 	btst  1, %l6                                   
40013af8:	12 80 01 57 	bne  40014054 <fat_init_volume_info+0x744>     
40013afc:	84 10 00 1c 	mov  %i4, %g2                                  
40013b00:	10 80 00 03 	b  40013b0c <fat_init_volume_info+0x1fc>       
40013b04:	86 10 20 01 	mov  1, %g3                                    
40013b08:	86 10 00 01 	mov  %g1, %g3                                  
         i >>= 1, vol->spc_log2++);                                   
40013b0c:	85 38 a0 01 	sra  %g2, 1, %g2                               
    {                                                                 
        close(vol->fd);                                               
        rtems_set_errno_and_return_minus_one(EINVAL);                 
    }                                                                 
                                                                      
    for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;               
40013b10:	80 88 a0 01 	btst  1, %g2                                   
40013b14:	02 bf ff fd 	be  40013b08 <fat_init_volume_info+0x1f8>      
40013b18:	82 00 e0 01 	add  %g3, 1, %g1                               
40013b1c:	c6 2e 20 05 	stb  %g3, [ %i0 + 5 ]                          
40013b20:	86 08 e0 ff 	and  %g3, 0xff, %g3                            
         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)
40013b24:	87 2a 40 03 	sll  %o1, %g3, %g3                             
40013b28:	89 28 e0 10 	sll  %g3, 0x10, %g4                            
40013b2c:	05 20 00 00 	sethi  %hi(0x80000000), %g2                    
40013b30:	80 a1 00 02 	cmp  %g4, %g2                                  
40013b34:	18 80 01 32 	bgu  40013ffc <fat_init_volume_info+0x6ec>     <== NEVER TAKEN
40013b38:	c6 36 20 06 	sth  %g3, [ %i0 + 6 ]                          
    {                                                                 
        close(vol->fd);                                               
        rtems_set_errno_and_return_minus_one(EINVAL);                 
    }                                                                 
                                                                      
    for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;               
40013b3c:	c0 2e 20 08 	clrb  [ %i0 + 8 ]                              
40013b40:	05 00 00 3f 	sethi  %hi(0xfc00), %g2                        
40013b44:	88 10 20 01 	mov  1, %g4                                    
40013b48:	84 10 a3 ff 	or  %g2, 0x3ff, %g2                            
40013b4c:	80 88 e0 01 	btst  1, %g3                                   
40013b50:	02 80 00 05 	be  40013b64 <fat_init_volume_info+0x254>      <== ALWAYS TAKEN
40013b54:	84 08 c0 02 	and  %g3, %g2, %g2                             
         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);        
40013b58:	10 80 00 09 	b  40013b7c <fat_init_volume_info+0x26c>       <== NOT EXECUTED
40013b5c:	b4 0e a0 ff 	and  %i2, 0xff, %i2                            <== NOT EXECUTED
    {                                                                 
        close(vol->fd);                                               
        rtems_set_errno_and_return_minus_one(EINVAL);                 
    }                                                                 
                                                                      
    for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;               
40013b60:	88 10 00 01 	mov  %g1, %g4                                  
         i >>= 1, vol->bpc_log2++);                                   
40013b64:	85 38 a0 01 	sra  %g2, 1, %g2                               
    {                                                                 
        close(vol->fd);                                               
        rtems_set_errno_and_return_minus_one(EINVAL);                 
    }                                                                 
                                                                      
    for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;               
40013b68:	80 88 a0 01 	btst  1, %g2                                   
40013b6c:	02 bf ff fd 	be  40013b60 <fat_init_volume_info+0x250>      
40013b70:	82 01 20 01 	add  %g4, 1, %g1                               
40013b74:	c8 2e 20 08 	stb  %g4, [ %i0 + 8 ]                          
         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);        
40013b78:	b4 0e a0 ff 	and  %i2, 0xff, %i2                            
40013b7c:	b2 0e 60 ff 	and  %i1, 0xff, %i1                            
40013b80:	b3 2e 60 08 	sll  %i1, 8, %i1                               
40013b84:	b2 16 40 1a 	or  %i1, %i2, %i1                              
                                                                      
    /* calculate the count of sectors occupied by the root directory */
    vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
40013b88:	87 2e 60 10 	sll  %i1, 0x10, %g3                            
40013b8c:	87 30 e0 0b 	srl  %g3, 0xb, %g3                             
40013b90:	90 02 7f ff 	add  %o1, -1, %o0                              
    }                                                                 
                                                                      
    for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;               
         i >>= 1, vol->bpc_log2++);                                   
                                                                      
    vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);                         
40013b94:	fa 2e 20 0d 	stb  %i5, [ %i0 + 0xd ]                        
    vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);         
40013b98:	aa 0d 60 ff 	and  %l5, 0xff, %l5                            
40013b9c:	a8 0d 20 ff 	and  %l4, 0xff, %l4                            
40013ba0:	ab 2d 60 08 	sll  %l5, 8, %l5                               
                                                                      
    vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);        
40013ba4:	f2 36 20 24 	sth  %i1, [ %i0 + 0x24 ]                       
                                                                      
    for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;               
         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);         
40013ba8:	a8 15 40 14 	or  %l5, %l4, %l4                              
                                                                      
    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)) /
40013bac:	90 00 c0 08 	add  %g3, %o0, %o0                             
40013bb0:	7f ff ba b3 	call  4000267c <.div>                          
40013bb4:	e8 36 20 18 	sth  %l4, [ %i0 + 0x18 ]                       
                     vol->bps;                                        
                                                                      
    vol->rdir_size = vol->rdir_secs << vol->sec_log2;                 
40013bb8:	b7 2a 00 1b 	sll  %o0, %i3, %i3                             
    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)) /
40013bbc:	d0 26 20 28 	st  %o0, [ %i0 + 0x28 ]                        
40013bc0:	b4 10 00 08 	mov  %o0, %i2                                  
                     vol->bps;                                        
                                                                      
    vol->rdir_size = vol->rdir_secs << vol->sec_log2;                 
                                                                      
    if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)                 
40013bc4:	a4 0c a0 ff 	and  %l2, 0xff, %l2                            
40013bc8:	90 0c e0 ff 	and  %l3, 0xff, %o0                            
40013bcc:	91 2a 20 08 	sll  %o0, 8, %o0                               
40013bd0:	90 12 00 12 	or  %o0, %l2, %o0                              
40013bd4:	91 2a 20 10 	sll  %o0, 0x10, %o0                            
40013bd8:	80 a2 20 00 	cmp  %o0, 0                                    
40013bdc:	02 80 00 8a 	be  40013e04 <fat_init_volume_info+0x4f4>      
40013be0:	f6 26 20 2c 	st  %i3, [ %i0 + 0x2c ]                        
        vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT(boot_rec);       
40013be4:	91 32 20 10 	srl  %o0, 0x10, %o0                            
40013be8:	d0 26 20 1c 	st  %o0, [ %i0 + 0x1c ]                        
    else                                                              
        vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);     
                                                                      
    vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length +     
40013bec:	92 0f 60 ff 	and  %i5, 0xff, %o1                            
40013bf0:	7f ff ba 67 	call  4000258c <.umul>                         
40013bf4:	a9 2d 20 10 	sll  %l4, 0x10, %l4                            
40013bf8:	a9 35 20 10 	srl  %l4, 0x10, %l4                            
40013bfc:	90 02 00 14 	add  %o0, %l4, %o0                             
40013c00:	b4 02 00 1a 	add  %o0, %i2, %i2                             
                     vol->rdir_secs;                                  
                                                                      
    /* for  FAT12/16 root dir starts at(sector) */                    
    vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;       
40013c04:	d0 26 20 20 	st  %o0, [ %i0 + 0x20 ]                        
                                                                      
    if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0)             
40013c08:	90 0c 60 ff 	and  %l1, 0xff, %o0                            
40013c0c:	a0 0c 20 ff 	and  %l0, 0xff, %l0                            
40013c10:	91 2a 20 08 	sll  %o0, 8, %o0                               
40013c14:	90 12 00 10 	or  %o0, %l0, %o0                              
40013c18:	91 2a 20 10 	sll  %o0, 0x10, %o0                            
40013c1c:	80 a2 20 00 	cmp  %o0, 0                                    
40013c20:	02 80 00 e3 	be  40013fac <fat_init_volume_info+0x69c>      
40013c24:	f4 26 20 34 	st  %i2, [ %i0 + 0x34 ]                        
        vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec);     
40013c28:	91 32 20 10 	srl  %o0, 0x10, %o0                            
40013c2c:	d0 26 20 30 	st  %o0, [ %i0 + 0x30 ]                        
    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;                             
40013c30:	90 22 00 1a 	sub  %o0, %i2, %o0                             
40013c34:	7f ff ba 90 	call  40002674 <.udiv>                         
40013c38:	92 10 00 1c 	mov  %i4, %o1                                  
                                                                      
    /* determine FAT type at least */                                 
    if ( vol->data_cls < FAT_FAT12_MAX_CLN)                           
40013c3c:	80 a2 2f f4 	cmp  %o0, 0xff4                                
40013c40:	18 80 00 7d 	bgu  40013e34 <fat_init_volume_info+0x524>     
40013c44:	d0 26 20 38 	st  %o0, [ %i0 + 0x38 ]                        
    {                                                                 
        vol->type = FAT_FAT12;                                        
40013c48:	84 10 20 01 	mov  1, %g2                                    
40013c4c:	c4 2e 20 0e 	stb  %g2, [ %i0 + 0xe ]                        
        vol->mask = FAT_FAT12_MASK;                                   
40013c50:	84 10 2f ff 	mov  0xfff, %g2                                
40013c54:	c4 26 20 10 	st  %g2, [ %i0 + 0x10 ]                        
        vol->eoc_val = FAT_FAT12_EOC;                                 
40013c58:	84 10 2f f8 	mov  0xff8, %g2                                
40013c5c:	c4 26 20 14 	st  %g2, [ %i0 + 0x14 ]                        
    else                                                              
    {                                                                 
        vol->rdir_cl = 0;                                             
        vol->mirror = 0;                                              
        vol->afat = 0;                                                
        vol->free_cls = FAT_UNDEFINED_VALUE;                          
40013c60:	84 10 3f ff 	mov  -1, %g2                                   
            }                                                         
        }                                                             
    }                                                                 
    else                                                              
    {                                                                 
        vol->rdir_cl = 0;                                             
40013c64:	c0 26 20 3c 	clr  [ %i0 + 0x3c ]                            
        vol->mirror = 0;                                              
40013c68:	c0 2e 20 54 	clrb  [ %i0 + 0x54 ]                           
        vol->afat = 0;                                                
40013c6c:	c0 2e 20 5c 	clrb  [ %i0 + 0x5c ]                           
        vol->free_cls = FAT_UNDEFINED_VALUE;                          
40013c70:	c4 26 20 44 	st  %g2, [ %i0 + 0x44 ]                        
        vol->next_cl = FAT_UNDEFINED_VALUE;                           
40013c74:	c4 26 20 4c 	st  %g2, [ %i0 + 0x4c ]                        
 *     0 on success, or -1 if error occured and errno set appropriately
 */                                                                   
int                                                                   
_fat_block_release(fat_fs_info_t *fs_info)                            
{                                                                     
    return fat_buf_release(fs_info);                                  
40013c78:	7f ff fd 73 	call  40013244 <fat_buf_release>               
40013c7c:	90 10 00 18 	mov  %i0, %o0                                  
        vol->next_cl = FAT_UNDEFINED_VALUE;                           
    }                                                                 
                                                                      
    _fat_block_release(fs_info);                                      
                                                                      
    vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;       
40013c80:	d2 06 20 1c 	ld  [ %i0 + 0x1c ], %o1                        
40013c84:	7f ff ba 42 	call  4000258c <.umul>                         
40013c88:	d0 0e 20 5c 	ldub  [ %i0 + 0x5c ], %o0                      
40013c8c:	c4 16 20 18 	lduh  [ %i0 + 0x18 ], %g2                      
                                                                      
    /* set up collection of fat-files fd */                           
    fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
40013c90:	92 10 20 0c 	mov  0xc, %o1                                  
        vol->next_cl = FAT_UNDEFINED_VALUE;                           
    }                                                                 
                                                                      
    _fat_block_release(fs_info);                                      
                                                                      
    vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;       
40013c94:	84 02 00 02 	add  %o0, %g2, %g2                             
                                                                      
    /* set up collection of fat-files fd */                           
    fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
40013c98:	90 10 20 02 	mov  2, %o0                                    
40013c9c:	7f ff c3 8d 	call  40004ad0 <calloc>                        
40013ca0:	c4 26 20 58 	st  %g2, [ %i0 + 0x58 ]                        
    if ( fs_info->vhash == NULL )                                     
40013ca4:	80 a2 20 00 	cmp  %o0, 0                                    
40013ca8:	02 80 01 03 	be  400140b4 <fat_init_volume_info+0x7a4>      <== NEVER TAKEN
40013cac:	d0 26 20 6c 	st  %o0, [ %i0 + 0x6c ]                        
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
40013cb0:	88 02 20 04 	add  %o0, 4, %g4                               
40013cb4:	84 02 20 0c 	add  %o0, 0xc, %g2                             
40013cb8:	86 02 20 10 	add  %o0, 0x10, %g3                            
                                                                      
  head->next = tail;                                                  
40013cbc:	c8 22 00 00 	st  %g4, [ %o0 ]                               
  head->previous = NULL;                                              
40013cc0:	c0 22 20 04 	clr  [ %o0 + 4 ]                               
  tail->previous = head;                                              
40013cc4:	d0 22 20 08 	st  %o0, [ %o0 + 8 ]                           
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
40013cc8:	c6 22 20 0c 	st  %g3, [ %o0 + 0xc ]                         
  head->previous = NULL;                                              
40013ccc:	c0 22 20 10 	clr  [ %o0 + 0x10 ]                            
  tail->previous = head;                                              
40013cd0:	c4 22 20 14 	st  %g2, [ %o0 + 0x14 ]                        
    }                                                                 
                                                                      
    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));
40013cd4:	92 10 20 0c 	mov  0xc, %o1                                  
40013cd8:	7f ff c3 7e 	call  40004ad0 <calloc>                        
40013cdc:	90 10 20 02 	mov  2, %o0                                    
    if ( fs_info->rhash == NULL )                                     
40013ce0:	80 a2 20 00 	cmp  %o0, 0                                    
40013ce4:	02 80 01 0c 	be  40014114 <fat_init_volume_info+0x804>      <== NEVER TAKEN
40013ce8:	d0 26 20 70 	st  %o0, [ %i0 + 0x70 ]                        
    }                                                                 
    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;                
    fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;        
40013cec:	c4 0e 20 03 	ldub  [ %i0 + 3 ], %g2                         
40013cf0:	f8 06 20 30 	ld  [ %i0 + 0x30 ], %i4                        
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
40013cf4:	86 02 20 0c 	add  %o0, 0xc, %g3                             
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
40013cf8:	c0 22 20 04 	clr  [ %o0 + 4 ]                               
  tail->previous = head;                                              
40013cfc:	d0 22 20 08 	st  %o0, [ %o0 + 8 ]                           
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
40013d00:	c0 22 20 10 	clr  [ %o0 + 0x10 ]                            
  tail->previous = head;                                              
40013d04:	c6 22 20 14 	st  %g3, [ %o0 + 0x14 ]                        
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
40013d08:	88 02 20 10 	add  %o0, 0x10, %g4                            
40013d0c:	ba 02 20 04 	add  %o0, 4, %i5                               
                                                                      
  head->next = tail;                                                  
40013d10:	c8 22 20 0c 	st  %g4, [ %o0 + 0xc ]                         
40013d14:	fa 22 00 00 	st  %i5, [ %o0 ]                               
40013d18:	85 2f 00 02 	sll  %i4, %g2, %g2                             
40013d1c:	85 28 a0 04 	sll  %g2, 4, %g2                               
40013d20:	c4 26 20 80 	st  %g2, [ %i0 + 0x80 ]                        
        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;                
40013d24:	84 10 21 00 	mov  0x100, %g2                                
    fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;        
    fs_info->index = 0;                                               
40013d28:	c0 26 20 78 	clr  [ %i0 + 0x78 ]                            
        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;                
40013d2c:	c4 26 20 7c 	st  %g2, [ %i0 + 0x7c ]                        
    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));
40013d30:	90 10 21 00 	mov  0x100, %o0                                
40013d34:	7f ff c3 67 	call  40004ad0 <calloc>                        
40013d38:	92 10 20 01 	mov  1, %o1                                    
    if ( fs_info->uino == NULL )                                      
40013d3c:	80 a2 20 00 	cmp  %o0, 0                                    
40013d40:	02 80 00 d0 	be  40014080 <fat_init_volume_info+0x770>      <== NEVER TAKEN
40013d44:	d0 26 20 74 	st  %o0, [ %i0 + 0x74 ]                        
        close(vol->fd);                                               
        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));  
40013d48:	d0 16 00 00 	lduh  [ %i0 ], %o0                             
40013d4c:	7f ff c3 61 	call  40004ad0 <calloc>                        
40013d50:	92 10 20 01 	mov  1, %o1                                    
    if (fs_info->sec_buf == NULL)                                     
40013d54:	80 a2 20 00 	cmp  %o0, 0                                    
40013d58:	02 80 00 e7 	be  400140f4 <fat_init_volume_info+0x7e4>      <== NEVER TAKEN
40013d5c:	d0 26 20 90 	st  %o0, [ %i0 + 0x90 ]                        
      return bytes_written;                                           
}                                                                     
                                                                      
static bool is_cluster_aligned(const fat_vol_t *vol, uint32_t sec_num)
{                                                                     
    return (sec_num & (vol->spc - 1)) == 0;                           
40013d60:	c4 0e 20 04 	ldub  [ %i0 + 4 ], %g2                         
40013d64:	c6 06 20 34 	ld  [ %i0 + 0x34 ], %g3                        
40013d68:	84 00 bf ff 	add  %g2, -1, %g2                              
    /*                                                                
     * If possible we will use the cluster size as bdbuf block size for faster
     * file access. This requires that certain sectors are aligned to cluster
     * borders.                                                       
     */                                                               
    if (is_cluster_aligned(vol, vol->data_fsec)                       
40013d6c:	80 88 80 03 	btst  %g2, %g3                                 
40013d70:	12 80 00 17 	bne  40013dcc <fat_init_volume_info+0x4bc>     <== NEVER TAKEN
40013d74:	01 00 00 00 	nop                                            
        && (FAT_FAT32 == vol->type || is_cluster_aligned(vol, vol->rdir_loc)))
40013d78:	c6 0e 20 0e 	ldub  [ %i0 + 0xe ], %g3                       
40013d7c:	80 a0 e0 04 	cmp  %g3, 4                                    
40013d80:	22 80 00 07 	be,a   40013d9c <fat_init_volume_info+0x48c>   
40013d84:	d0 06 20 64 	ld  [ %i0 + 0x64 ], %o0                        
      return bytes_written;                                           
}                                                                     
                                                                      
static bool is_cluster_aligned(const fat_vol_t *vol, uint32_t sec_num)
{                                                                     
    return (sec_num & (vol->spc - 1)) == 0;                           
40013d88:	c6 06 20 20 	ld  [ %i0 + 0x20 ], %g3                        
     * If possible we will use the cluster size as bdbuf block size for faster
     * file access. This requires that certain sectors are aligned to cluster
     * borders.                                                       
     */                                                               
    if (is_cluster_aligned(vol, vol->data_fsec)                       
        && (FAT_FAT32 == vol->type || is_cluster_aligned(vol, vol->rdir_loc)))
40013d8c:	80 88 80 03 	btst  %g2, %g3                                 
40013d90:	12 80 00 0f 	bne  40013dcc <fat_init_volume_info+0x4bc>     <== NEVER TAKEN
40013d94:	01 00 00 00 	nop                                            
    {                                                                 
        sc = rtems_bdbuf_set_block_size (vol->dd, vol->bpc, true);    
40013d98:	d0 06 20 64 	ld  [ %i0 + 0x64 ], %o0                        
40013d9c:	d2 16 20 06 	lduh  [ %i0 + 6 ], %o1                         
40013da0:	7f ff f6 83 	call  400117ac <rtems_bdbuf_set_block_size>    
40013da4:	94 10 20 01 	mov  1, %o2                                    
        if (sc == RTEMS_SUCCESSFUL)                                   
40013da8:	80 a2 20 00 	cmp  %o0, 0                                    
40013dac:	12 80 00 08 	bne  40013dcc <fat_init_volume_info+0x4bc>     <== NEVER TAKEN
40013db0:	01 00 00 00 	nop                                            
        {                                                             
            vol->bytes_per_block = vol->bpc;                          
40013db4:	c8 16 20 06 	lduh  [ %i0 + 6 ], %g4                         
            vol->bytes_per_block_log2 = vol->bpc_log2;                
40013db8:	c6 0e 20 08 	ldub  [ %i0 + 8 ], %g3                         
            vol->sectors_per_block = vol->spc;                        
40013dbc:	c4 0e 20 04 	ldub  [ %i0 + 4 ], %g2                         
        && (FAT_FAT32 == vol->type || is_cluster_aligned(vol, vol->rdir_loc)))
    {                                                                 
        sc = rtems_bdbuf_set_block_size (vol->dd, vol->bpc, true);    
        if (sc == RTEMS_SUCCESSFUL)                                   
        {                                                             
            vol->bytes_per_block = vol->bpc;                          
40013dc0:	c8 36 20 0a 	sth  %g4, [ %i0 + 0xa ]                        
            vol->bytes_per_block_log2 = vol->bpc_log2;                
40013dc4:	c6 2e 20 0c 	stb  %g3, [ %i0 + 0xc ]                        
            vol->sectors_per_block = vol->spc;                        
40013dc8:	c4 2e 20 09 	stb  %g2, [ %i0 + 9 ]                          
        }                                                             
    }                                                                 
                                                                      
    return RC_OK;                                                     
40013dcc:	81 c7 e0 08 	ret                                            
40013dd0:	91 e8 20 00 	restore  %g0, 0, %o0                           
    }                                                                 
                                                                      
    /* Evaluate boot record */                                        
    vol->bps = FAT_GET_BR_BYTES_PER_SECTOR(boot_rec);                 
                                                                      
    if ( (vol->bps != 512)  &&                                        
40013dd4:	80 a0 a2 00 	cmp  %g2, 0x200                                
40013dd8:	22 bf ff 26 	be,a   40013a70 <fat_init_volume_info+0x160>   <== ALWAYS TAKEN
40013ddc:	85 32 60 19 	srl  %o1, 0x19, %g2                            
         (vol->bps != 1024) &&                                        
40013de0:	80 a0 a8 00 	cmp  %g2, 0x800                                <== NOT EXECUTED
40013de4:	22 bf ff 26 	be,a   40013a7c <fat_init_volume_info+0x16c>   <== NOT EXECUTED
40013de8:	85 32 60 19 	srl  %o1, 0x19, %g2                            <== NOT EXECUTED
         (vol->bps != 2048) &&                                        
40013dec:	09 00 00 04 	sethi  %hi(0x1000), %g4                        <== NOT EXECUTED
40013df0:	80 a0 80 04 	cmp  %g2, %g4                                  <== NOT EXECUTED
40013df4:	12 80 00 82 	bne  40013ffc <fat_init_volume_info+0x6ec>     <== NOT EXECUTED
40013df8:	85 32 60 19 	srl  %o1, 0x19, %g2                            <== NOT EXECUTED
40013dfc:	10 bf ff 23 	b  40013a88 <fat_init_volume_info+0x178>       <== NOT EXECUTED
40013e00:	88 10 20 01 	mov  1, %g4                                    <== NOT EXECUTED
    vol->rdir_size = vol->rdir_secs << vol->sec_log2;                 
                                                                      
    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);     
40013e04:	c4 0f bf 96 	ldub  [ %fp + -106 ], %g2                      
40013e08:	d0 0f bf 97 	ldub  [ %fp + -105 ], %o0                      
40013e0c:	c2 0f bf 9f 	ldub  [ %fp + -97 ], %g1                       
40013e10:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
40013e14:	91 2a 20 08 	sll  %o0, 8, %o0                               
40013e18:	ae 0d e0 ff 	and  %l7, 0xff, %l7                            
40013e1c:	90 12 00 02 	or  %o0, %g2, %o0                              
40013e20:	85 28 60 18 	sll  %g1, 0x18, %g2                            
40013e24:	90 12 00 17 	or  %o0, %l7, %o0                              
40013e28:	90 12 00 02 	or  %o0, %g2, %o0                              
40013e2c:	10 bf ff 70 	b  40013bec <fat_init_volume_info+0x2dc>       
40013e30:	d0 26 20 1c 	st  %o0, [ %i0 + 0x1c ]                        
        vol->mask = FAT_FAT12_MASK;                                   
        vol->eoc_val = FAT_FAT12_EOC;                                 
    }                                                                 
    else                                                              
    {                                                                 
        if ( vol->data_cls < FAT_FAT16_MAX_CLN)                       
40013e34:	05 00 00 3f 	sethi  %hi(0xfc00), %g2                        
40013e38:	86 10 a3 f4 	or  %g2, 0x3f4, %g3	! fff4 <PROM_START+0xfff4> 
40013e3c:	80 a2 00 03 	cmp  %o0, %g3                                  
40013e40:	08 80 00 67 	bleu  40013fdc <fat_init_volume_info+0x6cc>    
40013e44:	86 10 a3 ff 	or  %g2, 0x3ff, %g3                            
                                                                      
    if (vol->type == FAT_FAT32)                                       
    {                                                                 
        vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);       
                                                                      
        vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
40013e48:	c2 0f bf 87 	ldub  [ %fp + -121 ], %g1                      
        }                                                             
    }                                                                 
                                                                      
    if (vol->type == FAT_FAT32)                                       
    {                                                                 
        vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);       
40013e4c:	f8 0f bf 7f 	ldub  [ %fp + -129 ], %i4                      
                                                                      
        vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
40013e50:	84 08 7f 80 	and  %g1, -128, %g2                            
        }                                                             
    }                                                                 
                                                                      
    if (vol->type == FAT_FAT32)                                       
    {                                                                 
        vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);       
40013e54:	f6 0f bf 90 	ldub  [ %fp + -112 ], %i3                      
40013e58:	c8 0f bf 7e 	ldub  [ %fp + -130 ], %g4                      
40013e5c:	c2 0f bf 77 	ldub  [ %fp + -137 ], %g1                      
40013e60:	b9 2f 20 08 	sll  %i4, 8, %i4                               
            vol->eoc_val = FAT_FAT16_EOC;                             
        }                                                             
        else                                                          
        {                                                             
            vol->type = FAT_FAT32;                                    
            vol->mask = FAT_FAT32_MASK;                               
40013e64:	07 03 ff ff 	sethi  %hi(0xffffc00), %g3                     
        }                                                             
    }                                                                 
                                                                      
    if (vol->type == FAT_FAT32)                                       
    {                                                                 
        vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);       
40013e68:	89 29 20 10 	sll  %g4, 0x10, %g4                            
            vol->eoc_val = FAT_FAT16_EOC;                             
        }                                                             
        else                                                          
        {                                                             
            vol->type = FAT_FAT32;                                    
            vol->mask = FAT_FAT32_MASK;                               
40013e6c:	ba 10 e3 ff 	or  %g3, 0x3ff, %i5                            
        }                                                             
    }                                                                 
                                                                      
    if (vol->type == FAT_FAT32)                                       
    {                                                                 
        vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);       
40013e70:	88 17 00 04 	or  %i4, %g4, %g4                              
        }                                                             
        else                                                          
        {                                                             
            vol->type = FAT_FAT32;                                    
            vol->mask = FAT_FAT32_MASK;                               
            vol->eoc_val = FAT_FAT32_EOC;                             
40013e74:	86 10 e3 f8 	or  %g3, 0x3f8, %g3                            
        }                                                             
    }                                                                 
                                                                      
    if (vol->type == FAT_FAT32)                                       
    {                                                                 
        vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);       
40013e78:	88 11 00 1b 	or  %g4, %i3, %g4                              
40013e7c:	b9 28 60 18 	sll  %g1, 0x18, %i4                            
            vol->mask = FAT_FAT16_MASK;                               
            vol->eoc_val = FAT_FAT16_EOC;                             
        }                                                             
        else                                                          
        {                                                             
            vol->type = FAT_FAT32;                                    
40013e80:	b6 10 20 04 	mov  4, %i3                                    
        }                                                             
    }                                                                 
                                                                      
    if (vol->type == FAT_FAT32)                                       
    {                                                                 
        vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);       
40013e84:	88 11 00 1c 	or  %g4, %i4, %g4                              
            vol->mask = FAT_FAT16_MASK;                               
            vol->eoc_val = FAT_FAT16_EOC;                             
        }                                                             
        else                                                          
        {                                                             
            vol->type = FAT_FAT32;                                    
40013e88:	f6 2e 20 0e 	stb  %i3, [ %i0 + 0xe ]                        
            vol->mask = FAT_FAT32_MASK;                               
40013e8c:	fa 26 20 10 	st  %i5, [ %i0 + 0x10 ]                        
            vol->eoc_val = FAT_FAT32_EOC;                             
40013e90:	c6 26 20 14 	st  %g3, [ %i0 + 0x14 ]                        
        }                                                             
    }                                                                 
                                                                      
    if (vol->type == FAT_FAT32)                                       
    {                                                                 
        vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);       
40013e94:	c8 26 20 3c 	st  %g4, [ %i0 + 0x3c ]                        
                                                                      
        vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
        if (vol->mirror)                                              
40013e98:	80 88 a0 80 	btst  0x80, %g2                                
40013e9c:	02 80 00 6a 	be  40014044 <fat_init_volume_info+0x734>      <== ALWAYS TAKEN
40013ea0:	c4 2e 20 54 	stb  %g2, [ %i0 + 0x54 ]                       
            vol->afat = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_FAT_NUM;
40013ea4:	c2 0f bf 87 	ldub  [ %fp + -121 ], %g1                      <== NOT EXECUTED
40013ea8:	84 08 60 0f 	and  %g1, 0xf, %g2                             <== NOT EXECUTED
40013eac:	c4 2e 20 5c 	stb  %g2, [ %i0 + 0x5c ]                       <== NOT EXECUTED
        else                                                          
            vol->afat = 0;                                            
                                                                      
        vol->info_sec = FAT_GET_BR_FAT32_FS_INFO_SECTOR(boot_rec);    
40013eb0:	c4 0f bf 91 	ldub  [ %fp + -111 ], %g2                      
40013eb4:	c6 0f bf 92 	ldub  [ %fp + -110 ], %g3                      
40013eb8:	85 28 a0 08 	sll  %g2, 8, %g2                               
40013ebc:	84 10 80 03 	or  %g2, %g3, %g2                              
40013ec0:	c4 36 20 40 	sth  %g2, [ %i0 + 0x40 ]                       
        if( vol->info_sec == 0 )                                      
40013ec4:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
40013ec8:	93 30 a0 10 	srl  %g2, 0x10, %o1                            
40013ecc:	80 a2 60 00 	cmp  %o1, 0                                    
40013ed0:	02 80 00 4b 	be  40013ffc <fat_init_volume_info+0x6ec>      <== NEVER TAKEN
40013ed4:	90 10 00 18 	mov  %i0, %o0                                  
            close(vol->fd);                                           
            rtems_set_errno_and_return_minus_one( EINVAL );           
        }                                                             
        else                                                          
        {                                                             
            ret = _fat_block_read(fs_info, vol->info_sec , 0,         
40013ed8:	94 10 20 00 	clr  %o2                                       
40013edc:	96 10 20 04 	mov  4, %o3                                    
40013ee0:	7f ff fd 7e 	call  400134d8 <_fat_block_read>               
40013ee4:	98 07 bf a8 	add  %fp, -88, %o4                             
                                  FAT_FSI_LEADSIG_SIZE, fs_info_sector);
            if ( ret < 0 )                                            
40013ee8:	80 a2 20 00 	cmp  %o0, 0                                    
40013eec:	06 80 00 7d 	bl  400140e0 <fat_init_volume_info+0x7d0>      <== NEVER TAKEN
40013ef0:	c4 0f bf ab 	ldub  [ %fp + -85 ], %g2                       
            {                                                         
                close(vol->fd);                                       
                return -1;                                            
            }                                                         
                                                                      
            if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=      
40013ef4:	c6 0f bf a9 	ldub  [ %fp + -87 ], %g3                       
40013ef8:	fa 0f bf aa 	ldub  [ %fp + -86 ], %i5                       
40013efc:	c8 0f bf a8 	ldub  [ %fp + -88 ], %g4                       
40013f00:	85 28 a0 18 	sll  %g2, 0x18, %g2                            
40013f04:	87 28 e0 08 	sll  %g3, 8, %g3                               
40013f08:	bb 2f 60 10 	sll  %i5, 0x10, %i5                            
40013f0c:	86 10 c0 1d 	or  %g3, %i5, %g3                              
40013f10:	86 10 c0 04 	or  %g3, %g4, %g3                              
40013f14:	86 10 c0 02 	or  %g3, %g2, %g3                              
40013f18:	05 10 58 54 	sethi  %hi(0x41615000), %g2                    
40013f1c:	84 10 a2 52 	or  %g2, 0x252, %g2	! 41615252 <RAM_END+0x1215252>
40013f20:	80 a0 c0 02 	cmp  %g3, %g2                                  
40013f24:	12 80 00 34 	bne  40013ff4 <fat_init_volume_info+0x6e4>     <== NEVER TAKEN
40013f28:	90 10 00 18 	mov  %i0, %o0                                  
                close(vol->fd);                                       
                rtems_set_errno_and_return_minus_one( EINVAL );       
            }                                                         
            else                                                      
            {                                                         
                ret = _fat_block_read(fs_info, vol->info_sec , FAT_FSI_INFO,
40013f2c:	d2 16 20 40 	lduh  [ %i0 + 0x40 ], %o1                      
40013f30:	94 10 21 e4 	mov  0x1e4, %o2                                
40013f34:	96 10 20 0c 	mov  0xc, %o3                                  
40013f38:	7f ff fd 68 	call  400134d8 <_fat_block_read>               
40013f3c:	98 07 bf a8 	add  %fp, -88, %o4                             
                                      FAT_USEFUL_INFO_SIZE, fs_info_sector);
                if ( ret < 0 )                                        
40013f40:	80 a2 20 00 	cmp  %o0, 0                                    
40013f44:	06 80 00 65 	bl  400140d8 <fat_init_volume_info+0x7c8>      <== NEVER TAKEN
40013f48:	c6 0f bf ad 	ldub  [ %fp + -83 ], %g3                       
                    close(vol->fd);                                   
                    return -1;                                        
                }                                                     
                                                                      
                vol->free_cls_in_fs_info =                            
                  FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);  
40013f4c:	f2 0f bf ae 	ldub  [ %fp + -82 ], %i1                       
40013f50:	f4 0f bf ac 	ldub  [ %fp + -84 ], %i2                       
40013f54:	f6 0f bf af 	ldub  [ %fp + -81 ], %i3                       
                vol->free_cls = vol->free_cls_in_fs_info;             
                vol->next_cl_in_fs_info =                             
                  FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);   
40013f58:	f8 0f bf b1 	ldub  [ %fp + -79 ], %i4                       
40013f5c:	c4 0f bf b2 	ldub  [ %fp + -78 ], %g2                       
40013f60:	fa 0f bf b0 	ldub  [ %fp + -80 ], %i5                       
40013f64:	c8 0f bf b3 	ldub  [ %fp + -77 ], %g4                       
                    close(vol->fd);                                   
                    return -1;                                        
                }                                                     
                                                                      
                vol->free_cls_in_fs_info =                            
                  FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);  
40013f68:	87 28 e0 08 	sll  %g3, 8, %g3                               
40013f6c:	b3 2e 60 10 	sll  %i1, 0x10, %i1                            
40013f70:	b7 2e e0 18 	sll  %i3, 0x18, %i3                            
40013f74:	86 10 c0 19 	or  %g3, %i1, %g3                              
                vol->free_cls = vol->free_cls_in_fs_info;             
                vol->next_cl_in_fs_info =                             
                  FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);   
40013f78:	b9 2f 20 08 	sll  %i4, 8, %i4                               
                    close(vol->fd);                                   
                    return -1;                                        
                }                                                     
                                                                      
                vol->free_cls_in_fs_info =                            
                  FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);  
40013f7c:	86 10 c0 1a 	or  %g3, %i2, %g3                              
                vol->free_cls = vol->free_cls_in_fs_info;             
                vol->next_cl_in_fs_info =                             
                  FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);   
40013f80:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
                    close(vol->fd);                                   
                    return -1;                                        
                }                                                     
                                                                      
                vol->free_cls_in_fs_info =                            
                  FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);  
40013f84:	86 10 c0 1b 	or  %g3, %i3, %g3                              
                vol->free_cls = vol->free_cls_in_fs_info;             
                vol->next_cl_in_fs_info =                             
                  FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);   
40013f88:	84 17 00 02 	or  %i4, %g2, %g2                              
40013f8c:	89 29 20 18 	sll  %g4, 0x18, %g4                            
40013f90:	84 10 80 1d 	or  %g2, %i5, %g2                              
                    _fat_block_release(fs_info);                      
                    close(vol->fd);                                   
                    return -1;                                        
                }                                                     
                                                                      
                vol->free_cls_in_fs_info =                            
40013f94:	c6 26 20 48 	st  %g3, [ %i0 + 0x48 ]                        
                  FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);  
                vol->free_cls = vol->free_cls_in_fs_info;             
                vol->next_cl_in_fs_info =                             
                  FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);   
40013f98:	84 10 80 04 	or  %g2, %g4, %g2                              
                    return -1;                                        
                }                                                     
                                                                      
                vol->free_cls_in_fs_info =                            
                  FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);  
                vol->free_cls = vol->free_cls_in_fs_info;             
40013f9c:	c6 26 20 44 	st  %g3, [ %i0 + 0x44 ]                        
                vol->next_cl_in_fs_info =                             
40013fa0:	c4 26 20 50 	st  %g2, [ %i0 + 0x50 ]                        
                  FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);   
                vol->next_cl = vol->next_cl_in_fs_info;               
40013fa4:	10 bf ff 35 	b  40013c78 <fat_init_volume_info+0x368>       
40013fa8:	c4 26 20 4c 	st  %g2, [ %i0 + 0x4c ]                        
    vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;       
                                                                      
    if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0)             
        vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec);     
    else                                                              
        vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM32(boot_rec);     
40013fac:	c4 0f bf 94 	ldub  [ %fp + -108 ], %g2                      
40013fb0:	d0 0f bf 95 	ldub  [ %fp + -107 ], %o0                      
40013fb4:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
40013fb8:	91 2a 20 08 	sll  %o0, 8, %o0                               
40013fbc:	c2 0f bf 93 	ldub  [ %fp + -109 ], %g1                      
40013fc0:	90 12 00 02 	or  %o0, %g2, %o0                              
40013fc4:	c4 0f bf 8f 	ldub  [ %fp + -113 ], %g2                      
40013fc8:	90 12 00 01 	or  %o0, %g1, %o0                              
40013fcc:	ad 28 a0 18 	sll  %g2, 0x18, %l6                            
40013fd0:	90 12 00 16 	or  %o0, %l6, %o0                              
40013fd4:	10 bf ff 17 	b  40013c30 <fat_init_volume_info+0x320>       
40013fd8:	d0 26 20 30 	st  %o0, [ %i0 + 0x30 ]                        
    }                                                                 
    else                                                              
    {                                                                 
        if ( vol->data_cls < FAT_FAT16_MAX_CLN)                       
        {                                                             
            vol->type = FAT_FAT16;                                    
40013fdc:	88 10 20 02 	mov  2, %g4                                    
            vol->mask = FAT_FAT16_MASK;                               
            vol->eoc_val = FAT_FAT16_EOC;                             
40013fe0:	84 10 a3 f8 	or  %g2, 0x3f8, %g2                            
    }                                                                 
    else                                                              
    {                                                                 
        if ( vol->data_cls < FAT_FAT16_MAX_CLN)                       
        {                                                             
            vol->type = FAT_FAT16;                                    
40013fe4:	c8 2e 20 0e 	stb  %g4, [ %i0 + 0xe ]                        
            vol->mask = FAT_FAT16_MASK;                               
40013fe8:	c6 26 20 10 	st  %g3, [ %i0 + 0x10 ]                        
            vol->eoc_val = FAT_FAT16_EOC;                             
40013fec:	10 bf ff 1d 	b  40013c60 <fat_init_volume_info+0x350>       
40013ff0:	c4 26 20 14 	st  %g2, [ %i0 + 0x14 ]                        
 *     0 on success, or -1 if error occured and errno set appropriately
 */                                                                   
int                                                                   
_fat_block_release(fat_fs_info_t *fs_info)                            
{                                                                     
    return fat_buf_release(fs_info);                                  
40013ff4:	7f ff fc 94 	call  40013244 <fat_buf_release>               <== NOT EXECUTED
40013ff8:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
                                                                      
            if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=      
                FAT_FSINFO_LEAD_SIGNATURE_VALUE)                      
            {                                                         
                _fat_block_release(fs_info);                          
                close(vol->fd);                                       
40013ffc:	d0 06 20 60 	ld  [ %i0 + 0x60 ], %o0                        <== NOT EXECUTED
40014000:	7f ff c2 c9 	call  40004b24 <close>                         <== NOT EXECUTED
40014004:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
                rtems_set_errno_and_return_minus_one( EINVAL );       
40014008:	40 00 20 e2 	call  4001c390 <__errno>                       <== NOT EXECUTED
4001400c:	01 00 00 00 	nop                                            <== NOT EXECUTED
40014010:	82 10 20 16 	mov  0x16, %g1	! 16 <PROM_START+0x16>          <== NOT EXECUTED
40014014:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
40014018:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001401c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    }                                                                 
                                                                      
    rc = fstat(vol->fd, &stat_buf);                                   
    if (rc != 0)                                                      
    {                                                                 
        close(vol->fd);                                               
40014020:	d0 06 20 60 	ld  [ %i0 + 0x60 ], %o0                        <== NOT EXECUTED
40014024:	7f ff c2 c0 	call  40004b24 <close>                         <== NOT EXECUTED
40014028:	01 00 00 00 	nop                                            <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(ENXIO);                  
4001402c:	40 00 20 d9 	call  4001c390 <__errno>                       <== NOT EXECUTED
40014030:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <LEON_REG+0x7fffffff>  <== NOT EXECUTED
40014034:	82 10 20 06 	mov  6, %g1                                    <== NOT EXECUTED
40014038:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4001403c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40014040:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
        vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
        if (vol->mirror)                                              
            vol->afat = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_FAT_NUM;
        else                                                          
            vol->afat = 0;                                            
40014044:	10 bf ff 9b 	b  40013eb0 <fat_init_volume_info+0x5a0>       
40014048:	c0 2e 20 5c 	clrb  [ %i0 + 0x5c ]                           
    for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;               
         i >>= 1, vol->sec_log2++);                                   
                                                                      
    vol->bytes_per_block = vol->bps;                                  
    vol->bytes_per_block_log2 = vol->sec_log2;                        
    vol->sectors_per_block = 1;                                       
4001404c:	10 bf fe a3 	b  40013ad8 <fat_init_volume_info+0x1c8>       <== NOT EXECUTED
40014050:	84 10 20 01 	mov  1, %g2                                    <== NOT EXECUTED
    {                                                                 
        close(vol->fd);                                               
        rtems_set_errno_and_return_minus_one(EINVAL);                 
    }                                                                 
                                                                      
    for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;               
40014054:	10 bf fe b4 	b  40013b24 <fat_init_volume_info+0x214>       
40014058:	86 10 20 00 	clr  %g3                                       
    memcpy( boot_rec, block->buffer, FAT_MAX_BPB_SIZE);               
                                                                      
    sc = rtems_bdbuf_release( block);                                 
    if (sc != RTEMS_SUCCESSFUL)                                       
    {                                                                 
        close(vol->fd);                                               
4001405c:	d0 06 20 60 	ld  [ %i0 + 0x60 ], %o0                        <== NOT EXECUTED
40014060:	7f ff c2 b1 	call  40004b24 <close>                         <== NOT EXECUTED
40014064:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one( EIO );                  
40014068:	40 00 20 ca 	call  4001c390 <__errno>                       <== NOT EXECUTED
4001406c:	01 00 00 00 	nop                                            <== NOT EXECUTED
40014070:	82 10 20 05 	mov  5, %g1	! 5 <PROM_START+0x5>               <== NOT EXECUTED
40014074:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
40014078:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001407c:	81 e8 00 00 	restore                                        <== 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 )                                      
    {                                                                 
        close(vol->fd);                                               
40014080:	7f ff c2 a9 	call  40004b24 <close>                         <== NOT EXECUTED
40014084:	d0 06 20 60 	ld  [ %i0 + 0x60 ], %o0                        <== NOT EXECUTED
        free(fs_info->vhash);                                         
40014088:	7f ff c2 c9 	call  40004bac <free>                          <== NOT EXECUTED
4001408c:	d0 06 20 6c 	ld  [ %i0 + 0x6c ], %o0                        <== NOT EXECUTED
        free(fs_info->rhash);                                         
40014090:	d0 06 20 70 	ld  [ %i0 + 0x70 ], %o0                        <== NOT EXECUTED
    if (fs_info->sec_buf == NULL)                                     
    {                                                                 
        close(vol->fd);                                               
        free(fs_info->vhash);                                         
        free(fs_info->rhash);                                         
        free(fs_info->uino);                                          
40014094:	7f ff c2 c6 	call  40004bac <free>                          <== NOT EXECUTED
40014098:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one( ENOMEM );               
4001409c:	40 00 20 bd 	call  4001c390 <__errno>                       <== NOT EXECUTED
400140a0:	01 00 00 00 	nop                                            <== NOT EXECUTED
400140a4:	82 10 20 0c 	mov  0xc, %g1	! c <PROM_START+0xc>             <== NOT EXECUTED
400140a8:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
400140ac:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400140b0:	81 e8 00 00 	restore                                        <== 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 )                                     
    {                                                                 
        close(vol->fd);                                               
400140b4:	d0 06 20 60 	ld  [ %i0 + 0x60 ], %o0                        <== NOT EXECUTED
400140b8:	7f ff c2 9b 	call  40004b24 <close>                         <== NOT EXECUTED
400140bc:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one( ENOMEM );               
400140c0:	40 00 20 b4 	call  4001c390 <__errno>                       <== NOT EXECUTED
400140c4:	01 00 00 00 	nop                                            <== NOT EXECUTED
400140c8:	82 10 20 0c 	mov  0xc, %g1	! c <PROM_START+0xc>             <== NOT EXECUTED
400140cc:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
400140d0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400140d4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
 *     0 on success, or -1 if error occured and errno set appropriately
 */                                                                   
int                                                                   
_fat_block_release(fat_fs_info_t *fs_info)                            
{                                                                     
    return fat_buf_release(fs_info);                                  
400140d8:	7f ff fc 5b 	call  40013244 <fat_buf_release>               <== NOT EXECUTED
400140dc:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
                ret = _fat_block_read(fs_info, vol->info_sec , FAT_FSI_INFO,
                                      FAT_USEFUL_INFO_SIZE, fs_info_sector);
                if ( ret < 0 )                                        
                {                                                     
                    _fat_block_release(fs_info);                      
                    close(vol->fd);                                   
400140e0:	d0 06 20 60 	ld  [ %i0 + 0x60 ], %o0                        <== NOT EXECUTED
400140e4:	7f ff c2 90 	call  40004b24 <close>                         <== NOT EXECUTED
400140e8:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
400140ec:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400140f0:	81 e8 00 00 	restore                                        <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one( ENOMEM );               
    }                                                                 
    fs_info->sec_buf = (uint8_t *)calloc(vol->bps, sizeof(uint8_t));  
    if (fs_info->sec_buf == NULL)                                     
    {                                                                 
        close(vol->fd);                                               
400140f4:	7f ff c2 8c 	call  40004b24 <close>                         <== NOT EXECUTED
400140f8:	d0 06 20 60 	ld  [ %i0 + 0x60 ], %o0                        <== NOT EXECUTED
        free(fs_info->vhash);                                         
400140fc:	7f ff c2 ac 	call  40004bac <free>                          <== NOT EXECUTED
40014100:	d0 06 20 6c 	ld  [ %i0 + 0x6c ], %o0                        <== NOT EXECUTED
        free(fs_info->rhash);                                         
40014104:	7f ff c2 aa 	call  40004bac <free>                          <== NOT EXECUTED
40014108:	d0 06 20 70 	ld  [ %i0 + 0x70 ], %o0                        <== NOT EXECUTED
        free(fs_info->uino);                                          
4001410c:	10 bf ff e2 	b  40014094 <fat_init_volume_info+0x784>       <== NOT EXECUTED
40014110:	d0 06 20 74 	ld  [ %i0 + 0x74 ], %o0                        <== 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 )                                     
    {                                                                 
        close(vol->fd);                                               
40014114:	7f ff c2 84 	call  40004b24 <close>                         <== NOT EXECUTED
40014118:	d0 06 20 60 	ld  [ %i0 + 0x60 ], %o0                        <== NOT EXECUTED
        free(fs_info->vhash);                                         
4001411c:	10 bf ff de 	b  40014094 <fat_init_volume_info+0x784>       <== NOT EXECUTED
40014120:	d0 06 20 6c 	ld  [ %i0 + 0x6c ], %o0                        <== NOT EXECUTED
                                                                      

4001a6f4 <fat_scan_fat_for_free_clusters>: uint32_t count, uint32_t *cls_added, uint32_t *last_cl, bool zero_fill ) {
4001a6f4:	9d e3 bf 98 	save  %sp, -104, %sp                           
    int            rc = RC_OK;                                        
    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;          
4001a6f8:	e6 06 20 38 	ld  [ %i0 + 0x38 ], %l3                        
    bool                                  zero_fill                   
    )                                                                 
{                                                                     
    int            rc = RC_OK;                                        
    uint32_t       cl4find = 2;                                       
    uint32_t       next_cln = 0;                                      
4001a6fc:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
    uint32_t       save_cln = 0;                                      
    uint32_t       data_cls_val = fs_info->vol.data_cls + 2;          
    uint32_t       i = 2;                                             
    ssize_t        bytes_written;                                     
                                                                      
    *cls_added = 0;                                                   
4001a700:	c0 26 c0 00 	clr  [ %i3 ]                                   
                                                                      
    if (count == 0)                                                   
4001a704:	80 a6 a0 00 	cmp  %i2, 0                                    
4001a708:	02 80 00 49 	be  4001a82c <fat_scan_fat_for_free_clusters+0x138><== NEVER TAKEN
4001a70c:	a4 10 20 00 	clr  %l2                                       
        return rc;                                                    
                                                                      
    if (fs_info->vol.next_cl != FAT_UNDEFINED_VALUE)                  
4001a710:	e0 06 20 4c 	ld  [ %i0 + 0x4c ], %l0                        
4001a714:	80 a4 3f ff 	cmp  %l0, -1                                   
4001a718:	22 80 00 02 	be,a   4001a720 <fat_scan_fat_for_free_clusters+0x2c>
4001a71c:	a0 10 20 02 	mov  2, %l0                                    
{                                                                     
    int            rc = RC_OK;                                        
    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;          
4001a720:	a6 04 e0 02 	add  %l3, 2, %l3                               
    /*                                                                
     * 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)                                          
4001a724:	80 a4 e0 02 	cmp  %l3, 2                                    
4001a728:	08 80 00 4e 	bleu  4001a860 <fat_scan_fat_for_free_clusters+0x16c><== NEVER TAKEN
4001a72c:	a2 10 20 02 	mov  2, %l1                                    
4001a730:	10 80 00 1a 	b  4001a798 <fat_scan_fat_for_free_clusters+0xa4>
4001a734:	a8 10 20 00 	clr  %l4                                       
             * wouldn't work properly                                 
             */                                                       
            if (*cls_added == 0)                                      
            {                                                         
                *chain = cl4find;                                     
                rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC);
4001a738:	90 10 00 18 	mov  %i0, %o0                                  
4001a73c:	92 10 00 10 	mov  %l0, %o1                                  
4001a740:	7f ff ff 03 	call  4001a34c <fat_set_fat_cluster>           
4001a744:	94 10 3f ff 	mov  -1, %o2                                   
                if ( rc != RC_OK )                                    
4001a748:	80 a2 20 00 	cmp  %o0, 0                                    
4001a74c:	32 80 00 38 	bne,a   4001a82c <fat_scan_fat_for_free_clusters+0x138><== NEVER TAKEN
4001a750:	a4 10 00 08 	mov  %o0, %l2                                  <== NOT EXECUTED
                rc = fat_set_fat_cluster(fs_info, save_cln, cl4find); 
                if ( rc != RC_OK )                                    
                    goto cleanup;                                     
            }                                                         
                                                                      
            if (zero_fill)                                            
4001a754:	80 a7 60 00 	cmp  %i5, 0                                    
4001a758:	32 80 00 37 	bne,a   4001a834 <fat_scan_fat_for_free_clusters+0x140>
4001a75c:	d6 16 20 06 	lduh  [ %i0 + 6 ], %o3                         
                    goto cleanup;                                     
                }                                                     
            }                                                         
                                                                      
            save_cln = cl4find;                                       
            (*cls_added)++;                                           
4001a760:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
4001a764:	82 00 60 01 	inc  %g1                                       
                                                                      
            /* have we satisfied request ? */                         
            if (*cls_added == count)                                  
4001a768:	80 a6 80 01 	cmp  %i2, %g1                                  
4001a76c:	02 80 00 53 	be  4001a8b8 <fat_scan_fat_for_free_clusters+0x1c4>
4001a770:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
4001a774:	a8 10 00 10 	mov  %l0, %l4                                  
                fat_buf_release(fs_info);                             
                return rc;                                            
            }                                                         
        }                                                             
        i++;                                                          
        cl4find++;                                                    
4001a778:	a0 04 20 01 	inc  %l0                                       
        if (cl4find >= data_cls_val)                                  
4001a77c:	80 a4 c0 10 	cmp  %l3, %l0                                  
4001a780:	18 80 00 03 	bgu  4001a78c <fat_scan_fat_for_free_clusters+0x98><== ALWAYS TAKEN
4001a784:	a2 04 60 01 	inc  %l1                                       
            cl4find = 2;                                              
4001a788:	a0 10 20 02 	mov  2, %l0                                    <== 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)                                          
4001a78c:	80 a4 c0 11 	cmp  %l3, %l1                                  
4001a790:	22 80 00 36 	be,a   4001a868 <fat_scan_fat_for_free_clusters+0x174><== NEVER TAKEN
4001a794:	c2 06 20 44 	ld  [ %i0 + 0x44 ], %g1                        <== NOT EXECUTED
    {                                                                 
        rc = fat_get_fat_cluster(fs_info, cl4find, &next_cln);        
4001a798:	90 10 00 18 	mov  %i0, %o0                                  
4001a79c:	92 10 00 10 	mov  %l0, %o1                                  
4001a7a0:	7f ff fe 67 	call  4001a13c <fat_get_fat_cluster>           
4001a7a4:	94 07 bf fc 	add  %fp, -4, %o2                              
        if ( rc != RC_OK )                                            
4001a7a8:	a4 92 20 00 	orcc  %o0, 0, %l2                              
4001a7ac:	12 80 00 3b 	bne  4001a898 <fat_scan_fat_for_free_clusters+0x1a4><== NEVER TAKEN
4001a7b0:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
            if (*cls_added != 0)                                      
                fat_free_fat_clusters_chain(fs_info, (*chain));       
            return rc;                                                
        }                                                             
                                                                      
        if (next_cln == FAT_GENFAT_FREE)                              
4001a7b4:	80 a0 60 00 	cmp  %g1, 0                                    
4001a7b8:	32 bf ff f1 	bne,a   4001a77c <fat_scan_fat_for_free_clusters+0x88>
4001a7bc:	a0 04 20 01 	inc  %l0                                       
            /*                                                        
             * 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)                                      
4001a7c0:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
4001a7c4:	80 a0 60 00 	cmp  %g1, 0                                    
4001a7c8:	22 bf ff dc 	be,a   4001a738 <fat_scan_fat_for_free_clusters+0x44>
4001a7cc:	e0 26 40 00 	st  %l0, [ %i1 ]                               
                }                                                     
            }                                                         
            else                                                      
            {                                                         
                /* set EOC value to new allocated cluster */          
                rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC);
4001a7d0:	90 10 00 18 	mov  %i0, %o0                                  
4001a7d4:	92 10 00 10 	mov  %l0, %o1                                  
4001a7d8:	7f ff fe dd 	call  4001a34c <fat_set_fat_cluster>           
4001a7dc:	94 10 3f ff 	mov  -1, %o2                                   
                if ( rc != RC_OK )                                    
4001a7e0:	82 92 20 00 	orcc  %o0, 0, %g1                              
4001a7e4:	12 80 00 40 	bne  4001a8e4 <fat_scan_fat_for_free_clusters+0x1f0><== NEVER TAKEN
4001a7e8:	92 10 00 14 	mov  %l4, %o1                                  
                    /* cleanup activity */                            
                    fat_free_fat_clusters_chain(fs_info, (*chain));   
                    return rc;                                        
                }                                                     
                                                                      
                rc = fat_set_fat_cluster(fs_info, save_cln, cl4find); 
4001a7ec:	90 10 00 18 	mov  %i0, %o0                                  
4001a7f0:	7f ff fe d7 	call  4001a34c <fat_set_fat_cluster>           
4001a7f4:	94 10 00 10 	mov  %l0, %o2                                  
                if ( rc != RC_OK )                                    
4001a7f8:	a8 92 20 00 	orcc  %o0, 0, %l4                              
4001a7fc:	02 bf ff d7 	be  4001a758 <fat_scan_fat_for_free_clusters+0x64><== ALWAYS TAKEN
4001a800:	80 a7 60 00 	cmp  %i5, 0                                    
    return RC_OK;                                                     
                                                                      
cleanup:                                                              
                                                                      
    /* cleanup activity */                                            
    fat_free_fat_clusters_chain(fs_info, (*chain));                   
4001a804:	d2 06 40 00 	ld  [ %i1 ], %o1                               <== NOT EXECUTED
4001a808:	7f ff ff 83 	call  4001a614 <fat_free_fat_clusters_chain>   <== NOT EXECUTED
4001a80c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
    /* trying to save last allocated cluster for future use */        
    fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_FREE);           
4001a810:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001a814:	92 10 00 10 	mov  %l0, %o1                                  <== NOT EXECUTED
4001a818:	7f ff fe cd 	call  4001a34c <fat_set_fat_cluster>           <== NOT EXECUTED
4001a81c:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
    fat_buf_release(fs_info);                                         
    return rc;                                                        
4001a820:	a4 10 00 14 	mov  %l4, %l2                                  <== NOT EXECUTED
                                                                      
    /* cleanup activity */                                            
    fat_free_fat_clusters_chain(fs_info, (*chain));                   
    /* trying to save last allocated cluster for future use */        
    fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_FREE);           
    fat_buf_release(fs_info);                                         
4001a824:	7f ff e2 88 	call  40013244 <fat_buf_release>               <== NOT EXECUTED
4001a828:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
    return rc;                                                        
}                                                                     
4001a82c:	81 c7 e0 08 	ret                                            
4001a830:	91 e8 00 12 	restore  %g0, %l2, %o0                         
                    goto cleanup;                                     
            }                                                         
                                                                      
            if (zero_fill)                                            
            {                                                         
                bytes_written = fat_cluster_set (fs_info, cl4find, 0, fs_info->vol.bpc, 0);
4001a834:	90 10 00 18 	mov  %i0, %o0                                  
4001a838:	92 10 00 10 	mov  %l0, %o1                                  
4001a83c:	94 10 20 00 	clr  %o2                                       
4001a840:	7f ff e3 72 	call  40013608 <fat_cluster_set>               
4001a844:	98 10 20 00 	clr  %o4                                       
                if (fs_info->vol.bpc != bytes_written)                
4001a848:	c2 16 20 06 	lduh  [ %i0 + 6 ], %g1                         
4001a84c:	80 a0 40 08 	cmp  %g1, %o0                                  
4001a850:	22 bf ff c5 	be,a   4001a764 <fat_scan_fat_for_free_clusters+0x70><== ALWAYS TAKEN
4001a854:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
                {                                                     
                    rc = -1;                                          
4001a858:	10 bf ff eb 	b  4001a804 <fat_scan_fat_for_free_clusters+0x110><== NOT EXECUTED
4001a85c:	a8 10 3f ff 	mov  -1, %l4                                   <== 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)                                          
4001a860:	a8 10 20 00 	clr  %l4                                       <== NOT EXECUTED
        if (cl4find >= data_cls_val)                                  
            cl4find = 2;                                              
    }                                                                 
                                                                      
        fs_info->vol.next_cl = save_cln;                              
        if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)             
4001a864:	c2 06 20 44 	ld  [ %i0 + 0x44 ], %g1                        <== NOT EXECUTED
4001a868:	80 a0 7f ff 	cmp  %g1, -1                                   <== NOT EXECUTED
4001a86c:	02 80 00 05 	be  4001a880 <fat_scan_fat_for_free_clusters+0x18c><== NOT EXECUTED
4001a870:	e8 26 20 4c 	st  %l4, [ %i0 + 0x4c ]                        <== NOT EXECUTED
            fs_info->vol.free_cls -= (*cls_added);                    
4001a874:	c4 06 c0 00 	ld  [ %i3 ], %g2                               <== NOT EXECUTED
4001a878:	82 20 40 02 	sub  %g1, %g2, %g1                             <== NOT EXECUTED
4001a87c:	c2 26 20 44 	st  %g1, [ %i0 + 0x44 ]                        <== NOT EXECUTED
                                                                      
    *last_cl = save_cln;                                              
4001a880:	e8 27 00 00 	st  %l4, [ %i4 ]                               <== NOT EXECUTED
    fat_buf_release(fs_info);                                         
4001a884:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001a888:	7f ff e2 6f 	call  40013244 <fat_buf_release>               <== NOT EXECUTED
4001a88c:	a4 10 20 00 	clr  %l2                                       <== NOT EXECUTED
    fat_free_fat_clusters_chain(fs_info, (*chain));                   
    /* trying to save last allocated cluster for future use */        
    fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_FREE);           
    fat_buf_release(fs_info);                                         
    return rc;                                                        
}                                                                     
4001a890:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001a894:	91 e8 00 12 	restore  %g0, %l2, %o0                         <== NOT EXECUTED
    while (i < data_cls_val)                                          
    {                                                                 
        rc = fat_get_fat_cluster(fs_info, cl4find, &next_cln);        
        if ( rc != RC_OK )                                            
        {                                                             
            if (*cls_added != 0)                                      
4001a898:	c2 06 c0 00 	ld  [ %i3 ], %g1                               <== NOT EXECUTED
4001a89c:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4001a8a0:	02 bf ff e3 	be  4001a82c <fat_scan_fat_for_free_clusters+0x138><== NOT EXECUTED
4001a8a4:	01 00 00 00 	nop                                            <== NOT EXECUTED
                fat_free_fat_clusters_chain(fs_info, (*chain));       
4001a8a8:	d2 06 40 00 	ld  [ %i1 ], %o1                               <== NOT EXECUTED
4001a8ac:	7f ff ff 5a 	call  4001a614 <fat_free_fat_clusters_chain>   <== NOT EXECUTED
4001a8b0:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001a8b4:	30 bf ff de 	b,a   4001a82c <fat_scan_fat_for_free_clusters+0x138><== NOT EXECUTED
                                                                      
            /* have we satisfied request ? */                         
            if (*cls_added == count)                                  
            {                                                         
                    fs_info->vol.next_cl = save_cln;                  
                    if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE) 
4001a8b8:	c2 06 20 44 	ld  [ %i0 + 0x44 ], %g1                        
4001a8bc:	80 a0 7f ff 	cmp  %g1, -1                                   
4001a8c0:	02 80 00 05 	be  4001a8d4 <fat_scan_fat_for_free_clusters+0x1e0><== ALWAYS TAKEN
4001a8c4:	e0 26 20 4c 	st  %l0, [ %i0 + 0x4c ]                        
                        fs_info->vol.free_cls -= (*cls_added);        
4001a8c8:	c4 06 c0 00 	ld  [ %i3 ], %g2                               <== NOT EXECUTED
4001a8cc:	82 20 40 02 	sub  %g1, %g2, %g1                             <== NOT EXECUTED
4001a8d0:	c2 26 20 44 	st  %g1, [ %i0 + 0x44 ]                        <== NOT EXECUTED
                *last_cl = save_cln;                                  
4001a8d4:	e0 27 00 00 	st  %l0, [ %i4 ]                               
                fat_buf_release(fs_info);                             
4001a8d8:	7f ff e2 5b 	call  40013244 <fat_buf_release>               
4001a8dc:	90 10 00 18 	mov  %i0, %o0                                  
4001a8e0:	30 bf ff d3 	b,a   4001a82c <fat_scan_fat_for_free_clusters+0x138>
                /* set EOC value to new allocated cluster */          
                rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC);
                if ( rc != RC_OK )                                    
                {                                                     
                    /* cleanup activity */                            
                    fat_free_fat_clusters_chain(fs_info, (*chain));   
4001a8e4:	d2 06 40 00 	ld  [ %i1 ], %o1                               <== NOT EXECUTED
4001a8e8:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001a8ec:	7f ff ff 4a 	call  4001a614 <fat_free_fat_clusters_chain>   <== NOT EXECUTED
4001a8f0:	a4 10 00 01 	mov  %g1, %l2                                  <== NOT EXECUTED
4001a8f4:	30 bf ff ce 	b,a   4001a82c <fat_scan_fat_for_free_clusters+0x138><== NOT EXECUTED
                                                                      

40013558 <fat_sector_write>: fat_fs_info_t *fs_info, uint32_t start, uint32_t offset, uint32_t count, const void *buff) {
40013558:	9d e3 bf 98 	save  %sp, -104, %sp                           
    uint32_t            sec_num = start;                              
    uint32_t            ofs = offset;                                 
    uint8_t            *sec_buf;                                      
    uint32_t            c = 0;                                        
                                                                      
    while(count > 0)                                                  
4001355c:	80 a6 e0 00 	cmp  %i3, 0                                    
40013560:	02 80 00 28 	be  40013600 <fat_sector_write+0xa8>           <== NEVER TAKEN
40013564:	a0 10 20 00 	clr  %l0                                       
}                                                                     
                                                                      
static inline void                                                    
fat_buf_mark_modified(fat_fs_info_t *fs_info)                         
{                                                                     
    fs_info->c.modified = true;                                       
40013568:	10 80 00 12 	b  400135b0 <fat_sector_write+0x58>            
4001356c:	a2 10 20 01 	mov  1, %l1                                    
        c = MIN(count, (fs_info->vol.bps - ofs));                     
                                                                      
        if (c == fs_info->vol.bytes_per_block)                        
            rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &sec_buf);
        else                                                          
            rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
40013570:	96 07 bf fc 	add  %fp, -4, %o3                              
40013574:	7f ff ff ab 	call  40013420 <fat_buf_access>                
40013578:	90 10 00 18 	mov  %i0, %o0                                  
        if (rc != RC_OK)                                              
            return -1;                                                
                                                                      
        memcpy((sec_buf + ofs), (buff + cmpltd), c);                  
4001357c:	92 07 00 10 	add  %i4, %l0, %o1                             
                                                                      
        if (c == fs_info->vol.bytes_per_block)                        
            rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &sec_buf);
        else                                                          
            rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
        if (rc != RC_OK)                                              
40013580:	80 a2 20 00 	cmp  %o0, 0                                    
40013584:	12 80 00 1e 	bne  400135fc <fat_sector_write+0xa4>          <== NEVER TAKEN
40013588:	94 10 00 1d 	mov  %i5, %o2                                  
            return -1;                                                
                                                                      
        memcpy((sec_buf + ofs), (buff + cmpltd), c);                  
4001358c:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
                                                                      
        fat_buf_mark_modified(fs_info);                               
                                                                      
        count -= c;                                                   
        cmpltd +=c;                                                   
40013590:	a0 07 40 10 	add  %i5, %l0, %l0                             
        else                                                          
            rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
        if (rc != RC_OK)                                              
            return -1;                                                
                                                                      
        memcpy((sec_buf + ofs), (buff + cmpltd), c);                  
40013594:	40 00 26 24 	call  4001ce24 <memcpy>                        
40013598:	90 02 00 1a 	add  %o0, %i2, %o0                             
4001359c:	e2 2e 20 88 	stb  %l1, [ %i0 + 0x88 ]                       
                                                                      
        fat_buf_mark_modified(fs_info);                               
                                                                      
        count -= c;                                                   
        cmpltd +=c;                                                   
        sec_num++;                                                    
400135a0:	b2 06 60 01 	inc  %i1                                       
    uint32_t            sec_num = start;                              
    uint32_t            ofs = offset;                                 
    uint8_t            *sec_buf;                                      
    uint32_t            c = 0;                                        
                                                                      
    while(count > 0)                                                  
400135a4:	b6 a6 c0 1d 	subcc  %i3, %i5, %i3                           
400135a8:	02 80 00 16 	be  40013600 <fat_sector_write+0xa8>           <== ALWAYS TAKEN
400135ac:	b4 10 20 00 	clr  %i2                                       
    {                                                                 
        c = MIN(count, (fs_info->vol.bps - ofs));                     
400135b0:	fa 16 00 00 	lduh  [ %i0 ], %i5                             
400135b4:	ba 27 40 1a 	sub  %i5, %i2, %i5                             
400135b8:	80 a7 40 1b 	cmp  %i5, %i3                                  
400135bc:	08 80 00 03 	bleu  400135c8 <fat_sector_write+0x70>         
400135c0:	92 10 00 19 	mov  %i1, %o1                                  
400135c4:	ba 10 00 1b 	mov  %i3, %i5                                  
                                                                      
        if (c == fs_info->vol.bytes_per_block)                        
400135c8:	c2 16 20 0a 	lduh  [ %i0 + 0xa ], %g1                       
400135cc:	80 a0 40 1d 	cmp  %g1, %i5                                  
400135d0:	12 bf ff e8 	bne  40013570 <fat_sector_write+0x18>          <== ALWAYS TAKEN
400135d4:	94 10 20 01 	mov  1, %o2                                    
            rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &sec_buf);
400135d8:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
400135dc:	94 10 20 02 	mov  2, %o2                                    <== NOT EXECUTED
400135e0:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
400135e4:	7f ff ff 8f 	call  40013420 <fat_buf_access>                <== NOT EXECUTED
400135e8:	96 07 bf fc 	add  %fp, -4, %o3                              <== NOT EXECUTED
        else                                                          
            rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
        if (rc != RC_OK)                                              
            return -1;                                                
                                                                      
        memcpy((sec_buf + ofs), (buff + cmpltd), c);                  
400135ec:	92 07 00 10 	add  %i4, %l0, %o1                             <== NOT EXECUTED
                                                                      
        if (c == fs_info->vol.bytes_per_block)                        
            rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &sec_buf);
        else                                                          
            rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
        if (rc != RC_OK)                                              
400135f0:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
400135f4:	02 bf ff e6 	be  4001358c <fat_sector_write+0x34>           <== NOT EXECUTED
400135f8:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
            return -1;                                                
400135fc:	a0 10 3f ff 	mov  -1, %l0                                   <== NOT EXECUTED
        cmpltd +=c;                                                   
        sec_num++;                                                    
        ofs = 0;                                                      
    }                                                                 
    return cmpltd;                                                    
}                                                                     
40013600:	81 c7 e0 08 	ret                                            
40013604:	91 e8 00 10 	restore  %g0, %l0, %o0                         
                                                                      

4001a34c <fat_set_fat_cluster>: fat_set_fat_cluster( fat_fs_info_t *fs_info, uint32_t cln, uint32_t in_val ) {
4001a34c:	9d e3 bf 98 	save  %sp, -104, %sp                           
    int                 rc = RC_OK;                                   
    uint32_t            sec = 0;                                      
    uint32_t            ofs = 0;                                      
    uint16_t            fat16_clv = 0;                                
    uint32_t            fat32_clv = 0;                                
    uint8_t            *sec_buf = NULL;                               
4001a350:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
                                                                      
    /* sanity check */                                                
    if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )           
4001a354:	80 a6 60 01 	cmp  %i1, 1                                    
4001a358:	08 80 00 26 	bleu  4001a3f0 <fat_set_fat_cluster+0xa4>      <== NEVER TAKEN
4001a35c:	ba 10 00 18 	mov  %i0, %i5                                  
4001a360:	c2 06 20 38 	ld  [ %i0 + 0x38 ], %g1                        
4001a364:	82 00 60 01 	inc  %g1                                       
4001a368:	80 a6 40 01 	cmp  %i1, %g1                                  
4001a36c:	18 80 00 21 	bgu  4001a3f0 <fat_set_fat_cluster+0xa4>       <== NEVER TAKEN
4001a370:	01 00 00 00 	nop                                            
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
4001a374:	c2 0e 20 0e 	ldub  [ %i0 + 0xe ], %g1                       
4001a378:	80 88 60 01 	btst  1, %g1                                   
4001a37c:	12 80 00 23 	bne  4001a408 <fat_set_fat_cluster+0xbc>       
4001a380:	e0 0e 20 02 	ldub  [ %i0 + 2 ], %l0                         
4001a384:	82 08 60 02 	and  %g1, 2, %g1                               
4001a388:	80 88 60 ff 	btst  0xff, %g1                                
4001a38c:	02 80 00 25 	be  4001a420 <fat_set_fat_cluster+0xd4>        
4001a390:	c2 06 20 58 	ld  [ %i0 + 0x58 ], %g1                        
4001a394:	b9 2e 60 01 	sll  %i1, 1, %i4                               
4001a398:	a1 37 00 10 	srl  %i4, %l0, %l0                             
4001a39c:	a0 04 00 01 	add  %l0, %g1, %l0                             
          fs_info->vol.afat_loc;                                      
    ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
4001a3a0:	e2 17 40 00 	lduh  [ %i5 ], %l1                             
                                                                      
    rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);    
4001a3a4:	90 10 00 1d 	mov  %i5, %o0                                  
4001a3a8:	92 10 00 10 	mov  %l0, %o1                                  
4001a3ac:	94 10 20 01 	mov  1, %o2                                    
4001a3b0:	7f ff e4 1c 	call  40013420 <fat_buf_access>                
4001a3b4:	96 07 bf fc 	add  %fp, -4, %o3                              
    if (rc != RC_OK)                                                  
4001a3b8:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001a3bc:	12 80 00 11 	bne  4001a400 <fat_set_fat_cluster+0xb4>       <== NEVER TAKEN
4001a3c0:	a3 2c 60 10 	sll  %l1, 0x10, %l1                            
        return rc;                                                    
                                                                      
    switch ( fs_info->vol.type )                                      
4001a3c4:	f6 0f 60 0e 	ldub  [ %i5 + 0xe ], %i3                       
4001a3c8:	80 a6 e0 02 	cmp  %i3, 2                                    
    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);
4001a3cc:	a3 34 60 10 	srl  %l1, 0x10, %l1                            
4001a3d0:	a2 04 7f ff 	add  %l1, -1, %l1                              
                                                                      
    rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);    
    if (rc != RC_OK)                                                  
        return rc;                                                    
                                                                      
    switch ( fs_info->vol.type )                                      
4001a3d4:	02 80 00 17 	be  4001a430 <fat_set_fat_cluster+0xe4>        
4001a3d8:	b8 0f 00 11 	and  %i4, %l1, %i4                             
4001a3dc:	80 a6 e0 04 	cmp  %i3, 4                                    
4001a3e0:	02 80 00 3b 	be  4001a4cc <fat_set_fat_cluster+0x180>       
4001a3e4:	80 a6 e0 01 	cmp  %i3, 1                                    
4001a3e8:	02 80 00 1f 	be  4001a464 <fat_set_fat_cluster+0x118>       <== ALWAYS TAKEN
4001a3ec:	80 8e 60 01 	btst  1, %i1                                   
                                                                      
            fat_buf_mark_modified(fs_info);                           
            break;                                                    
                                                                      
        default:                                                      
            rtems_set_errno_and_return_minus_one(EIO);                
4001a3f0:	40 00 07 e8 	call  4001c390 <__errno>                       <== NOT EXECUTED
4001a3f4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4001a3f8:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
4001a3fc:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
            break;                                                    
                                                                      
    }                                                                 
                                                                      
    return RC_OK;                                                     
}                                                                     
4001a400:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001a404:	81 e8 00 00 	restore                                        <== 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) +
4001a408:	c2 06 20 58 	ld  [ %i0 + 0x58 ], %g1                        
4001a40c:	b9 36 60 01 	srl  %i1, 1, %i4                               
4001a410:	b8 07 00 19 	add  %i4, %i1, %i4                             
4001a414:	a1 37 00 10 	srl  %i4, %l0, %l0                             
4001a418:	10 bf ff e2 	b  4001a3a0 <fat_set_fat_cluster+0x54>         
4001a41c:	a0 04 00 01 	add  %l0, %g1, %l0                             
4001a420:	b9 2e 60 02 	sll  %i1, 2, %i4                               
4001a424:	a1 37 00 10 	srl  %i4, %l0, %l0                             
4001a428:	10 bf ff de 	b  4001a3a0 <fat_set_fat_cluster+0x54>         
4001a42c:	a0 04 00 01 	add  %l0, %g1, %l0                             
            }                                                         
            break;                                                    
                                                                      
        case FAT_FAT16:                                               
            *((uint16_t   *)(sec_buf + ofs)) =                        
                    (uint16_t  )(CT_LE_W(in_val));                    
4001a430:	83 2e a0 10 	sll  %i2, 0x10, %g1                            
4001a434:	83 30 60 18 	srl  %g1, 0x18, %g1                            
            break;                                                    
                                                                      
    }                                                                 
                                                                      
    return RC_OK;                                                     
}                                                                     
4001a438:	05 00 00 3f 	sethi  %hi(0xfc00), %g2                        
4001a43c:	84 10 a3 ff 	or  %g2, 0x3ff, %g2	! ffff <PROM_START+0xffff> 
4001a440:	b4 0e 80 02 	and  %i2, %g2, %i2                             
            }                                                         
            break;                                                    
                                                                      
        case FAT_FAT16:                                               
            *((uint16_t   *)(sec_buf + ofs)) =                        
                    (uint16_t  )(CT_LE_W(in_val));                    
4001a444:	b5 2e a0 08 	sll  %i2, 8, %i2                               
4001a448:	b4 16 80 01 	or  %i2, %g1, %i2                              
                }                                                     
            }                                                         
            break;                                                    
                                                                      
        case FAT_FAT16:                                               
            *((uint16_t   *)(sec_buf + ofs)) =                        
4001a44c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4001a450:	f4 30 40 1c 	sth  %i2, [ %g1 + %i4 ]                        
}                                                                     
                                                                      
static inline void                                                    
fat_buf_mark_modified(fat_fs_info_t *fs_info)                         
{                                                                     
    fs_info->c.modified = true;                                       
4001a454:	82 10 20 01 	mov  1, %g1                                    
4001a458:	c2 2f 60 88 	stb  %g1, [ %i5 + 0x88 ]                       
4001a45c:	81 c7 e0 08 	ret                                            
4001a460:	81 e8 00 00 	restore                                        
        return rc;                                                    
                                                                      
    switch ( fs_info->vol.type )                                      
    {                                                                 
        case FAT_FAT12:                                               
            if ( FAT_CLUSTER_IS_ODD(cln) )                            
4001a464:	02 80 00 30 	be  4001a524 <fat_set_fat_cluster+0x1d8>       
4001a468:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
            {                                                         
                fat16_clv = ((uint16_t  )in_val) << FAT_FAT12_SHIFT;  
                *(sec_buf + ofs) &= 0x0F;                             
                                                                      
                *(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00F0);    
4001a46c:	85 2e a0 04 	sll  %i2, 4, %g2                               
    {                                                                 
        case FAT_FAT12:                                               
            if ( FAT_CLUSTER_IS_ODD(cln) )                            
            {                                                         
                fat16_clv = ((uint16_t  )in_val) << FAT_FAT12_SHIFT;  
                *(sec_buf + ofs) &= 0x0F;                             
4001a470:	c6 08 40 1c 	ldub  [ %g1 + %i4 ], %g3                       
4001a474:	86 08 e0 0f 	and  %g3, 0xf, %g3                             
4001a478:	c6 28 40 1c 	stb  %g3, [ %g1 + %i4 ]                        
                                                                      
                *(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00F0);    
4001a47c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4001a480:	c6 08 40 1c 	ldub  [ %g1 + %i4 ], %g3                       
4001a484:	84 10 c0 02 	or  %g3, %g2, %g2                              
4001a488:	c4 28 40 1c 	stb  %g2, [ %g1 + %i4 ]                        
                                                                      
                fat_buf_mark_modified(fs_info);                       
                                                                      
                if ( ofs == (fs_info->vol.bps - 1) )                  
4001a48c:	c2 17 40 00 	lduh  [ %i5 ], %g1                             
4001a490:	82 00 7f ff 	add  %g1, -1, %g1                              
4001a494:	80 a0 40 1c 	cmp  %g1, %i4                                  
4001a498:	02 80 00 3a 	be  4001a580 <fat_set_fat_cluster+0x234>       <== NEVER TAKEN
4001a49c:	f6 2f 60 88 	stb  %i3, [ %i5 + 0x88 ]                       
                                                                      
                     fat_buf_mark_modified(fs_info);                  
                }                                                     
                else                                                  
                {                                                     
                    *(sec_buf + ofs + 1) &= 0x00;                     
4001a4a0:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4001a4a4:	b8 07 20 01 	inc  %i4                                       
4001a4a8:	c0 28 40 1c 	clrb  [ %g1 + %i4 ]                            
                                                                      
                    *(sec_buf + ofs + 1) |= (uint8_t  )((fat16_clv & 0xFF00)>>8);
4001a4ac:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4001a4b0:	b5 2e a0 14 	sll  %i2, 0x14, %i2                            
4001a4b4:	c4 08 40 1c 	ldub  [ %g1 + %i4 ], %g2                       
4001a4b8:	b5 36 a0 18 	srl  %i2, 0x18, %i2                            
4001a4bc:	84 10 80 1a 	or  %g2, %i2, %g2                              
4001a4c0:	c4 28 40 1c 	stb  %g2, [ %g1 + %i4 ]                        
4001a4c4:	81 c7 e0 08 	ret                                            
4001a4c8:	81 e8 00 00 	restore                                        
            break;                                                    
                                                                      
        case FAT_FAT32:                                               
            fat32_clv = CT_LE_L((in_val & FAT_FAT32_MASK));           
                                                                      
            *((uint32_t *)(sec_buf + ofs)) &= CT_LE_L(0xF0000000);    
4001a4cc:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
                    (uint16_t  )(CT_LE_W(in_val));                    
            fat_buf_mark_modified(fs_info);                           
            break;                                                    
                                                                      
        case FAT_FAT32:                                               
            fat32_clv = CT_LE_L((in_val & FAT_FAT32_MASK));           
4001a4d0:	03 3c 00 00 	sethi  %hi(0xf0000000), %g1                    
                                                                      
            *((uint32_t *)(sec_buf + ofs)) &= CT_LE_L(0xF0000000);    
4001a4d4:	c6 00 80 1c 	ld  [ %g2 + %i4 ], %g3                         
                    (uint16_t  )(CT_LE_W(in_val));                    
            fat_buf_mark_modified(fs_info);                           
            break;                                                    
                                                                      
        case FAT_FAT32:                                               
            fat32_clv = CT_LE_L((in_val & FAT_FAT32_MASK));           
4001a4d8:	82 2e 80 01 	andn  %i2, %g1, %g1                            
  uint32_t value                                                      
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
4001a4dc:	89 30 60 18 	srl  %g1, 0x18, %g4                            
  byte3 = (value >> 16) & 0xff;                                       
  byte2 = (value >> 8)  & 0xff;                                       
4001a4e0:	b7 30 60 08 	srl  %g1, 8, %i3                               
                                                                      
            *((uint32_t *)(sec_buf + ofs)) &= CT_LE_L(0xF0000000);    
4001a4e4:	86 08 e0 f0 	and  %g3, 0xf0, %g3                            
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
4001a4e8:	b5 2e a0 18 	sll  %i2, 0x18, %i2                            
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
  byte3 = (value >> 16) & 0xff;                                       
  byte2 = (value >> 8)  & 0xff;                                       
4001a4ec:	b6 0e e0 ff 	and  %i3, 0xff, %i3                            
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
4001a4f0:	b4 16 80 04 	or  %i2, %g4, %i2                              
4001a4f4:	b7 2e e0 10 	sll  %i3, 0x10, %i3                            
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
  byte3 = (value >> 16) & 0xff;                                       
4001a4f8:	89 30 60 10 	srl  %g1, 0x10, %g4                            
  byte2 = (value >> 8)  & 0xff;                                       
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
4001a4fc:	82 16 80 1b 	or  %i2, %i3, %g1                              
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
  byte3 = (value >> 16) & 0xff;                                       
4001a500:	88 09 20 ff 	and  %g4, 0xff, %g4                            
  byte2 = (value >> 8)  & 0xff;                                       
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
4001a504:	89 29 20 08 	sll  %g4, 8, %g4                               
4001a508:	82 10 40 04 	or  %g1, %g4, %g1                              
                                                                      
            *((uint32_t *)(sec_buf + ofs)) |= fat32_clv;              
4001a50c:	82 10 40 03 	or  %g1, %g3, %g1                              
4001a510:	c2 20 80 1c 	st  %g1, [ %g2 + %i4 ]                         
4001a514:	82 10 20 01 	mov  1, %g1                                    
4001a518:	c2 2f 60 88 	stb  %g1, [ %i5 + 0x88 ]                       
4001a51c:	81 c7 e0 08 	ret                                            
4001a520:	81 e8 00 00 	restore                                        
                    *(sec_buf + ofs + 1) |= (uint8_t  )((fat16_clv & 0xFF00)>>8);
                }                                                     
            }                                                         
            else                                                      
            {                                                         
                fat16_clv = ((uint16_t  )in_val) & FAT_FAT12_MASK;    
4001a524:	b4 0e af ff 	and  %i2, 0xfff, %i2                           
                *(sec_buf + ofs) &= 0x00;                             
4001a528:	c0 28 40 1c 	clrb  [ %g1 + %i4 ]                            
                                                                      
                *(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00FF);    
4001a52c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4001a530:	c4 08 40 1c 	ldub  [ %g1 + %i4 ], %g2                       
4001a534:	84 10 80 1a 	or  %g2, %i2, %g2                              
4001a538:	c4 28 40 1c 	stb  %g2, [ %g1 + %i4 ]                        
                                                                      
                fat_buf_mark_modified(fs_info);                       
                                                                      
                if ( ofs == (fs_info->vol.bps - 1) )                  
4001a53c:	c2 17 40 00 	lduh  [ %i5 ], %g1                             
4001a540:	82 00 7f ff 	add  %g1, -1, %g1                              
4001a544:	80 a0 40 1c 	cmp  %g1, %i4                                  
4001a548:	02 80 00 20 	be  4001a5c8 <fat_set_fat_cluster+0x27c>       <== NEVER TAKEN
4001a54c:	f6 2f 60 88 	stb  %i3, [ %i5 + 0x88 ]                       
                                                                      
                    fat_buf_mark_modified(fs_info);                   
                }                                                     
                else                                                  
                {                                                     
                    *(sec_buf + ofs + 1) &= 0xF0;                     
4001a550:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4001a554:	b8 07 20 01 	inc  %i4                                       
4001a558:	c4 08 40 1c 	ldub  [ %g1 + %i4 ], %g2                       
                                                                      
                    *(sec_buf + ofs+1) |= (uint8_t)((fat16_clv & 0xFF00)>>8);
4001a55c:	b5 36 a0 08 	srl  %i2, 8, %i2                               
                                                                      
                    fat_buf_mark_modified(fs_info);                   
                }                                                     
                else                                                  
                {                                                     
                    *(sec_buf + ofs + 1) &= 0xF0;                     
4001a560:	84 08 bf f0 	and  %g2, -16, %g2                             
4001a564:	c4 28 40 1c 	stb  %g2, [ %g1 + %i4 ]                        
                                                                      
                    *(sec_buf + ofs+1) |= (uint8_t)((fat16_clv & 0xFF00)>>8);
4001a568:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4001a56c:	c4 08 40 1c 	ldub  [ %g1 + %i4 ], %g2                       
4001a570:	b4 10 80 1a 	or  %g2, %i2, %i2                              
4001a574:	f4 28 40 1c 	stb  %i2, [ %g1 + %i4 ]                        
4001a578:	81 c7 e0 08 	ret                                            
4001a57c:	81 e8 00 00 	restore                                        
                                                                      
                fat_buf_mark_modified(fs_info);                       
                                                                      
                if ( ofs == (fs_info->vol.bps - 1) )                  
                {                                                     
                    rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
4001a580:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001a584:	92 04 20 01 	add  %l0, 1, %o1                               <== NOT EXECUTED
4001a588:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
4001a58c:	7f ff e3 a5 	call  40013420 <fat_buf_access>                <== NOT EXECUTED
4001a590:	96 07 bf fc 	add  %fp, -4, %o3                              <== NOT EXECUTED
                                        &sec_buf);                    
                    if (rc != RC_OK)                                  
4001a594:	b0 92 20 00 	orcc  %o0, 0, %i0                              <== NOT EXECUTED
4001a598:	12 bf ff 9a 	bne  4001a400 <fat_set_fat_cluster+0xb4>       <== NOT EXECUTED
4001a59c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          <== NOT EXECUTED
                        return rc;                                    
                                                                      
                     *sec_buf &= 0x00;                                
                                                                      
                     *sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);  
4001a5a0:	87 2e a0 14 	sll  %i2, 0x14, %g3                            <== NOT EXECUTED
                    rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
                                        &sec_buf);                    
                    if (rc != RC_OK)                                  
                        return rc;                                    
                                                                      
                     *sec_buf &= 0x00;                                
4001a5a4:	c0 28 40 00 	clrb  [ %g1 ]                                  <== NOT EXECUTED
                                                                      
                     *sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);  
4001a5a8:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          <== NOT EXECUTED
4001a5ac:	87 30 e0 18 	srl  %g3, 0x18, %g3                            <== NOT EXECUTED
4001a5b0:	c4 08 40 00 	ldub  [ %g1 ], %g2                             <== NOT EXECUTED
4001a5b4:	84 10 c0 02 	or  %g3, %g2, %g2                              <== NOT EXECUTED
4001a5b8:	c4 28 40 00 	stb  %g2, [ %g1 ]                              <== NOT EXECUTED
4001a5bc:	f6 2f 60 88 	stb  %i3, [ %i5 + 0x88 ]                       <== NOT EXECUTED
4001a5c0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001a5c4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
                fat_buf_mark_modified(fs_info);                       
                                                                      
                if ( ofs == (fs_info->vol.bps - 1) )                  
                {                                                     
                    rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
4001a5c8:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001a5cc:	92 04 20 01 	add  %l0, 1, %o1                               <== NOT EXECUTED
4001a5d0:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
4001a5d4:	7f ff e3 93 	call  40013420 <fat_buf_access>                <== NOT EXECUTED
4001a5d8:	96 07 bf fc 	add  %fp, -4, %o3                              <== NOT EXECUTED
                                        &sec_buf);                    
                    if (rc != RC_OK)                                  
4001a5dc:	b0 92 20 00 	orcc  %o0, 0, %i0                              <== NOT EXECUTED
4001a5e0:	12 bf ff 88 	bne  4001a400 <fat_set_fat_cluster+0xb4>       <== NOT EXECUTED
4001a5e4:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          <== NOT EXECUTED
                        return rc;                                    
                                                                      
                    *sec_buf &= 0xF0;                                 
                                                                      
                    *sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);   
4001a5e8:	b5 36 a0 08 	srl  %i2, 8, %i2                               <== NOT EXECUTED
                    rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
                                        &sec_buf);                    
                    if (rc != RC_OK)                                  
                        return rc;                                    
                                                                      
                    *sec_buf &= 0xF0;                                 
4001a5ec:	c4 08 40 00 	ldub  [ %g1 ], %g2                             <== NOT EXECUTED
4001a5f0:	84 08 bf f0 	and  %g2, -16, %g2                             <== NOT EXECUTED
4001a5f4:	c4 28 40 00 	stb  %g2, [ %g1 ]                              <== NOT EXECUTED
                                                                      
                    *sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);   
4001a5f8:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          <== NOT EXECUTED
4001a5fc:	c4 08 40 00 	ldub  [ %g1 ], %g2                             <== NOT EXECUTED
4001a600:	84 16 80 02 	or  %i2, %g2, %g2                              <== NOT EXECUTED
4001a604:	c4 28 40 00 	stb  %g2, [ %g1 ]                              <== NOT EXECUTED
4001a608:	f6 2f 60 88 	stb  %i3, [ %i5 + 0x88 ]                       <== NOT EXECUTED
4001a60c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001a610:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4001424c <fat_shutdown_drive>: * RC_OK on success, or -1 if error occured * and errno set appropriately */ int fat_shutdown_drive(fat_fs_info_t *fs_info) {
4001424c:	9d e3 bf a0 	save  %sp, -96, %sp                            
    int            rc = RC_OK;                                        
    int            i = 0;                                             
                                                                      
    rc = fat_sync(fs_info);                                           
40014250:	90 10 00 18 	mov  %i0, %o0                                  
40014254:	7f ff ff b4 	call  40014124 <fat_sync>                      
40014258:	b8 10 00 18 	mov  %i0, %i4                                  
    if ( rc != RC_OK )                                                
4001425c:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40014260:	32 80 00 35 	bne,a   40014334 <fat_shutdown_drive+0xe8>     <== NEVER TAKEN
40014264:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
        rc = -1;                                                      
40014268:	b6 10 20 00 	clr  %i3                                       
                                                                      
    for (i = 0; i < FAT_HASH_SIZE; i++)                               
    {                                                                 
        rtems_chain_node    *node = NULL;                             
        rtems_chain_control *the_chain = fs_info->vhash + i;          
4001426c:	fa 07 20 6c 	ld  [ %i4 + 0x6c ], %i5                        
                                                                      
        while ( (node = rtems_chain_get(the_chain)) != NULL )         
40014270:	10 80 00 04 	b  40014280 <fat_shutdown_drive+0x34>          
40014274:	ba 07 40 1b 	add  %i5, %i3, %i5                             
            free(node);                                               
40014278:	7f ff c2 4d 	call  40004bac <free>                          
4001427c:	01 00 00 00 	nop                                            
 */                                                                   
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(               
  rtems_chain_control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Get( the_chain );                                     
40014280:	7f ff d7 3a 	call  40009f68 <_Chain_Get>                    
40014284:	90 10 00 1d 	mov  %i5, %o0                                  
    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 )         
40014288:	80 a2 20 00 	cmp  %o0, 0                                    
4001428c:	12 bf ff fb 	bne  40014278 <fat_shutdown_drive+0x2c>        
40014290:	01 00 00 00 	nop                                            
40014294:	b6 06 e0 0c 	add  %i3, 0xc, %i3                             
                                                                      
    rc = fat_sync(fs_info);                                           
    if ( rc != RC_OK )                                                
        rc = -1;                                                      
                                                                      
    for (i = 0; i < FAT_HASH_SIZE; i++)                               
40014298:	80 a6 e0 18 	cmp  %i3, 0x18                                 
4001429c:	32 bf ff f5 	bne,a   40014270 <fat_shutdown_drive+0x24>     
400142a0:	fa 07 20 6c 	ld  [ %i4 + 0x6c ], %i5                        
400142a4:	b6 10 20 00 	clr  %i3                                       
    }                                                                 
                                                                      
    for (i = 0; i < FAT_HASH_SIZE; i++)                               
    {                                                                 
        rtems_chain_node    *node = NULL;                             
        rtems_chain_control *the_chain = fs_info->rhash + i;          
400142a8:	fa 07 20 70 	ld  [ %i4 + 0x70 ], %i5                        
                                                                      
        while ( (node = rtems_chain_get(the_chain)) != NULL )         
400142ac:	10 80 00 04 	b  400142bc <fat_shutdown_drive+0x70>          
400142b0:	ba 07 40 1b 	add  %i5, %i3, %i5                             
            free(node);                                               
400142b4:	7f ff c2 3e 	call  40004bac <free>                          <== NOT EXECUTED
400142b8:	01 00 00 00 	nop                                            <== NOT EXECUTED
400142bc:	7f ff d7 2b 	call  40009f68 <_Chain_Get>                    
400142c0:	90 10 00 1d 	mov  %i5, %o0                                  
    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 )         
400142c4:	80 a2 20 00 	cmp  %o0, 0                                    
400142c8:	12 bf ff fb 	bne  400142b4 <fat_shutdown_drive+0x68>        <== NEVER TAKEN
400142cc:	01 00 00 00 	nop                                            
400142d0:	b6 06 e0 0c 	add  %i3, 0xc, %i3                             
                                                                      
        while ( (node = rtems_chain_get(the_chain)) != NULL )         
            free(node);                                               
    }                                                                 
                                                                      
    for (i = 0; i < FAT_HASH_SIZE; i++)                               
400142d4:	80 a6 e0 18 	cmp  %i3, 0x18                                 
400142d8:	32 bf ff f5 	bne,a   400142ac <fat_shutdown_drive+0x60>     
400142dc:	fa 07 20 70 	ld  [ %i4 + 0x70 ], %i5                        
                                                                      
        while ( (node = rtems_chain_get(the_chain)) != NULL )         
            free(node);                                               
    }                                                                 
                                                                      
    free(fs_info->vhash);                                             
400142e0:	7f ff c2 33 	call  40004bac <free>                          
400142e4:	d0 07 20 6c 	ld  [ %i4 + 0x6c ], %o0                        
    free(fs_info->rhash);                                             
400142e8:	7f ff c2 31 	call  40004bac <free>                          
400142ec:	d0 07 20 70 	ld  [ %i4 + 0x70 ], %o0                        
                                                                      
    free(fs_info->uino);                                              
400142f0:	7f ff c2 2f 	call  40004bac <free>                          
400142f4:	d0 07 20 74 	ld  [ %i4 + 0x74 ], %o0                        
    free(fs_info->sec_buf);                                           
400142f8:	7f ff c2 2d 	call  40004bac <free>                          
400142fc:	d0 07 20 90 	ld  [ %i4 + 0x90 ], %o0                        
    close(fs_info->vol.fd);                                           
40014300:	7f ff c2 09 	call  40004b24 <close>                         
40014304:	d0 07 20 60 	ld  [ %i4 + 0x60 ], %o0                        
                                                                      
    if (rc)                                                           
40014308:	80 a6 20 00 	cmp  %i0, 0                                    
4001430c:	12 80 00 04 	bne  4001431c <fat_shutdown_drive+0xd0>        <== NEVER TAKEN
40014310:	01 00 00 00 	nop                                            
        errno = EIO;                                                  
    return rc;                                                        
}                                                                     
40014314:	81 c7 e0 08 	ret                                            
40014318:	81 e8 00 00 	restore                                        
    free(fs_info->uino);                                              
    free(fs_info->sec_buf);                                           
    close(fs_info->vol.fd);                                           
                                                                      
    if (rc)                                                           
        errno = EIO;                                                  
4001431c:	40 00 20 1d 	call  4001c390 <__errno>                       <== NOT EXECUTED
40014320:	01 00 00 00 	nop                                            <== NOT EXECUTED
40014324:	82 10 20 05 	mov  5, %g1	! 5 <PROM_START+0x5>               <== NOT EXECUTED
40014328:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
    return rc;                                                        
}                                                                     
4001432c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40014330:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    int            rc = RC_OK;                                        
    int            i = 0;                                             
                                                                      
    rc = fat_sync(fs_info);                                           
    if ( rc != RC_OK )                                                
        rc = -1;                                                      
40014334:	10 bf ff ce 	b  4001426c <fat_shutdown_drive+0x20>          <== NOT EXECUTED
40014338:	b6 10 20 00 	clr  %i3                                       <== NOT EXECUTED
                                                                      

40014124 <fat_sync>: return RC_OK; } int fat_sync(fat_fs_info_t *fs_info) {
40014124:	9d e3 bf 98 	save  %sp, -104, %sp                           
static int                                                            
fat_fat32_update_fsinfo_sector(fat_fs_info_t *fs_info)                
{                                                                     
    ssize_t ret1 = 0, ret2 = 0;                                       
                                                                      
    if (fs_info->vol.type == FAT_FAT32)                               
40014128:	c2 0e 20 0e 	ldub  [ %i0 + 0xe ], %g1                       
4001412c:	80 a0 60 04 	cmp  %g1, 4                                    
40014130:	02 80 00 0c 	be  40014160 <fat_sync+0x3c>                   
40014134:	ba 10 00 18 	mov  %i0, %i5                                  
                                    FAT_FSINFO_FREE_CLUSTER_COUNT_OFFSET,
                                    sizeof(le_free_count),            
                                    &le_free_count);                  
        }                                                             
                                                                      
        if (next_free != fs_info->vol.next_cl_in_fs_info)             
40014138:	b0 10 20 00 	clr  %i0                                       
                                                                      
    rc = fat_fat32_update_fsinfo_sector(fs_info);                     
    if ( rc != RC_OK )                                                
        rc = -1;                                                      
                                                                      
    fat_buf_release(fs_info);                                         
4001413c:	7f ff fc 42 	call  40013244 <fat_buf_release>               
40014140:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
    if (rtems_bdbuf_syncdev(fs_info->vol.dd) != RTEMS_SUCCESSFUL)     
40014144:	7f ff f5 05 	call  40011558 <rtems_bdbuf_syncdev>           
40014148:	d0 07 60 64 	ld  [ %i5 + 0x64 ], %o0                        
4001414c:	80 a2 20 00 	cmp  %o0, 0                                    
40014150:	12 80 00 3d 	bne  40014244 <fat_sync+0x120>                 <== NEVER TAKEN
40014154:	01 00 00 00 	nop                                            
        rc = -1;                                                      
                                                                      
    return rc;                                                        
}                                                                     
40014158:	81 c7 e0 08 	ret                                            
4001415c:	81 e8 00 00 	restore                                        
{                                                                     
    ssize_t ret1 = 0, ret2 = 0;                                       
                                                                      
    if (fs_info->vol.type == FAT_FAT32)                               
    {                                                                 
        uint32_t free_count = fs_info->vol.free_cls;                  
40014160:	c2 06 20 44 	ld  [ %i0 + 0x44 ], %g1                        
        uint32_t next_free = fs_info->vol.next_cl;                    
                                                                      
        if (free_count != fs_info->vol.free_cls_in_fs_info)           
40014164:	c4 06 20 48 	ld  [ %i0 + 0x48 ], %g2                        
    ssize_t ret1 = 0, ret2 = 0;                                       
                                                                      
    if (fs_info->vol.type == FAT_FAT32)                               
    {                                                                 
        uint32_t free_count = fs_info->vol.free_cls;                  
        uint32_t next_free = fs_info->vol.next_cl;                    
40014168:	f8 06 20 4c 	ld  [ %i0 + 0x4c ], %i4                        
                                                                      
        if (free_count != fs_info->vol.free_cls_in_fs_info)           
4001416c:	80 a0 40 02 	cmp  %g1, %g2                                  
40014170:	02 80 00 16 	be  400141c8 <fat_sync+0xa4>                   <== ALWAYS TAKEN
40014174:	b6 10 20 00 	clr  %i3                                       
  uint32_t value                                                      
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
40014178:	85 30 60 18 	srl  %g1, 0x18, %g2                            <== NOT EXECUTED
        {                                                             
            uint32_t le_free_count = CT_LE_L(free_count);             
                                                                      
            fs_info->vol.free_cls_in_fs_info = free_count;            
                                                                      
            ret1 = fat_sector_write(fs_info,                          
4001417c:	d2 16 20 40 	lduh  [ %i0 + 0x40 ], %o1                      <== NOT EXECUTED
  byte3 = (value >> 16) & 0xff;                                       
  byte2 = (value >> 8)  & 0xff;                                       
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
40014180:	87 28 60 18 	sll  %g1, 0x18, %g3                            <== NOT EXECUTED
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
  byte3 = (value >> 16) & 0xff;                                       
  byte2 = (value >> 8)  & 0xff;                                       
40014184:	89 30 60 08 	srl  %g1, 8, %g4                               <== NOT EXECUTED
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
40014188:	86 10 c0 02 	or  %g3, %g2, %g3                              <== NOT EXECUTED
                                                                      
        if (free_count != fs_info->vol.free_cls_in_fs_info)           
        {                                                             
            uint32_t le_free_count = CT_LE_L(free_count);             
                                                                      
            fs_info->vol.free_cls_in_fs_info = free_count;            
4001418c:	c2 26 20 48 	st  %g1, [ %i0 + 0x48 ]                        <== NOT EXECUTED
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
  byte3 = (value >> 16) & 0xff;                                       
40014190:	85 30 60 10 	srl  %g1, 0x10, %g2                            <== NOT EXECUTED
  byte2 = (value >> 8)  & 0xff;                                       
40014194:	88 09 20 ff 	and  %g4, 0xff, %g4                            <== NOT EXECUTED
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
  byte3 = (value >> 16) & 0xff;                                       
40014198:	84 08 a0 ff 	and  %g2, 0xff, %g2                            <== NOT EXECUTED
  byte2 = (value >> 8)  & 0xff;                                       
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
4001419c:	89 29 20 10 	sll  %g4, 0x10, %g4                            <== NOT EXECUTED
400141a0:	85 28 a0 08 	sll  %g2, 8, %g2                               <== NOT EXECUTED
400141a4:	86 10 c0 04 	or  %g3, %g4, %g3                              <== NOT EXECUTED
400141a8:	82 10 c0 02 	or  %g3, %g2, %g1                              <== NOT EXECUTED
                                                                      
            ret1 = fat_sector_write(fs_info,                          
400141ac:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
        uint32_t free_count = fs_info->vol.free_cls;                  
        uint32_t next_free = fs_info->vol.next_cl;                    
                                                                      
        if (free_count != fs_info->vol.free_cls_in_fs_info)           
        {                                                             
            uint32_t le_free_count = CT_LE_L(free_count);             
400141b0:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          <== NOT EXECUTED
                                                                      
            fs_info->vol.free_cls_in_fs_info = free_count;            
                                                                      
            ret1 = fat_sector_write(fs_info,                          
400141b4:	94 10 21 e8 	mov  0x1e8, %o2                                <== NOT EXECUTED
400141b8:	96 10 20 04 	mov  4, %o3                                    <== NOT EXECUTED
400141bc:	7f ff fc e7 	call  40013558 <fat_sector_write>              <== NOT EXECUTED
400141c0:	98 07 bf fc 	add  %fp, -4, %o4                              <== NOT EXECUTED
400141c4:	b7 32 20 1f 	srl  %o0, 0x1f, %i3                            <== NOT EXECUTED
                                    FAT_FSINFO_FREE_CLUSTER_COUNT_OFFSET,
                                    sizeof(le_free_count),            
                                    &le_free_count);                  
        }                                                             
                                                                      
        if (next_free != fs_info->vol.next_cl_in_fs_info)             
400141c8:	c4 07 60 50 	ld  [ %i5 + 0x50 ], %g2                        
400141cc:	80 a7 00 02 	cmp  %i4, %g2                                  
400141d0:	02 80 00 16 	be  40014228 <fat_sync+0x104>                  <== NEVER TAKEN
400141d4:	90 10 20 00 	clr  %o0                                       
400141d8:	85 2f 20 18 	sll  %i4, 0x18, %g2                            
        {                                                             
            uint32_t le_next_free = CT_LE_L(next_free);               
                                                                      
            fs_info->vol.next_cl_in_fs_info = next_free;              
                                                                      
            ret2 = fat_sector_write(fs_info,                          
400141dc:	d2 17 60 40 	lduh  [ %i5 + 0x40 ], %o1                      
  uint32_t value                                                      
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
400141e0:	83 37 20 18 	srl  %i4, 0x18, %g1                            
  byte3 = (value >> 16) & 0xff;                                       
  byte2 = (value >> 8)  & 0xff;                                       
400141e4:	87 37 20 08 	srl  %i4, 8, %g3                               
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
400141e8:	82 10 80 01 	or  %g2, %g1, %g1                              
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
  byte3 = (value >> 16) & 0xff;                                       
  byte2 = (value >> 8)  & 0xff;                                       
400141ec:	86 08 e0 ff 	and  %g3, 0xff, %g3                            
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
  byte3 = (value >> 16) & 0xff;                                       
400141f0:	85 37 20 10 	srl  %i4, 0x10, %g2                            
  byte2 = (value >> 8)  & 0xff;                                       
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
400141f4:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
  byte3 = (value >> 16) & 0xff;                                       
400141f8:	84 08 a0 ff 	and  %g2, 0xff, %g2                            
  byte2 = (value >> 8)  & 0xff;                                       
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
400141fc:	82 10 40 03 	or  %g1, %g3, %g1                              
40014200:	85 28 a0 08 	sll  %g2, 8, %g2                               
40014204:	82 10 40 02 	or  %g1, %g2, %g1                              
                                                                      
        if (next_free != fs_info->vol.next_cl_in_fs_info)             
        {                                                             
            uint32_t le_next_free = CT_LE_L(next_free);               
                                                                      
            fs_info->vol.next_cl_in_fs_info = next_free;              
40014208:	f8 27 60 50 	st  %i4, [ %i5 + 0x50 ]                        
                                                                      
            ret2 = fat_sector_write(fs_info,                          
4001420c:	90 10 00 1d 	mov  %i5, %o0                                  
                                    &le_free_count);                  
        }                                                             
                                                                      
        if (next_free != fs_info->vol.next_cl_in_fs_info)             
        {                                                             
            uint32_t le_next_free = CT_LE_L(next_free);               
40014210:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
                                                                      
            fs_info->vol.next_cl_in_fs_info = next_free;              
                                                                      
            ret2 = fat_sector_write(fs_info,                          
40014214:	94 10 21 ec 	mov  0x1ec, %o2                                
40014218:	96 10 20 04 	mov  4, %o3                                    
4001421c:	7f ff fc cf 	call  40013558 <fat_sector_write>              
40014220:	98 07 bf fc 	add  %fp, -4, %o4                              
40014224:	91 32 20 1f 	srl  %o0, 0x1f, %o0                            
                                    sizeof(le_next_free),             
                                    &le_next_free);                   
        }                                                             
    }                                                                 
                                                                      
    if ( (ret1 < 0) || (ret2 < 0) )                                   
40014228:	80 8a 20 ff 	btst  0xff, %o0                                
4001422c:	12 80 00 04 	bne  4001423c <fat_sync+0x118>                 <== NEVER TAKEN
40014230:	80 8e e0 ff 	btst  0xff, %i3                                
40014234:	22 bf ff c2 	be,a   4001413c <fat_sync+0x18>                <== ALWAYS TAKEN
40014238:	b0 10 20 00 	clr  %i0                                       
{                                                                     
    int rc = RC_OK;                                                   
                                                                      
    rc = fat_fat32_update_fsinfo_sector(fs_info);                     
    if ( rc != RC_OK )                                                
        rc = -1;                                                      
4001423c:	10 bf ff c0 	b  4001413c <fat_sync+0x18>                    <== NOT EXECUTED
40014240:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
                                                                      
    fat_buf_release(fs_info);                                         
                                                                      
    if (rtems_bdbuf_syncdev(fs_info->vol.dd) != RTEMS_SUCCESSFUL)     
        rc = -1;                                                      
40014244:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40014248:	91 e8 3f ff 	restore  %g0, -1, %o0                          <== NOT EXECUTED
                                                                      

40036eb4 <fchdir>: /** * compatible with SVr4, 4.4BSD and X/OPEN - Change Directory */ int fchdir( int fd ) {
40036eb4:	9d e3 bf 40 	save  %sp, -192, %sp                           <== NOT EXECUTED
                                                                      
  st.st_mode = 0;                                                     
  st.st_uid = 0;                                                      
  st.st_gid = 0;                                                      
                                                                      
  rtems_libio_check_fd( fd );                                         
40036eb8:	03 10 01 90 	sethi  %hi(0x40064000), %g1                    <== NOT EXECUTED
40036ebc:	c2 00 62 20 	ld  [ %g1 + 0x220 ], %g1	! 40064220 <rtems_libio_number_iops><== NOT EXECUTED
  int rv = 0;                                                         
  rtems_libio_t *iop;                                                 
  struct stat st;                                                     
  rtems_filesystem_location_info_t loc;                               
                                                                      
  st.st_mode = 0;                                                     
40036ec0:	c0 27 bf c4 	clr  [ %fp + -60 ]                             <== NOT EXECUTED
  st.st_uid = 0;                                                      
40036ec4:	c0 37 bf ca 	clrh  [ %fp + -54 ]                            <== NOT EXECUTED
  st.st_gid = 0;                                                      
                                                                      
  rtems_libio_check_fd( fd );                                         
40036ec8:	80 a6 00 01 	cmp  %i0, %g1                                  <== NOT EXECUTED
40036ecc:	1a 80 00 3d 	bcc  40036fc0 <fchdir+0x10c>                   <== NOT EXECUTED
40036ed0:	c0 37 bf cc 	clrh  [ %fp + -52 ]                            <== NOT EXECUTED
  iop = rtems_libio_iop( fd );                                        
40036ed4:	03 10 01 a0 	sethi  %hi(0x40068000), %g1                    <== NOT EXECUTED
40036ed8:	fa 00 63 0c 	ld  [ %g1 + 0x30c ], %i5	! 4006830c <rtems_libio_iops><== NOT EXECUTED
40036edc:	83 2e 20 03 	sll  %i0, 3, %g1                               <== NOT EXECUTED
40036ee0:	b1 2e 20 06 	sll  %i0, 6, %i0                               <== NOT EXECUTED
40036ee4:	b0 26 00 01 	sub  %i0, %g1, %i0                             <== NOT EXECUTED
40036ee8:	ba 07 40 18 	add  %i5, %i0, %i5                             <== NOT EXECUTED
  rtems_libio_check_is_open( iop );                                   
40036eec:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        <== NOT EXECUTED
40036ef0:	80 88 61 00 	btst  0x100, %g1                               <== NOT EXECUTED
40036ef4:	02 80 00 33 	be  40036fc0 <fchdir+0x10c>                    <== NOT EXECUTED
40036ef8:	01 00 00 00 	nop                                            <== NOT EXECUTED
                                                                      
static inline void rtems_filesystem_instance_lock(                    
  const rtems_filesystem_location_info_t *loc                         
)                                                                     
{                                                                     
  const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
40036efc:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        <== NOT EXECUTED
                                                                      
  (*mt_entry->ops->lock_h)( mt_entry );                               
40036f00:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         <== NOT EXECUTED
40036f04:	c2 00 40 00 	ld  [ %g1 ], %g1                               <== NOT EXECUTED
40036f08:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
40036f0c:	b8 07 60 14 	add  %i5, 0x14, %i4                            <== NOT EXECUTED
                                                                      
  rtems_filesystem_instance_lock( &iop->pathinfo );                   
  rv = (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, &st );     
40036f10:	c2 07 60 24 	ld  [ %i5 + 0x24 ], %g1                        <== NOT EXECUTED
40036f14:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
40036f18:	c2 00 60 18 	ld  [ %g1 + 0x18 ], %g1                        <== NOT EXECUTED
40036f1c:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
40036f20:	92 07 bf b8 	add  %fp, -72, %o1                             <== NOT EXECUTED
  if ( rv == 0 ) {                                                    
40036f24:	b0 92 20 00 	orcc  %o0, 0, %i0                              <== NOT EXECUTED
40036f28:	02 80 00 09 	be  40036f4c <fchdir+0x98>                     <== NOT EXECUTED
40036f2c:	d2 07 bf c4 	ld  [ %fp + -60 ], %o1                         <== NOT EXECUTED
                                                                      
static inline void rtems_filesystem_instance_unlock(                  
  const rtems_filesystem_location_info_t *loc                         
)                                                                     
{                                                                     
  const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
40036f30:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        <== NOT EXECUTED
                                                                      
  (*mt_entry->ops->unlock_h)( mt_entry );                             
40036f34:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         <== NOT EXECUTED
40036f38:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           <== NOT EXECUTED
40036f3c:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
40036f40:	01 00 00 00 	nop                                            <== NOT EXECUTED
  if ( rv == 0 ) {                                                    
    rv = rtems_filesystem_chdir( &loc );                              
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
40036f44:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40036f48:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  rtems_libio_check_is_open( iop );                                   
                                                                      
  rtems_filesystem_instance_lock( &iop->pathinfo );                   
  rv = (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, &st );     
  if ( rv == 0 ) {                                                    
    bool access_ok = rtems_filesystem_check_access(                   
40036f4c:	d4 17 bf ca 	lduh  [ %fp + -54 ], %o2                       <== NOT EXECUTED
40036f50:	d6 17 bf cc 	lduh  [ %fp + -52 ], %o3                       <== NOT EXECUTED
40036f54:	7f ff 5d 5e 	call  4000e4cc <rtems_filesystem_check_access> <== NOT EXECUTED
40036f58:	90 10 20 01 	mov  1, %o0                                    <== NOT EXECUTED
      st.st_mode,                                                     
      st.st_uid,                                                      
      st.st_gid                                                       
    );                                                                
                                                                      
    if ( access_ok ) {                                                
40036f5c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40036f60:	02 80 00 0d 	be  40036f94 <fchdir+0xe0>                     <== NOT EXECUTED
40036f64:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
      rtems_filesystem_location_clone( &loc, &iop->pathinfo );        
40036f68:	7f ff 5b b4 	call  4000de38 <rtems_filesystem_location_clone><== NOT EXECUTED
40036f6c:	90 07 bf a0 	add  %fp, -96, %o0                             <== NOT EXECUTED
                                                                      
static inline void rtems_filesystem_instance_unlock(                  
  const rtems_filesystem_location_info_t *loc                         
)                                                                     
{                                                                     
  const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
40036f70:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        <== NOT EXECUTED
                                                                      
  (*mt_entry->ops->unlock_h)( mt_entry );                             
40036f74:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         <== NOT EXECUTED
40036f78:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           <== NOT EXECUTED
40036f7c:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
40036f80:	01 00 00 00 	nop                                            <== NOT EXECUTED
    }                                                                 
  }                                                                   
  rtems_filesystem_instance_unlock( &iop->pathinfo );                 
                                                                      
  if ( rv == 0 ) {                                                    
    rv = rtems_filesystem_chdir( &loc );                              
40036f84:	7f ff bd 5c 	call  400264f4 <rtems_filesystem_chdir>        <== NOT EXECUTED
40036f88:	90 07 bf a0 	add  %fp, -96, %o0                             <== NOT EXECUTED
40036f8c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40036f90:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
    );                                                                
                                                                      
    if ( access_ok ) {                                                
      rtems_filesystem_location_clone( &loc, &iop->pathinfo );        
    } else {                                                          
      errno = EACCES;                                                 
40036f94:	40 00 11 75 	call  4003b568 <__errno>                       <== NOT EXECUTED
40036f98:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40036f9c:	82 10 20 0d 	mov  0xd, %g1                                  <== NOT EXECUTED
40036fa0:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
                                                                      
static inline void rtems_filesystem_instance_unlock(                  
  const rtems_filesystem_location_info_t *loc                         
)                                                                     
{                                                                     
  const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
40036fa4:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        <== NOT EXECUTED
                                                                      
  (*mt_entry->ops->unlock_h)( mt_entry );                             
40036fa8:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         <== NOT EXECUTED
40036fac:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           <== NOT EXECUTED
40036fb0:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
40036fb4:	01 00 00 00 	nop                                            <== NOT EXECUTED
  if ( rv == 0 ) {                                                    
    rv = rtems_filesystem_chdir( &loc );                              
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
40036fb8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40036fbc:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  st.st_uid = 0;                                                      
  st.st_gid = 0;                                                      
                                                                      
  rtems_libio_check_fd( fd );                                         
  iop = rtems_libio_iop( fd );                                        
  rtems_libio_check_is_open( iop );                                   
40036fc0:	40 00 11 6a 	call  4003b568 <__errno>                       <== NOT EXECUTED
40036fc4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40036fc8:	82 10 20 09 	mov  9, %g1                                    <== NOT EXECUTED
40036fcc:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
40036fd0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40036fd4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
40036fd8:	40 03 71 40 	call  401134d8 <__end+0xaa2c8>                 <== NOT EXECUTED
40036fdc:	40 03 71 34 	call  401134ac <__end+0xaa29c>                 <== NOT EXECUTED
40036fe0:	40 03 71 14 	call  40113430 <__end+0xaa220>                 <== NOT EXECUTED
40036fe4:	40 03 70 f4 	call  401133b4 <__end+0xaa1a4>                 <== NOT EXECUTED
40036fe8:	40 03 70 a0 	call  40113268 <__end+0xaa058>                 <== NOT EXECUTED
40036fec:	40 03 70 88 	call  4011320c <__end+0xa9ffc>                 <== NOT EXECUTED
40036ff0:	40 03 70 88 	call  40113210 <__end+0xaa000>                 <== NOT EXECUTED
40036ff4:	40 03 70 88 	call  40113214 <__end+0xaa004>                 <== NOT EXECUTED
40036ff8:	40 03 70 88 	call  40113218 <__end+0xaa008>                 <== NOT EXECUTED
40036ffc:	40 03 70 88 	call  4011321c <__end+0xaa00c>                 <== NOT EXECUTED
                                                                      

40026a3c <fchmod>: /** * POSIX 1003.1b 5.6.4 - Change File Modes */ int fchmod( int fd, mode_t mode ) {
40026a3c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rv;                                                             
  rtems_libio_t *iop;                                                 
                                                                      
  rtems_libio_check_fd( fd );                                         
40026a40:	03 10 01 90 	sethi  %hi(0x40064000), %g1                    
40026a44:	c2 00 62 20 	ld  [ %g1 + 0x220 ], %g1	! 40064220 <rtems_libio_number_iops>
40026a48:	80 a6 00 01 	cmp  %i0, %g1                                  
40026a4c:	1a 80 00 28 	bcc  40026aec <fchmod+0xb0>                    
40026a50:	03 10 01 a0 	sethi  %hi(0x40068000), %g1                    
  iop = rtems_libio_iop( fd );                                        
40026a54:	fa 00 63 0c 	ld  [ %g1 + 0x30c ], %i5	! 4006830c <rtems_libio_iops>
40026a58:	83 2e 20 03 	sll  %i0, 3, %g1                               
40026a5c:	b1 2e 20 06 	sll  %i0, 6, %i0                               
40026a60:	b0 26 00 01 	sub  %i0, %g1, %i0                             
40026a64:	ba 07 40 18 	add  %i5, %i0, %i5                             
  rtems_libio_check_is_open(iop);                                     
40026a68:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
40026a6c:	80 88 61 00 	btst  0x100, %g1                               
40026a70:	02 80 00 1f 	be  40026aec <fchmod+0xb0>                     
40026a74:	01 00 00 00 	nop                                            
                                                                      
  if (iop->pathinfo.mt_entry->writeable) {                            
40026a78:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
40026a7c:	c2 0a 20 29 	ldub  [ %o0 + 0x29 ], %g1                      
40026a80:	80 a0 60 00 	cmp  %g1, 0                                    
40026a84:	02 80 00 14 	be  40026ad4 <fchmod+0x98>                     <== NEVER TAKEN
40026a88:	01 00 00 00 	nop                                            
  const rtems_filesystem_location_info_t *loc                         
)                                                                     
{                                                                     
  const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
                                                                      
  (*mt_entry->ops->lock_h)( mt_entry );                               
40026a8c:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
40026a90:	c2 00 40 00 	ld  [ %g1 ], %g1                               
40026a94:	9f c0 40 00 	call  %g1                                      
40026a98:	01 00 00 00 	nop                                            
    rtems_filesystem_instance_lock( &iop->pathinfo );                 
    rv = (*iop->pathinfo.mt_entry->ops->fchmod_h)( &iop->pathinfo, mode );
40026a9c:	c2 07 60 28 	ld  [ %i5 + 0x28 ], %g1                        
40026aa0:	90 07 60 14 	add  %i5, 0x14, %o0                            
40026aa4:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
40026aa8:	c2 00 60 20 	ld  [ %g1 + 0x20 ], %g1                        
40026aac:	9f c0 40 00 	call  %g1                                      
40026ab0:	92 10 00 19 	mov  %i1, %o1                                  
40026ab4:	b0 10 00 08 	mov  %o0, %i0                                  
                                                                      
static inline void rtems_filesystem_instance_unlock(                  
  const rtems_filesystem_location_info_t *loc                         
)                                                                     
{                                                                     
  const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
40026ab8:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
                                                                      
  (*mt_entry->ops->unlock_h)( mt_entry );                             
40026abc:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
40026ac0:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
40026ac4:	9f c0 40 00 	call  %g1                                      
40026ac8:	01 00 00 00 	nop                                            
40026acc:	81 c7 e0 08 	ret                                            
40026ad0:	81 e8 00 00 	restore                                        
    rtems_filesystem_instance_unlock( &iop->pathinfo );               
  } else {                                                            
    errno = EROFS;                                                    
40026ad4:	40 00 52 a5 	call  4003b568 <__errno>                       <== NOT EXECUTED
40026ad8:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40026adc:	82 10 20 1e 	mov  0x1e, %g1                                 <== NOT EXECUTED
40026ae0:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
40026ae4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40026ae8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  int rv;                                                             
  rtems_libio_t *iop;                                                 
                                                                      
  rtems_libio_check_fd( fd );                                         
  iop = rtems_libio_iop( fd );                                        
  rtems_libio_check_is_open(iop);                                     
40026aec:	40 00 52 9f 	call  4003b568 <__errno>                       
40026af0:	b0 10 3f ff 	mov  -1, %i0                                   
40026af4:	82 10 20 09 	mov  9, %g1                                    
40026af8:	c2 22 00 00 	st  %g1, [ %o0 ]                               
40026afc:	81 c7 e0 08 	ret                                            
40026b00:	81 e8 00 00 	restore                                        
                                                                      

40026b04 <fchown>: /** * POSIX 1003.1b 5.6.5 - Change Owner and Group of a File */ int fchown( int fd, uid_t owner, gid_t group ) {
40026b04:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rv = 0;                                                         
  rtems_libio_t *iop;                                                 
                                                                      
  rtems_libio_check_fd( fd );                                         
40026b08:	03 10 01 90 	sethi  %hi(0x40064000), %g1                    
40026b0c:	c2 00 62 20 	ld  [ %g1 + 0x220 ], %g1	! 40064220 <rtems_libio_number_iops>
40026b10:	80 a6 00 01 	cmp  %i0, %g1                                  
40026b14:	1a 80 00 29 	bcc  40026bb8 <fchown+0xb4>                    
40026b18:	03 10 01 a0 	sethi  %hi(0x40068000), %g1                    
  iop = rtems_libio_iop( fd );                                        
40026b1c:	fa 00 63 0c 	ld  [ %g1 + 0x30c ], %i5	! 4006830c <rtems_libio_iops>
40026b20:	83 2e 20 03 	sll  %i0, 3, %g1                               
40026b24:	b1 2e 20 06 	sll  %i0, 6, %i0                               
40026b28:	b0 26 00 01 	sub  %i0, %g1, %i0                             
40026b2c:	ba 07 40 18 	add  %i5, %i0, %i5                             
  rtems_libio_check_is_open(iop);                                     
40026b30:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
40026b34:	80 88 61 00 	btst  0x100, %g1                               
40026b38:	02 80 00 20 	be  40026bb8 <fchown+0xb4>                     
40026b3c:	01 00 00 00 	nop                                            
                                                                      
  if (iop->pathinfo.mt_entry->writeable) {                            
40026b40:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
40026b44:	c2 0a 20 29 	ldub  [ %o0 + 0x29 ], %g1                      
40026b48:	80 a0 60 00 	cmp  %g1, 0                                    
40026b4c:	02 80 00 15 	be  40026ba0 <fchown+0x9c>                     <== NEVER TAKEN
40026b50:	01 00 00 00 	nop                                            
  const rtems_filesystem_location_info_t *loc                         
)                                                                     
{                                                                     
  const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
                                                                      
  (*mt_entry->ops->lock_h)( mt_entry );                               
40026b54:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
40026b58:	c2 00 40 00 	ld  [ %g1 ], %g1                               
40026b5c:	9f c0 40 00 	call  %g1                                      
40026b60:	01 00 00 00 	nop                                            
    rtems_filesystem_instance_lock( &iop->pathinfo );                 
    rv = (*iop->pathinfo.mt_entry->ops->chown_h)(                     
40026b64:	c2 07 60 28 	ld  [ %i5 + 0x28 ], %g1                        
40026b68:	90 07 60 14 	add  %i5, 0x14, %o0                            
40026b6c:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
40026b70:	92 10 00 19 	mov  %i1, %o1                                  
40026b74:	c2 00 60 24 	ld  [ %g1 + 0x24 ], %g1                        
40026b78:	9f c0 40 00 	call  %g1                                      
40026b7c:	94 10 00 1a 	mov  %i2, %o2                                  
40026b80:	b0 10 00 08 	mov  %o0, %i0                                  
                                                                      
static inline void rtems_filesystem_instance_unlock(                  
  const rtems_filesystem_location_info_t *loc                         
)                                                                     
{                                                                     
  const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
40026b84:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
                                                                      
  (*mt_entry->ops->unlock_h)( mt_entry );                             
40026b88:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
40026b8c:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
40026b90:	9f c0 40 00 	call  %g1                                      
40026b94:	01 00 00 00 	nop                                            
40026b98:	81 c7 e0 08 	ret                                            
40026b9c:	81 e8 00 00 	restore                                        
      owner,                                                          
      group                                                           
    );                                                                
    rtems_filesystem_instance_unlock( &iop->pathinfo );               
  } else {                                                            
    errno = EROFS;                                                    
40026ba0:	40 00 52 72 	call  4003b568 <__errno>                       <== NOT EXECUTED
40026ba4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40026ba8:	82 10 20 1e 	mov  0x1e, %g1                                 <== NOT EXECUTED
40026bac:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
40026bb0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40026bb4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  int rv = 0;                                                         
  rtems_libio_t *iop;                                                 
                                                                      
  rtems_libio_check_fd( fd );                                         
  iop = rtems_libio_iop( fd );                                        
  rtems_libio_check_is_open(iop);                                     
40026bb8:	40 00 52 6c 	call  4003b568 <__errno>                       
40026bbc:	b0 10 3f ff 	mov  -1, %i0                                   
40026bc0:	82 10 20 09 	mov  9, %g1                                    
40026bc4:	c2 22 00 00 	st  %g1, [ %o0 ]                               
40026bc8:	81 c7 e0 08 	ret                                            
40026bcc:	81 e8 00 00 	restore                                        
                                                                      

40032f8c <fcntl>: int fcntl( int fd, int cmd, ... ) {
40032f8c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  int            fd2;                                                 
  int            flags;                                               
  int            mask;                                                
  int            ret = 0;                                             
                                                                      
  rtems_libio_check_fd( fd );                                         
40032f90:	03 10 00 e4 	sethi  %hi(0x40039000), %g1                    
40032f94:	c4 00 61 ac 	ld  [ %g1 + 0x1ac ], %g2	! 400391ac <rtems_libio_number_iops>
  ...                                                                 
)                                                                     
{                                                                     
  int            ret;                                                 
  va_list        ap;                                                  
  va_start( ap, cmd );                                                
40032f98:	f4 27 a0 4c 	st  %i2, [ %fp + 0x4c ]                        
40032f9c:	82 07 a0 4c 	add  %fp, 0x4c, %g1                            
40032fa0:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]                        
40032fa4:	f8 27 a0 54 	st  %i4, [ %fp + 0x54 ]                        
40032fa8:	fa 27 a0 58 	st  %i5, [ %fp + 0x58 ]                        
  int            fd2;                                                 
  int            flags;                                               
  int            mask;                                                
  int            ret = 0;                                             
                                                                      
  rtems_libio_check_fd( fd );                                         
40032fac:	80 a6 00 02 	cmp  %i0, %g2                                  
40032fb0:	1a 80 00 7c 	bcc  400331a0 <fcntl+0x214>                    
40032fb4:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
  iop = rtems_libio_iop( fd );                                        
40032fb8:	39 10 01 27 	sethi  %hi(0x40049c00), %i4                    
40032fbc:	fa 07 20 90 	ld  [ %i4 + 0x90 ], %i5	! 40049c90 <rtems_libio_iops>
40032fc0:	85 2e 20 03 	sll  %i0, 3, %g2                               
40032fc4:	b1 2e 20 06 	sll  %i0, 6, %i0                               
40032fc8:	b0 26 00 02 	sub  %i0, %g2, %i0                             
40032fcc:	ba 07 40 18 	add  %i5, %i0, %i5                             
  rtems_libio_check_is_open(iop);                                     
40032fd0:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        
40032fd4:	80 8a 21 00 	btst  0x100, %o0                               
40032fd8:	02 80 00 72 	be  400331a0 <fcntl+0x214>                     
40032fdc:	80 a6 60 09 	cmp  %i1, 9                                    
                                                                      
  /*                                                                  
   *  This switch should contain all the cases from POSIX.            
   */                                                                 
                                                                      
  switch ( cmd ) {                                                    
40032fe0:	08 80 00 08 	bleu  40033000 <fcntl+0x74>                    
40032fe4:	85 2e 60 02 	sll  %i1, 2, %g2                               
      errno = ENOTSUP;                                                
      ret = -1;                                                       
      break;                                                          
                                                                      
    default:                                                          
      errno = EINVAL;                                                 
40032fe8:	7f ff be 54 	call  40022938 <__errno>                       
40032fec:	b0 10 3f ff 	mov  -1, %i0                                   
40032ff0:	82 10 20 16 	mov  0x16, %g1                                 
40032ff4:	c2 22 00 00 	st  %g1, [ %o0 ]                               
  va_list        ap;                                                  
  va_start( ap, cmd );                                                
  ret = vfcntl(fd,cmd,ap);                                            
  va_end(ap);                                                         
  return ret;                                                         
}                                                                     
40032ff8:	81 c7 e0 08 	ret                                            
40032ffc:	81 e8 00 00 	restore                                        
                                                                      
  /*                                                                  
   *  This switch should contain all the cases from POSIX.            
   */                                                                 
                                                                      
  switch ( cmd ) {                                                    
40033000:	07 10 00 cb 	sethi  %hi(0x40032c00), %g3                    
40033004:	86 10 e3 64 	or  %g3, 0x364, %g3	! 40032f64 <_calloc_r+0x14>
40033008:	c4 00 c0 02 	ld  [ %g3 + %g2 ], %g2                         
4003300c:	81 c0 80 00 	jmp  %g2                                       
40033010:	01 00 00 00 	nop                                            
      errno = ENOTSUP;                                                
      ret = -1;                                                       
      break;                                                          
                                                                      
    case F_GETOWN:       /*  for sockets. */                          
      errno = ENOTSUP;                                                
40033014:	7f ff be 49 	call  40022938 <__errno>                       
40033018:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <LEON_REG+0x7fffffff>  
4003301c:	82 10 20 86 	mov  0x86, %g1                                 
40033020:	c2 22 00 00 	st  %g1, [ %o0 ]                               
40033024:	81 c7 e0 08 	ret                                            
40033028:	81 e8 00 00 	restore                                        
    case F_GETFL:        /* more flags (cloexec) */                   
      ret = rtems_libio_to_fcntl_flags( iop->flags );                 
      break;                                                          
                                                                      
    case F_SETFL:                                                     
      flags = rtems_libio_fcntl_flags( va_arg( ap, int ) );           
4003302c:	d0 00 40 00 	ld  [ %g1 ], %o0                               
40033030:	7f ff 54 9d 	call  400082a4 <rtems_libio_fcntl_flags>       
40033034:	b0 10 20 00 	clr  %i0                                       
                                                                      
      /*                                                              
       *  XXX If we are turning on append, should we seek to the end? 
       */                                                             
                                                                      
      iop->flags = (iop->flags & ~mask) | (flags & mask);             
40033038:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
4003303c:	90 0a 22 01 	and  %o0, 0x201, %o0                           
40033040:	82 08 7d fe 	and  %g1, -514, %g1                            
40033044:	82 12 00 01 	or  %o0, %g1, %g1                              
40033048:	c2 27 60 10 	st  %g1, [ %i5 + 0x10 ]                        
   *  If we got this far successfully, then we give the optional      
   *  filesystem specific handler a chance to process this.           
   */                                                                 
                                                                      
  if (ret >= 0) {                                                     
    int err = (*iop->pathinfo.handlers->fcntl_h)( iop, cmd );         
4003304c:	c2 07 60 24 	ld  [ %i5 + 0x24 ], %g1                        
40033050:	90 10 00 1d 	mov  %i5, %o0                                  
40033054:	c2 00 60 28 	ld  [ %g1 + 0x28 ], %g1                        
40033058:	9f c0 40 00 	call  %g1                                      
4003305c:	92 10 00 19 	mov  %i1, %o1                                  
    if (err) {                                                        
40033060:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40033064:	02 80 00 53 	be  400331b0 <fcntl+0x224>                     <== ALWAYS TAKEN
40033068:	01 00 00 00 	nop                                            
      errno = err;                                                    
4003306c:	7f ff be 33 	call  40022938 <__errno>                       <== NOT EXECUTED
40033070:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <LEON_REG+0x7fffffff>  <== NOT EXECUTED
40033074:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
40033078:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4003307c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
      else                                                            
        iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;                     
      break;                                                          
                                                                      
    case F_GETFL:        /* more flags (cloexec) */                   
      ret = rtems_libio_to_fcntl_flags( iop->flags );                 
40033080:	7f ff 54 96 	call  400082d8 <rtems_libio_to_fcntl_flags>    
40033084:	01 00 00 00 	nop                                            
40033088:	b0 10 00 08 	mov  %o0, %i0                                  
  /*                                                                  
   *  If we got this far successfully, then we give the optional      
   *  filesystem specific handler a chance to process this.           
   */                                                                 
                                                                      
  if (ret >= 0) {                                                     
4003308c:	80 a6 20 00 	cmp  %i0, 0                                    
40033090:	36 bf ff f0 	bge,a   40033050 <fcntl+0xc4>                  <== ALWAYS TAKEN
40033094:	c2 07 60 24 	ld  [ %i5 + 0x24 ], %g1                        
  va_list        ap;                                                  
  va_start( ap, cmd );                                                
  ret = vfcntl(fd,cmd,ap);                                            
  va_end(ap);                                                         
  return ret;                                                         
}                                                                     
40033098:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4003309c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
       *  if a new process is exec()'ed.  Since RTEMS does not support
       *  processes, then we can ignore this one except to make       
       *  F_GETFD work.                                               
       */                                                             
                                                                      
      if ( va_arg( ap, int ) )                                        
400330a0:	c2 00 40 00 	ld  [ %g1 ], %g1                               
400330a4:	80 a0 60 00 	cmp  %g1, 0                                    
400330a8:	22 80 00 3b 	be,a   40033194 <fcntl+0x208>                  
400330ac:	90 0a 37 ff 	and  %o0, -2049, %o0                           
        iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;                      
400330b0:	90 12 28 00 	or  %o0, 0x800, %o0                            
{                                                                     
  rtems_libio_t *iop;                                                 
  int            fd2;                                                 
  int            flags;                                               
  int            mask;                                                
  int            ret = 0;                                             
400330b4:	b0 10 20 00 	clr  %i0                                       
       *  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;                      
400330b8:	10 bf ff e5 	b  4003304c <fcntl+0xc0>                       
400330bc:	d0 27 60 10 	st  %o0, [ %i5 + 0x10 ]                        
      fd2 = va_arg( ap, int );                                        
      ret = duplicate_iop( iop, fd2 );                                
      break;                                                          
                                                                      
    case F_GETFD:        /* get f_flags */                            
      ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0);          
400330c0:	b1 32 20 0b 	srl  %o0, 0xb, %i0                             
400330c4:	10 bf ff e2 	b  4003304c <fcntl+0xc0>                       
400330c8:	b0 0e 20 01 	and  %i0, 1, %i0                               
                                                                      
  /*                                                                  
   * FIXME: We ignore the start value fd2 for the file descriptor search.  This
   * is not POSIX conform.                                            
   */                                                                 
  rtems_libio_t *diop = rtems_libio_allocate();                       
400330cc:	7f ff 54 9a 	call  40008334 <rtems_libio_allocate>          
400330d0:	01 00 00 00 	nop                                            
                                                                      
  if (diop != NULL) {                                                 
400330d4:	b6 92 20 00 	orcc  %o0, 0, %i3                              
400330d8:	02 bf ff c8 	be  40032ff8 <fcntl+0x6c>                      
400330dc:	b0 10 3f ff 	mov  -1, %i0                                   
    int oflag = rtems_libio_to_fcntl_flags( iop->flags );             
400330e0:	7f ff 54 7e 	call  400082d8 <rtems_libio_to_fcntl_flags>    
400330e4:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        
                                                                      
    oflag &= ~O_CREAT;                                                
    diop->flags |= rtems_libio_fcntl_flags( oflag );                  
400330e8:	f0 06 e0 10 	ld  [ %i3 + 0x10 ], %i0                        
  rtems_libio_t *diop = rtems_libio_allocate();                       
                                                                      
  if (diop != NULL) {                                                 
    int oflag = rtems_libio_to_fcntl_flags( iop->flags );             
                                                                      
    oflag &= ~O_CREAT;                                                
400330ec:	b4 0a 3d ff 	and  %o0, -513, %i2                            
    diop->flags |= rtems_libio_fcntl_flags( oflag );                  
400330f0:	7f ff 54 6d 	call  400082a4 <rtems_libio_fcntl_flags>       
400330f4:	90 10 00 1a 	mov  %i2, %o0                                  
                                                                      
static inline void rtems_filesystem_instance_lock(                    
  const rtems_filesystem_location_info_t *loc                         
)                                                                     
{                                                                     
  const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
400330f8:	c2 07 60 28 	ld  [ %i5 + 0x28 ], %g1                        
400330fc:	b0 12 00 18 	or  %o0, %i0, %i0                              
                                                                      
  (*mt_entry->ops->lock_h)( mt_entry );                               
40033100:	c4 00 60 0c 	ld  [ %g1 + 0xc ], %g2                         
40033104:	90 10 00 01 	mov  %g1, %o0                                  
40033108:	c2 00 80 00 	ld  [ %g2 ], %g1                               
4003310c:	9f c0 40 00 	call  %g1                                      
40033110:	f0 26 e0 10 	st  %i0, [ %i3 + 0x10 ]                        
                                                                      
    rtems_filesystem_instance_lock( &iop->pathinfo );                 
    rtems_filesystem_location_clone( &diop->pathinfo, &iop->pathinfo );
40033114:	92 07 60 14 	add  %i5, 0x14, %o1                            
40033118:	7f ff 91 ac 	call  400177c8 <rtems_filesystem_location_clone>
4003311c:	90 06 e0 14 	add  %i3, 0x14, %o0                            
                                                                      
static inline void rtems_filesystem_instance_unlock(                  
  const rtems_filesystem_location_info_t *loc                         
)                                                                     
{                                                                     
  const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
40033120:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
                                                                      
  (*mt_entry->ops->unlock_h)( mt_entry );                             
40033124:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
40033128:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
4003312c:	9f c0 40 00 	call  %g1                                      
40033130:	01 00 00 00 	nop                                            
    /*                                                                
     * XXX: We call the open handler here to have a proper open and close pair.
     *                                                                
     * FIXME: What to do with the path?                               
     */                                                               
    rv = (*diop->pathinfo.handlers->open_h)( diop, NULL, oflag, 0 );  
40033134:	c2 06 e0 24 	ld  [ %i3 + 0x24 ], %g1                        
40033138:	90 10 00 1b 	mov  %i3, %o0                                  
4003313c:	c2 00 40 00 	ld  [ %g1 ], %g1                               
40033140:	92 10 20 00 	clr  %o1                                       
40033144:	94 10 00 1a 	mov  %i2, %o2                                  
40033148:	9f c0 40 00 	call  %g1                                      
4003314c:	96 10 20 00 	clr  %o3                                       
    if ( rv == 0 ) {                                                  
40033150:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40033154:	12 80 00 19 	bne  400331b8 <fcntl+0x22c>                    <== NEVER TAKEN
40033158:	c2 07 20 90 	ld  [ %i4 + 0x90 ], %g1                        
      rv = diop - rtems_libio_iops;                                   
4003315c:	b6 26 c0 01 	sub  %i3, %g1, %i3                             
40033160:	b7 3e e0 03 	sra  %i3, 3, %i3                               
40033164:	85 2e e0 03 	sll  %i3, 3, %g2                               
40033168:	83 2e e0 06 	sll  %i3, 6, %g1                               
4003316c:	82 00 80 01 	add  %g2, %g1, %g1                             
40033170:	85 28 60 06 	sll  %g1, 6, %g2                               
40033174:	82 00 40 02 	add  %g1, %g2, %g1                             
40033178:	82 00 40 1b 	add  %g1, %i3, %g1                             
4003317c:	85 28 60 0f 	sll  %g1, 0xf, %g2                             
40033180:	82 00 40 02 	add  %g1, %g2, %g1                             
40033184:	83 28 60 03 	sll  %g1, 3, %g1                               
40033188:	b6 00 40 1b 	add  %g1, %i3, %i3                             
4003318c:	10 bf ff c0 	b  4003308c <fcntl+0x100>                      
40033190:	b0 20 00 1b 	neg  %i3, %i0                                  
{                                                                     
  rtems_libio_t *iop;                                                 
  int            fd2;                                                 
  int            flags;                                               
  int            mask;                                                
  int            ret = 0;                                             
40033194:	b0 10 20 00 	clr  %i0                                       
       */                                                             
                                                                      
      if ( va_arg( ap, int ) )                                        
        iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;                      
      else                                                            
        iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;                     
40033198:	10 bf ff ad 	b  4003304c <fcntl+0xc0>                       
4003319c:	d0 27 60 10 	st  %o0, [ %i5 + 0x10 ]                        
  int            mask;                                                
  int            ret = 0;                                             
                                                                      
  rtems_libio_check_fd( fd );                                         
  iop = rtems_libio_iop( fd );                                        
  rtems_libio_check_is_open(iop);                                     
400331a0:	7f ff bd e6 	call  40022938 <__errno>                       
400331a4:	b0 10 3f ff 	mov  -1, %i0                                   
400331a8:	82 10 20 09 	mov  9, %g1                                    
400331ac:	c2 22 00 00 	st  %g1, [ %o0 ]                               
400331b0:	81 c7 e0 08 	ret                                            
400331b4:	81 e8 00 00 	restore                                        
     */                                                               
    rv = (*diop->pathinfo.handlers->open_h)( diop, NULL, oflag, 0 );  
    if ( rv == 0 ) {                                                  
      rv = diop - rtems_libio_iops;                                   
    } else {                                                          
      rtems_libio_free( diop );                                       
400331b8:	7f ff 54 75 	call  4000838c <rtems_libio_free>              <== NOT EXECUTED
400331bc:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
  /*                                                                  
   *  If we got this far successfully, then we give the optional      
   *  filesystem specific handler a chance to process this.           
   */                                                                 
                                                                      
  if (ret >= 0) {                                                     
400331c0:	10 bf ff b4 	b  40033090 <fcntl+0x104>                      <== NOT EXECUTED
400331c4:	80 a6 20 00 	cmp  %i0, 0                                    <== NOT EXECUTED
                                                                      

40003a0c <fdatasync>: #include <rtems/seterr.h> int fdatasync( int fd ) {
40003a0c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_libio_t *iop;                                                 
                                                                      
  rtems_libio_check_fd( fd );                                         
40003a10:	03 10 00 5b 	sethi  %hi(0x40016c00), %g1                    
40003a14:	c2 00 62 c4 	ld  [ %g1 + 0x2c4 ], %g1	! 40016ec4 <rtems_libio_number_iops>
40003a18:	80 a6 00 01 	cmp  %i0, %g1                                  
40003a1c:	1a 80 00 13 	bcc  40003a68 <fdatasync+0x5c>                 
40003a20:	03 10 00 5e 	sethi  %hi(0x40017800), %g1                    
  iop = rtems_libio_iop( fd );                                        
40003a24:	d0 00 60 1c 	ld  [ %g1 + 0x1c ], %o0	! 4001781c <rtems_libio_iops>
40003a28:	83 2e 20 03 	sll  %i0, 3, %g1                               
40003a2c:	b1 2e 20 06 	sll  %i0, 6, %i0                               
40003a30:	b0 26 00 01 	sub  %i0, %g1, %i0                             
40003a34:	90 02 00 18 	add  %o0, %i0, %o0                             
  rtems_libio_check_is_open(iop);                                     
40003a38:	c2 02 20 10 	ld  [ %o0 + 0x10 ], %g1                        
40003a3c:	80 88 61 00 	btst  0x100, %g1                               
40003a40:	02 80 00 0a 	be  40003a68 <fdatasync+0x5c>                  <== NEVER TAKEN
40003a44:	80 88 60 04 	btst  4, %g1                                   
  rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
40003a48:	02 80 00 08 	be  40003a68 <fdatasync+0x5c>                  
40003a4c:	01 00 00 00 	nop                                            
                                                                      
  /*                                                                  
   *  Now process the fdatasync().                                    
   */                                                                 
                                                                      
  return (*iop->pathinfo.handlers->fdatasync_h)( iop );               
40003a50:	c2 02 20 24 	ld  [ %o0 + 0x24 ], %g1                        
40003a54:	c2 00 60 24 	ld  [ %g1 + 0x24 ], %g1                        
40003a58:	9f c0 40 00 	call  %g1                                      
40003a5c:	01 00 00 00 	nop                                            
}                                                                     
40003a60:	81 c7 e0 08 	ret                                            
40003a64:	91 e8 00 08 	restore  %g0, %o0, %o0                         
  rtems_libio_t *iop;                                                 
                                                                      
  rtems_libio_check_fd( fd );                                         
  iop = rtems_libio_iop( fd );                                        
  rtems_libio_check_is_open(iop);                                     
  rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
40003a68:	40 00 32 55 	call  400103bc <__errno>                       
40003a6c:	b0 10 3f ff 	mov  -1, %i0                                   
40003a70:	82 10 20 09 	mov  9, %g1                                    
40003a74:	c2 22 00 00 	st  %g1, [ %o0 ]                               
40003a78:	81 c7 e0 08 	ret                                            
40003a7c:	81 e8 00 00 	restore                                        
                                                                      

4000db00 <fifo_open>: int fifo_open( pipe_control_t **pipep, rtems_libio_t *iop ) {
4000db00:	9d e3 bf 98 	save  %sp, -104, %sp                           
                                                                      
static int pipe_lock(void)                                            
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  if (pipe_semaphore == RTEMS_ID_NONE) {                              
4000db04:	3b 10 00 8e 	sethi  %hi(0x40023800), %i5                    
4000db08:	d0 07 60 98 	ld  [ %i5 + 0x98 ], %o0	! 40023898 <pipe_semaphore>
                                                                      
int fifo_open(                                                        
  pipe_control_t **pipep,                                             
  rtems_libio_t *iop                                                  
)                                                                     
{                                                                     
4000db0c:	b6 10 00 18 	mov  %i0, %i3                                  
                                                                      
static int pipe_lock(void)                                            
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  if (pipe_semaphore == RTEMS_ID_NONE) {                              
4000db10:	80 a2 20 00 	cmp  %o0, 0                                    
4000db14:	02 80 00 18 	be  4000db74 <fifo_open+0x74>                  
4000db18:	b8 17 60 98 	or  %i5, 0x98, %i4                             
                                                                      
    rtems_libio_unlock();                                             
  }                                                                   
                                                                      
  if (sc == RTEMS_SUCCESSFUL) {                                       
    sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
4000db1c:	92 10 20 00 	clr  %o1                                       
4000db20:	7f ff eb d9 	call  40008a84 <rtems_semaphore_obtain>        
4000db24:	94 10 20 00 	clr  %o2                                       
  }                                                                   
                                                                      
  if (sc == RTEMS_SUCCESSFUL) {                                       
4000db28:	80 a2 20 00 	cmp  %o0, 0                                    
4000db2c:	12 80 00 7a 	bne  4000dd14 <fifo_open+0x214>                <== NEVER TAKEN
4000db30:	01 00 00 00 	nop                                            
                                                                      
  err = pipe_lock();                                                  
  if (err)                                                            
    return err;                                                       
                                                                      
  pipe = *pipep;                                                      
4000db34:	f8 06 c0 00 	ld  [ %i3 ], %i4                               
  if (pipe == NULL) {                                                 
4000db38:	80 a7 20 00 	cmp  %i4, 0                                    
4000db3c:	02 80 00 1b 	be  4000dba8 <fifo_open+0xa8>                  
4000db40:	01 00 00 00 	nop                                            
    err = pipe_alloc(&pipe);                                          
    if (err)                                                          
      goto out;                                                       
  }                                                                   
                                                                      
  if (! PIPE_LOCK(pipe))                                              
4000db44:	d0 07 20 28 	ld  [ %i4 + 0x28 ], %o0                        
4000db48:	92 10 20 00 	clr  %o1                                       
4000db4c:	7f ff eb ce 	call  40008a84 <rtems_semaphore_obtain>        
4000db50:	94 10 20 00 	clr  %o2                                       
4000db54:	80 a2 20 00 	cmp  %o0, 0                                    
4000db58:	02 80 00 8c 	be  4000dd88 <fifo_open+0x288>                 <== ALWAYS TAKEN
4000db5c:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
    err = -EINTR;                                                     
                                                                      
  if (*pipep == NULL) {                                               
4000db60:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4000db64:	22 80 00 6e 	be,a   4000dd1c <fifo_open+0x21c>              <== NOT EXECUTED
4000db68:	d0 07 20 2c 	ld  [ %i4 + 0x2c ], %o0                        <== NOT EXECUTED
    if (err)                                                          
      goto out;                                                       
  }                                                                   
                                                                      
  if (! PIPE_LOCK(pipe))                                              
    err = -EINTR;                                                     
4000db6c:	10 80 00 76 	b  4000dd44 <fifo_open+0x244>                  <== NOT EXECUTED
4000db70:	b0 10 3f fc 	mov  -4, %i0                                   <== NOT EXECUTED
 */                                                                   
#include <rtems/userenv.h>                                            
                                                                      
static inline void rtems_libio_lock( void )                           
{                                                                     
  rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
4000db74:	35 10 00 8e 	sethi  %hi(0x40023800), %i2                    
4000db78:	d0 06 a2 18 	ld  [ %i2 + 0x218 ], %o0	! 40023a18 <rtems_libio_semaphore>
4000db7c:	92 10 20 00 	clr  %o1                                       
4000db80:	7f ff eb c1 	call  40008a84 <rtems_semaphore_obtain>        
4000db84:	94 10 20 00 	clr  %o2                                       
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  if (pipe_semaphore == RTEMS_ID_NONE) {                              
    rtems_libio_lock();                                               
                                                                      
    if (pipe_semaphore == RTEMS_ID_NONE) {                            
4000db88:	c2 07 60 98 	ld  [ %i5 + 0x98 ], %g1                        
4000db8c:	80 a0 60 00 	cmp  %g1, 0                                    
4000db90:	02 80 00 55 	be  4000dce4 <fifo_open+0x1e4>                 <== ALWAYS TAKEN
4000db94:	98 10 00 1c 	mov  %i4, %o4                                  
}                                                                     
                                                                      
static inline void rtems_libio_unlock( void )                         
{                                                                     
  rtems_semaphore_release( rtems_libio_semaphore );                   
4000db98:	7f ff ec 0a 	call  40008bc0 <rtems_semaphore_release>       <== NOT EXECUTED
4000db9c:	d0 06 a2 18 	ld  [ %i2 + 0x218 ], %o0                       <== NOT EXECUTED
4000dba0:	10 bf ff df 	b  4000db1c <fifo_open+0x1c>                   <== NOT EXECUTED
4000dba4:	d0 07 60 98 	ld  [ %i5 + 0x98 ], %o0                        <== NOT EXECUTED
{                                                                     
  static char c = 'a';                                                
  pipe_control_t *pipe;                                               
  int err = -ENOMEM;                                                  
                                                                      
  pipe = malloc(sizeof(pipe_control_t));                              
4000dba8:	7f ff da 71 	call  4000456c <malloc>                        
4000dbac:	90 10 20 34 	mov  0x34, %o0                                 
  if (pipe == NULL)                                                   
4000dbb0:	b8 92 20 00 	orcc  %o0, 0, %i4                              
4000dbb4:	02 80 00 73 	be  4000dd80 <fifo_open+0x280>                 <== NEVER TAKEN
4000dbb8:	82 10 22 00 	mov  0x200, %g1                                
    return err;                                                       
  memset(pipe, 0, sizeof(pipe_control_t));                            
4000dbbc:	c0 27 00 00 	clr  [ %i4 ]                                   
4000dbc0:	c0 27 20 08 	clr  [ %i4 + 8 ]                               
4000dbc4:	c0 27 20 0c 	clr  [ %i4 + 0xc ]                             
4000dbc8:	c0 27 20 10 	clr  [ %i4 + 0x10 ]                            
4000dbcc:	c0 27 20 14 	clr  [ %i4 + 0x14 ]                            
4000dbd0:	c0 27 20 18 	clr  [ %i4 + 0x18 ]                            
4000dbd4:	c0 27 20 1c 	clr  [ %i4 + 0x1c ]                            
4000dbd8:	c0 27 20 20 	clr  [ %i4 + 0x20 ]                            
4000dbdc:	c0 27 20 24 	clr  [ %i4 + 0x24 ]                            
4000dbe0:	c0 27 20 28 	clr  [ %i4 + 0x28 ]                            
4000dbe4:	c0 27 20 2c 	clr  [ %i4 + 0x2c ]                            
4000dbe8:	c0 27 20 30 	clr  [ %i4 + 0x30 ]                            
                                                                      
  pipe->Size = PIPE_BUF;                                              
  pipe->Buffer = malloc(pipe->Size);                                  
4000dbec:	90 10 22 00 	mov  0x200, %o0                                
4000dbf0:	7f ff da 5f 	call  4000456c <malloc>                        
4000dbf4:	c2 27 20 04 	st  %g1, [ %i4 + 4 ]                           
  if (! pipe->Buffer)                                                 
4000dbf8:	80 a2 20 00 	cmp  %o0, 0                                    
4000dbfc:	02 80 00 5f 	be  4000dd78 <fifo_open+0x278>                 <== NEVER TAKEN
4000dc00:	d0 27 00 00 	st  %o0, [ %i4 ]                               
    goto err_buf;                                                     
                                                                      
  err = -ENOMEM;                                                      
                                                                      
  if (rtems_barrier_create(                                           
        rtems_build_name ('P', 'I', 'r', c),                          
4000dc04:	35 10 00 8c 	sethi  %hi(0x40023000), %i2                    
4000dc08:	d0 4e a1 8c 	ldsb  [ %i2 + 0x18c ], %o0	! 4002318c <c.7174> 
  if (! pipe->Buffer)                                                 
    goto err_buf;                                                     
                                                                      
  err = -ENOMEM;                                                      
                                                                      
  if (rtems_barrier_create(                                           
4000dc0c:	31 14 12 5c 	sethi  %hi(0x50497000), %i0                    
4000dc10:	82 16 22 00 	or  %i0, 0x200, %g1	! 50497200 <RAM_END+0x10097200>
4000dc14:	92 10 20 00 	clr  %o1                                       
4000dc18:	94 10 20 00 	clr  %o2                                       
4000dc1c:	90 12 00 01 	or  %o0, %g1, %o0                              
4000dc20:	40 00 06 29 	call  4000f4c4 <rtems_barrier_create>          
4000dc24:	96 07 20 2c 	add  %i4, 0x2c, %o3                            
4000dc28:	80 a2 20 00 	cmp  %o0, 0                                    
4000dc2c:	12 80 00 51 	bne  4000dd70 <fifo_open+0x270>                
4000dc30:	d0 4e a1 8c 	ldsb  [ %i2 + 0x18c ], %o0                     
        rtems_build_name ('P', 'I', 'r', c),                          
        RTEMS_BARRIER_MANUAL_RELEASE, 0,                              
        &pipe->readBarrier) != RTEMS_SUCCESSFUL)                      
    goto err_rbar;                                                    
  if (rtems_barrier_create(                                           
4000dc34:	03 14 12 5d 	sethi  %hi(0x50497400), %g1                    
4000dc38:	82 10 63 00 	or  %g1, 0x300, %g1	! 50497700 <RAM_END+0x10097700>
4000dc3c:	92 10 20 00 	clr  %o1                                       
4000dc40:	94 10 20 00 	clr  %o2                                       
4000dc44:	90 12 00 01 	or  %o0, %g1, %o0                              
4000dc48:	40 00 06 1f 	call  4000f4c4 <rtems_barrier_create>          
4000dc4c:	96 07 20 30 	add  %i4, 0x30, %o3                            
4000dc50:	80 a2 20 00 	cmp  %o0, 0                                    
4000dc54:	12 80 00 45 	bne  4000dd68 <fifo_open+0x268>                
4000dc58:	d0 4e a1 8c 	ldsb  [ %i2 + 0x18c ], %o0                     
        rtems_build_name ('P', 'I', 'w', c),                          
        RTEMS_BARRIER_MANUAL_RELEASE, 0,                              
        &pipe->writeBarrier) != RTEMS_SUCCESSFUL)                     
    goto err_wbar;                                                    
  if (rtems_semaphore_create(                                         
4000dc5c:	b0 16 23 00 	or  %i0, 0x300, %i0                            
4000dc60:	92 10 20 01 	mov  1, %o1                                    
4000dc64:	90 12 00 18 	or  %o0, %i0, %o0                              
4000dc68:	94 10 20 10 	mov  0x10, %o2                                 
4000dc6c:	96 10 20 00 	clr  %o3                                       
4000dc70:	7f ff ea dd 	call  400087e4 <rtems_semaphore_create>        
4000dc74:	98 07 20 28 	add  %i4, 0x28, %o4                            
4000dc78:	80 a2 20 00 	cmp  %o0, 0                                    
4000dc7c:	12 80 00 39 	bne  4000dd60 <fifo_open+0x260>                
4000dc80:	94 07 bf fc 	add  %fp, -4, %o2                              
RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get (                  
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (Barrier_Control *)                                          
4000dc84:	d2 07 20 2c 	ld  [ %i4 + 0x2c ], %o1                        
4000dc88:	21 10 00 91 	sethi  %hi(0x40024400), %l0                    
4000dc8c:	7f ff f2 85 	call  4000a6a0 <_Objects_Get>                  
4000dc90:	90 14 20 b0 	or  %l0, 0xb0, %o0	! 400244b0 <_Barrier_Information>
static void pipe_interruptible(pipe_control_t *pipe)                  
{                                                                     
  Objects_Locations location;                                         
                                                                      
  _Barrier_Get(pipe->readBarrier, &location)->Barrier.Wait_queue.state
    |= STATES_INTERRUPTIBLE_BY_SIGNAL;                                
4000dc94:	c2 02 20 4c 	ld  [ %o0 + 0x4c ], %g1                        
4000dc98:	31 04 00 00 	sethi  %hi(0x10000000), %i0                    
4000dc9c:	82 10 40 18 	or  %g1, %i0, %g1                              
  _Thread_Enable_dispatch();                                          
4000dca0:	7f ff f6 37 	call  4000b57c <_Thread_Enable_dispatch>       
4000dca4:	c2 22 20 4c 	st  %g1, [ %o0 + 0x4c ]                        
4000dca8:	d2 07 20 30 	ld  [ %i4 + 0x30 ], %o1                        
4000dcac:	94 07 bf fc 	add  %fp, -4, %o2                              
4000dcb0:	7f ff f2 7c 	call  4000a6a0 <_Objects_Get>                  
4000dcb4:	90 14 20 b0 	or  %l0, 0xb0, %o0                             
  _Barrier_Get(pipe->writeBarrier, &location)->Barrier.Wait_queue.state
    |= STATES_INTERRUPTIBLE_BY_SIGNAL;                                
4000dcb8:	c2 02 20 4c 	ld  [ %o0 + 0x4c ], %g1                        
4000dcbc:	b0 10 40 18 	or  %g1, %i0, %i0                              
  _Thread_Enable_dispatch();                                          
4000dcc0:	7f ff f6 2f 	call  4000b57c <_Thread_Enable_dispatch>       
4000dcc4:	f0 22 20 4c 	st  %i0, [ %o0 + 0x4c ]                        
#ifdef RTEMS_POSIX_API                                                
  pipe_interruptible(pipe);                                           
#endif                                                                
                                                                      
  *pipep = pipe;                                                      
  if (c ++ == 'z')                                                    
4000dcc8:	c2 4e a1 8c 	ldsb  [ %i2 + 0x18c ], %g1                     
4000dccc:	80 a0 60 7a 	cmp  %g1, 0x7a                                 
4000dcd0:	02 80 00 21 	be  4000dd54 <fifo_open+0x254>                 
4000dcd4:	c4 0e a1 8c 	ldub  [ %i2 + 0x18c ], %g2                     
4000dcd8:	84 00 a0 01 	inc  %g2                                       
4000dcdc:	10 bf ff 9a 	b  4000db44 <fifo_open+0x44>                   
4000dce0:	c4 2e a1 8c 	stb  %g2, [ %i2 + 0x18c ]                      
                                                                      
  if (pipe_semaphore == RTEMS_ID_NONE) {                              
    rtems_libio_lock();                                               
                                                                      
    if (pipe_semaphore == RTEMS_ID_NONE) {                            
      sc = rtems_semaphore_create(                                    
4000dce4:	92 10 20 01 	mov  1, %o1                                    
4000dce8:	94 10 20 54 	mov  0x54, %o2                                 
4000dcec:	96 10 20 00 	clr  %o3                                       
4000dcf0:	11 14 12 54 	sethi  %hi(0x50495000), %o0                    
4000dcf4:	7f ff ea bc 	call  400087e4 <rtems_semaphore_create>        
4000dcf8:	90 12 20 45 	or  %o0, 0x45, %o0	! 50495045 <RAM_END+0x10095045>
4000dcfc:	b8 10 00 08 	mov  %o0, %i4                                  
4000dd00:	7f ff eb b0 	call  40008bc0 <rtems_semaphore_release>       
4000dd04:	d0 06 a2 18 	ld  [ %i2 + 0x218 ], %o0                       
    }                                                                 
                                                                      
    rtems_libio_unlock();                                             
  }                                                                   
                                                                      
  if (sc == RTEMS_SUCCESSFUL) {                                       
4000dd08:	80 a7 20 00 	cmp  %i4, 0                                    
4000dd0c:	02 bf ff 84 	be  4000db1c <fifo_open+0x1c>                  
4000dd10:	d0 07 60 98 	ld  [ %i5 + 0x98 ], %o0                        
      if (pipe->Writers ++ == 0)                                      
        PIPE_WAKEUPREADERS(pipe);                                     
                                                                      
      if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {                 
	PIPE_UNLOCK(pipe);                                                   
        err = -ENXIO;                                                 
4000dd14:	81 c7 e0 08 	ret                                            
4000dd18:	91 e8 3f f4 	restore  %g0, -12, %o0                         
/* Called with pipe_semaphore held. */                                
static inline void pipe_free(                                         
  pipe_control_t *pipe                                                
)                                                                     
{                                                                     
  rtems_barrier_delete(pipe->readBarrier);                            
4000dd1c:	40 00 06 1b 	call  4000f588 <rtems_barrier_delete>          <== NOT EXECUTED
4000dd20:	b0 10 3f fc 	mov  -4, %i0                                   <== NOT EXECUTED
  rtems_barrier_delete(pipe->writeBarrier);                           
4000dd24:	40 00 06 19 	call  4000f588 <rtems_barrier_delete>          <== NOT EXECUTED
4000dd28:	d0 07 20 30 	ld  [ %i4 + 0x30 ], %o0                        <== NOT EXECUTED
  rtems_semaphore_delete(pipe->Semaphore);                            
4000dd2c:	7f ff eb 1f 	call  400089a8 <rtems_semaphore_delete>        <== NOT EXECUTED
4000dd30:	d0 07 20 28 	ld  [ %i4 + 0x28 ], %o0                        <== NOT EXECUTED
  free(pipe->Buffer);                                                 
4000dd34:	7f ff d8 f3 	call  40004100 <free>                          <== NOT EXECUTED
4000dd38:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
  free(pipe);                                                         
4000dd3c:	7f ff d8 f1 	call  40004100 <free>                          <== NOT EXECUTED
4000dd40:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
#ifdef RTEMS_DEBUG                                                    
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  sc =                                                                
#endif                                                                
   rtems_semaphore_release(pipe_semaphore);                           
4000dd44:	7f ff eb 9f 	call  40008bc0 <rtems_semaphore_release>       
4000dd48:	d0 07 60 98 	ld  [ %i5 + 0x98 ], %o0                        
  return 0;                                                           
                                                                      
out_error:                                                            
  pipe_release(pipep, iop);                                           
  return err;                                                         
}                                                                     
4000dd4c:	81 c7 e0 08 	ret                                            
4000dd50:	81 e8 00 00 	restore                                        
  pipe_interruptible(pipe);                                           
#endif                                                                
                                                                      
  *pipep = pipe;                                                      
  if (c ++ == 'z')                                                    
    c = 'a';                                                          
4000dd54:	82 10 20 61 	mov  0x61, %g1                                 
4000dd58:	10 bf ff 7b 	b  4000db44 <fifo_open+0x44>                   
4000dd5c:	c2 2e a1 8c 	stb  %g1, [ %i2 + 0x18c ]                      
  return 0;                                                           
                                                                      
err_sem:                                                              
  rtems_barrier_delete(pipe->writeBarrier);                           
4000dd60:	40 00 06 0a 	call  4000f588 <rtems_barrier_delete>          
4000dd64:	d0 07 20 30 	ld  [ %i4 + 0x30 ], %o0                        
err_wbar:                                                             
  rtems_barrier_delete(pipe->readBarrier);                            
4000dd68:	40 00 06 08 	call  4000f588 <rtems_barrier_delete>          
4000dd6c:	d0 07 20 2c 	ld  [ %i4 + 0x2c ], %o0                        
err_rbar:                                                             
  free(pipe->Buffer);                                                 
4000dd70:	7f ff d8 e4 	call  40004100 <free>                          
4000dd74:	d0 07 00 00 	ld  [ %i4 ], %o0                               
err_buf:                                                              
  free(pipe);                                                         
4000dd78:	7f ff d8 e2 	call  40004100 <free>                          
4000dd7c:	90 10 00 1c 	mov  %i4, %o0                                  
    if (err)                                                          
      goto out;                                                       
  }                                                                   
                                                                      
  if (! PIPE_LOCK(pipe))                                              
    err = -EINTR;                                                     
4000dd80:	10 bf ff f1 	b  4000dd44 <fifo_open+0x244>                  
4000dd84:	b0 10 3f f4 	mov  -12, %i0                                  
                                                                      
  if (*pipep == NULL) {                                               
4000dd88:	80 a0 60 00 	cmp  %g1, 0                                    
4000dd8c:	22 80 00 02 	be,a   4000dd94 <fifo_open+0x294>              
4000dd90:	f8 26 c0 00 	st  %i4, [ %i3 ]                               
#ifdef RTEMS_DEBUG                                                    
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  sc =                                                                
#endif                                                                
   rtems_semaphore_release(pipe_semaphore);                           
4000dd94:	7f ff eb 8b 	call  40008bc0 <rtems_semaphore_release>       
4000dd98:	d0 07 60 98 	ld  [ %i5 + 0x98 ], %o0                        
  err = pipe_new(pipep);                                              
  if (err)                                                            
    return err;                                                       
  pipe = *pipep;                                                      
                                                                      
  switch (LIBIO_ACCMODE(iop)) {                                       
4000dd9c:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1                        
4000dda0:	82 08 60 06 	and  %g1, 6, %g1                               
4000dda4:	80 a0 60 04 	cmp  %g1, 4                                    
4000dda8:	02 80 00 0c 	be  4000ddd8 <fifo_open+0x2d8>                 
4000ddac:	fa 06 c0 00 	ld  [ %i3 ], %i5                               
4000ddb0:	80 a0 60 06 	cmp  %g1, 6                                    
4000ddb4:	02 80 00 58 	be  4000df14 <fifo_open+0x414>                 
4000ddb8:	80 a0 60 02 	cmp  %g1, 2                                    
4000ddbc:	22 80 00 31 	be,a   4000de80 <fifo_open+0x380>              <== ALWAYS TAKEN
4000ddc0:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
      if (pipe->Writers ++ == 0)                                      
        PIPE_WAKEUPREADERS(pipe);                                     
      break;                                                          
  }                                                                   
                                                                      
  PIPE_UNLOCK(pipe);                                                  
4000ddc4:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        <== NOT EXECUTED
4000ddc8:	7f ff eb 7e 	call  40008bc0 <rtems_semaphore_release>       
4000ddcc:	b0 10 20 00 	clr  %i0                                       
  return 0;                                                           
4000ddd0:	81 c7 e0 08 	ret                                            
4000ddd4:	81 e8 00 00 	restore                                        
      break;                                                          
                                                                      
    case LIBIO_FLAGS_WRITE:                                           
      pipe->writerCounter ++;                                         
                                                                      
      if (pipe->Writers ++ == 0)                                      
4000ddd8:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
        } while (prevCounter == pipe->writerCounter);                 
      }                                                               
      break;                                                          
                                                                      
    case LIBIO_FLAGS_WRITE:                                           
      pipe->writerCounter ++;                                         
4000dddc:	c4 07 60 24 	ld  [ %i5 + 0x24 ], %g2                        
                                                                      
      if (pipe->Writers ++ == 0)                                      
4000dde0:	86 00 60 01 	add  %g1, 1, %g3                               
        } while (prevCounter == pipe->writerCounter);                 
      }                                                               
      break;                                                          
                                                                      
    case LIBIO_FLAGS_WRITE:                                           
      pipe->writerCounter ++;                                         
4000dde4:	84 00 a0 01 	inc  %g2                                       
                                                                      
      if (pipe->Writers ++ == 0)                                      
4000dde8:	c6 27 60 14 	st  %g3, [ %i5 + 0x14 ]                        
4000ddec:	80 a0 60 00 	cmp  %g1, 0                                    
4000ddf0:	02 80 00 68 	be  4000df90 <fifo_open+0x490>                 <== ALWAYS TAKEN
4000ddf4:	c4 27 60 24 	st  %g2, [ %i5 + 0x24 ]                        
        PIPE_WAKEUPREADERS(pipe);                                     
                                                                      
      if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {                 
4000ddf8:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        <== NOT EXECUTED
4000ddfc:	80 a0 60 00 	cmp  %g1, 0                                    
4000de00:	32 bf ff f2 	bne,a   4000ddc8 <fifo_open+0x2c8>             
4000de04:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
4000de08:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1                        
4000de0c:	80 88 60 01 	btst  1, %g1                                   
4000de10:	32 80 00 65 	bne,a   4000dfa4 <fifo_open+0x4a4>             
4000de14:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
        err = -ENXIO;                                                 
        goto out_error;                                               
      }                                                               
                                                                      
      if (pipe->Readers == 0) {                                       
        prevCounter = pipe->readerCounter;                            
4000de18:	10 80 00 0c 	b  4000de48 <fifo_open+0x348>                  
4000de1c:	f8 07 60 20 	ld  [ %i5 + 0x20 ], %i4                        
        err = -EINTR;                                                 
        do {                                                          
          PIPE_UNLOCK(pipe);                                          
          if (! PIPE_WRITEWAIT(pipe))                                 
            goto out_error;                                           
          if (! PIPE_LOCK(pipe))                                      
4000de20:	92 10 20 00 	clr  %o1                                       
4000de24:	7f ff eb 18 	call  40008a84 <rtems_semaphore_obtain>        
4000de28:	94 10 20 00 	clr  %o2                                       
4000de2c:	80 a2 20 00 	cmp  %o0, 0                                    
4000de30:	12 80 00 0f 	bne  4000de6c <fifo_open+0x36c>                <== NEVER TAKEN
4000de34:	b0 10 3f fc 	mov  -4, %i0                                   
            goto out_error;                                           
        } while (prevCounter == pipe->readerCounter);                 
4000de38:	c2 07 60 20 	ld  [ %i5 + 0x20 ], %g1                        
4000de3c:	80 a0 40 1c 	cmp  %g1, %i4                                  
4000de40:	32 bf ff e2 	bne,a   4000ddc8 <fifo_open+0x2c8>             <== ALWAYS TAKEN
4000de44:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
                                                                      
      if (pipe->Readers == 0) {                                       
        prevCounter = pipe->readerCounter;                            
        err = -EINTR;                                                 
        do {                                                          
          PIPE_UNLOCK(pipe);                                          
4000de48:	7f ff eb 5e 	call  40008bc0 <rtems_semaphore_release>       
4000de4c:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
          if (! PIPE_WRITEWAIT(pipe))                                 
4000de50:	d0 07 60 30 	ld  [ %i5 + 0x30 ], %o0                        
4000de54:	40 00 06 0e 	call  4000f68c <rtems_barrier_wait>            
4000de58:	92 10 20 00 	clr  %o1                                       
4000de5c:	80 a2 20 00 	cmp  %o0, 0                                    
4000de60:	22 bf ff f0 	be,a   4000de20 <fifo_open+0x320>              <== ALWAYS TAKEN
4000de64:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
        /* Not an error */                                            
        if (LIBIO_NODELAY(iop))                                       
          break;                                                      
                                                                      
        prevCounter = pipe->writerCounter;                            
        err = -EINTR;                                                 
4000de68:	b0 10 3f fc 	mov  -4, %i0                                   <== NOT EXECUTED
                                                                      
  PIPE_UNLOCK(pipe);                                                  
  return 0;                                                           
                                                                      
out_error:                                                            
  pipe_release(pipep, iop);                                           
4000de6c:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
4000de70:	7f ff fe e5 	call  4000da04 <pipe_release>                  
4000de74:	92 10 00 19 	mov  %i1, %o1                                  
  return err;                                                         
4000de78:	81 c7 e0 08 	ret                                            
4000de7c:	81 e8 00 00 	restore                                        
    return err;                                                       
  pipe = *pipep;                                                      
                                                                      
  switch (LIBIO_ACCMODE(iop)) {                                       
    case LIBIO_FLAGS_READ:                                            
      pipe->readerCounter ++;                                         
4000de80:	c4 07 60 20 	ld  [ %i5 + 0x20 ], %g2                        
      if (pipe->Readers ++ == 0)                                      
4000de84:	86 00 60 01 	add  %g1, 1, %g3                               
    return err;                                                       
  pipe = *pipep;                                                      
                                                                      
  switch (LIBIO_ACCMODE(iop)) {                                       
    case LIBIO_FLAGS_READ:                                            
      pipe->readerCounter ++;                                         
4000de88:	84 00 a0 01 	inc  %g2                                       
      if (pipe->Readers ++ == 0)                                      
4000de8c:	c6 27 60 10 	st  %g3, [ %i5 + 0x10 ]                        
4000de90:	80 a0 60 00 	cmp  %g1, 0                                    
4000de94:	02 80 00 35 	be  4000df68 <fifo_open+0x468>                 <== ALWAYS TAKEN
4000de98:	c4 27 60 20 	st  %g2, [ %i5 + 0x20 ]                        
        PIPE_WAKEUPWRITERS(pipe);                                     
                                                                      
      if (pipe->Writers == 0) {                                       
4000de9c:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        <== NOT EXECUTED
4000dea0:	80 a0 60 00 	cmp  %g1, 0                                    
4000dea4:	32 bf ff c9 	bne,a   4000ddc8 <fifo_open+0x2c8>             
4000dea8:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
        /* Not an error */                                            
        if (LIBIO_NODELAY(iop))                                       
4000deac:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1                        
4000deb0:	80 88 60 01 	btst  1, %g1                                   
4000deb4:	32 bf ff c5 	bne,a   4000ddc8 <fifo_open+0x2c8>             
4000deb8:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
          break;                                                      
                                                                      
        prevCounter = pipe->writerCounter;                            
4000debc:	10 80 00 0c 	b  4000deec <fifo_open+0x3ec>                  
4000dec0:	f8 07 60 24 	ld  [ %i5 + 0x24 ], %i4                        
        /* Wait until a writer opens the pipe */                      
        do {                                                          
          PIPE_UNLOCK(pipe);                                          
          if (! PIPE_READWAIT(pipe))                                  
            goto out_error;                                           
          if (! PIPE_LOCK(pipe))                                      
4000dec4:	92 10 20 00 	clr  %o1                                       
4000dec8:	7f ff ea ef 	call  40008a84 <rtems_semaphore_obtain>        
4000decc:	94 10 20 00 	clr  %o2                                       
4000ded0:	80 a2 20 00 	cmp  %o0, 0                                    
4000ded4:	12 bf ff e6 	bne  4000de6c <fifo_open+0x36c>                <== NEVER TAKEN
4000ded8:	b0 10 3f fc 	mov  -4, %i0                                   
            goto out_error;                                           
        } while (prevCounter == pipe->writerCounter);                 
4000dedc:	c2 07 60 24 	ld  [ %i5 + 0x24 ], %g1                        
4000dee0:	80 a0 40 1c 	cmp  %g1, %i4                                  
4000dee4:	32 bf ff b9 	bne,a   4000ddc8 <fifo_open+0x2c8>             <== ALWAYS TAKEN
4000dee8:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
                                                                      
        prevCounter = pipe->writerCounter;                            
        err = -EINTR;                                                 
        /* Wait until a writer opens the pipe */                      
        do {                                                          
          PIPE_UNLOCK(pipe);                                          
4000deec:	7f ff eb 35 	call  40008bc0 <rtems_semaphore_release>       
4000def0:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
          if (! PIPE_READWAIT(pipe))                                  
4000def4:	d0 07 60 2c 	ld  [ %i5 + 0x2c ], %o0                        
4000def8:	40 00 05 e5 	call  4000f68c <rtems_barrier_wait>            
4000defc:	92 10 20 00 	clr  %o1                                       
4000df00:	80 a2 20 00 	cmp  %o0, 0                                    
4000df04:	22 bf ff f0 	be,a   4000dec4 <fifo_open+0x3c4>              <== ALWAYS TAKEN
4000df08:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
        /* Not an error */                                            
        if (LIBIO_NODELAY(iop))                                       
          break;                                                      
                                                                      
        prevCounter = pipe->writerCounter;                            
        err = -EINTR;                                                 
4000df0c:	10 bf ff d8 	b  4000de6c <fifo_open+0x36c>                  <== NOT EXECUTED
4000df10:	b0 10 3f fc 	mov  -4, %i0                                   <== NOT EXECUTED
      }                                                               
      break;                                                          
                                                                      
    case LIBIO_FLAGS_READ_WRITE:                                      
      pipe->readerCounter ++;                                         
      if (pipe->Readers ++ == 0)                                      
4000df14:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
        } while (prevCounter == pipe->readerCounter);                 
      }                                                               
      break;                                                          
                                                                      
    case LIBIO_FLAGS_READ_WRITE:                                      
      pipe->readerCounter ++;                                         
4000df18:	c4 07 60 20 	ld  [ %i5 + 0x20 ], %g2                        
      if (pipe->Readers ++ == 0)                                      
4000df1c:	86 00 60 01 	add  %g1, 1, %g3                               
        } while (prevCounter == pipe->readerCounter);                 
      }                                                               
      break;                                                          
                                                                      
    case LIBIO_FLAGS_READ_WRITE:                                      
      pipe->readerCounter ++;                                         
4000df20:	84 00 a0 01 	inc  %g2                                       
      if (pipe->Readers ++ == 0)                                      
4000df24:	c6 27 60 10 	st  %g3, [ %i5 + 0x10 ]                        
4000df28:	80 a0 60 00 	cmp  %g1, 0                                    
4000df2c:	02 80 00 14 	be  4000df7c <fifo_open+0x47c>                 <== ALWAYS TAKEN
4000df30:	c4 27 60 20 	st  %g2, [ %i5 + 0x20 ]                        
        PIPE_WAKEUPWRITERS(pipe);                                     
      pipe->writerCounter ++;                                         
      if (pipe->Writers ++ == 0)                                      
4000df34:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        <== NOT EXECUTED
                                                                      
    case LIBIO_FLAGS_READ_WRITE:                                      
      pipe->readerCounter ++;                                         
      if (pipe->Readers ++ == 0)                                      
        PIPE_WAKEUPWRITERS(pipe);                                     
      pipe->writerCounter ++;                                         
4000df38:	c4 07 60 24 	ld  [ %i5 + 0x24 ], %g2                        
      if (pipe->Writers ++ == 0)                                      
4000df3c:	86 00 60 01 	add  %g1, 1, %g3                               
                                                                      
    case LIBIO_FLAGS_READ_WRITE:                                      
      pipe->readerCounter ++;                                         
      if (pipe->Readers ++ == 0)                                      
        PIPE_WAKEUPWRITERS(pipe);                                     
      pipe->writerCounter ++;                                         
4000df40:	84 00 a0 01 	inc  %g2                                       
      if (pipe->Writers ++ == 0)                                      
4000df44:	c6 27 60 14 	st  %g3, [ %i5 + 0x14 ]                        
4000df48:	80 a0 60 00 	cmp  %g1, 0                                    
4000df4c:	12 bf ff 9e 	bne  4000ddc4 <fifo_open+0x2c4>                <== NEVER TAKEN
4000df50:	c4 27 60 24 	st  %g2, [ %i5 + 0x24 ]                        
        PIPE_WAKEUPREADERS(pipe);                                     
4000df54:	d0 07 60 2c 	ld  [ %i5 + 0x2c ], %o0                        
4000df58:	40 00 05 b5 	call  4000f62c <rtems_barrier_release>         
4000df5c:	92 07 bf f8 	add  %fp, -8, %o1                              
      break;                                                          
  }                                                                   
                                                                      
  PIPE_UNLOCK(pipe);                                                  
4000df60:	10 bf ff 9a 	b  4000ddc8 <fifo_open+0x2c8>                  
4000df64:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
                                                                      
  switch (LIBIO_ACCMODE(iop)) {                                       
    case LIBIO_FLAGS_READ:                                            
      pipe->readerCounter ++;                                         
      if (pipe->Readers ++ == 0)                                      
        PIPE_WAKEUPWRITERS(pipe);                                     
4000df68:	d0 07 60 30 	ld  [ %i5 + 0x30 ], %o0                        
4000df6c:	40 00 05 b0 	call  4000f62c <rtems_barrier_release>         
4000df70:	92 07 bf f8 	add  %fp, -8, %o1                              
                                                                      
      if (pipe->Writers == 0) {                                       
4000df74:	10 bf ff cb 	b  4000dea0 <fifo_open+0x3a0>                  
4000df78:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
      break;                                                          
                                                                      
    case LIBIO_FLAGS_READ_WRITE:                                      
      pipe->readerCounter ++;                                         
      if (pipe->Readers ++ == 0)                                      
        PIPE_WAKEUPWRITERS(pipe);                                     
4000df7c:	d0 07 60 30 	ld  [ %i5 + 0x30 ], %o0                        
4000df80:	40 00 05 ab 	call  4000f62c <rtems_barrier_release>         
4000df84:	92 07 bf f8 	add  %fp, -8, %o1                              
      pipe->writerCounter ++;                                         
      if (pipe->Writers ++ == 0)                                      
4000df88:	10 bf ff ec 	b  4000df38 <fifo_open+0x438>                  
4000df8c:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
                                                                      
    case LIBIO_FLAGS_WRITE:                                           
      pipe->writerCounter ++;                                         
                                                                      
      if (pipe->Writers ++ == 0)                                      
        PIPE_WAKEUPREADERS(pipe);                                     
4000df90:	d0 07 60 2c 	ld  [ %i5 + 0x2c ], %o0                        
4000df94:	40 00 05 a6 	call  4000f62c <rtems_barrier_release>         
4000df98:	92 07 bf f8 	add  %fp, -8, %o1                              
                                                                      
      if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {                 
4000df9c:	10 bf ff 98 	b  4000ddfc <fifo_open+0x2fc>                  
4000dfa0:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
	PIPE_UNLOCK(pipe);                                                   
4000dfa4:	7f ff eb 07 	call  40008bc0 <rtems_semaphore_release>       
4000dfa8:	b0 10 3f fa 	mov  -6, %i0                                   
        err = -ENXIO;                                                 
        goto out_error;                                               
4000dfac:	10 bf ff b1 	b  4000de70 <fifo_open+0x370>                  
4000dfb0:	90 10 00 1b 	mov  %i3, %o0                                  
                                                                      

40009a50 <fpathconf>: */ long fpathconf( int fd, int name ) {
40009a50:	9d e3 bf a0 	save  %sp, -96, %sp                            
  long                                    return_value;               
  rtems_libio_t                          *iop;                        
  const rtems_filesystem_limits_and_options_t *the_limits;            
                                                                      
  rtems_libio_check_fd(fd);                                           
40009a54:	03 10 00 54 	sethi  %hi(0x40015000), %g1                    
40009a58:	c2 00 62 48 	ld  [ %g1 + 0x248 ], %g1	! 40015248 <rtems_libio_number_iops>
40009a5c:	80 a6 00 01 	cmp  %i0, %g1                                  
40009a60:	1a 80 00 3e 	bcc  40009b58 <fpathconf+0x108>                
40009a64:	03 10 00 56 	sethi  %hi(0x40015800), %g1                    
  iop = rtems_libio_iop(fd);                                          
40009a68:	c2 00 63 80 	ld  [ %g1 + 0x380 ], %g1	! 40015b80 <rtems_libio_iops>
40009a6c:	85 2e 20 03 	sll  %i0, 3, %g2                               
40009a70:	b1 2e 20 06 	sll  %i0, 6, %i0                               
40009a74:	b0 26 00 02 	sub  %i0, %g2, %i0                             
40009a78:	b0 00 40 18 	add  %g1, %i0, %i0                             
  rtems_libio_check_is_open(iop);                                     
40009a7c:	c2 06 20 10 	ld  [ %i0 + 0x10 ], %g1                        
40009a80:	80 88 61 00 	btst  0x100, %g1                               
40009a84:	02 80 00 35 	be  40009b58 <fpathconf+0x108>                 <== NEVER TAKEN
40009a88:	80 a6 60 0b 	cmp  %i1, 0xb                                  
                                                                      
  /*                                                                  
   *  Now process the information request.                            
   */                                                                 
                                                                      
  the_limits = iop->pathinfo.mt_entry->pathconf_limits_and_options;   
40009a8c:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
                                                                      
  switch ( name ) {                                                   
40009a90:	08 80 00 08 	bleu  40009ab0 <fpathconf+0x60>                
40009a94:	c2 00 60 2c 	ld  [ %g1 + 0x2c ], %g1                        
      break;                                                          
    case _PC_SYNC_IO:                                                 
      return_value = the_limits->posix_sync_io;                       
      break;                                                          
    default:                                                          
      rtems_set_errno_and_return_minus_one( EINVAL );                 
40009a98:	40 00 09 72 	call  4000c060 <__errno>                       
40009a9c:	b0 10 3f ff 	mov  -1, %i0                                   
40009aa0:	82 10 20 16 	mov  0x16, %g1                                 
40009aa4:	c2 22 00 00 	st  %g1, [ %o0 ]                               
      break;                                                          
  }                                                                   
                                                                      
  return return_value;                                                
}                                                                     
40009aa8:	81 c7 e0 08 	ret                                            
40009aac:	81 e8 00 00 	restore                                        
   *  Now process the information request.                            
   */                                                                 
                                                                      
  the_limits = iop->pathinfo.mt_entry->pathconf_limits_and_options;   
                                                                      
  switch ( name ) {                                                   
40009ab0:	b3 2e 60 02 	sll  %i1, 2, %i1                               
40009ab4:	05 10 00 26 	sethi  %hi(0x40009800), %g2                    
40009ab8:	84 10 a2 20 	or  %g2, 0x220, %g2	! 40009a20 <_close_r+0x10> 
40009abc:	c4 00 80 19 	ld  [ %g2 + %i1 ], %g2                         
40009ac0:	81 c0 80 00 	jmp  %g2                                       
40009ac4:	01 00 00 00 	nop                                            
      break;                                                          
    case _PC_ASYNC_IO:                                                
      return_value = the_limits->posix_async_io;                      
      break;                                                          
    case _PC_PRIO_IO:                                                 
      return_value = the_limits->posix_prio_io;                       
40009ac8:	f0 00 60 24 	ld  [ %g1 + 0x24 ], %i0                        
      break;                                                          
40009acc:	81 c7 e0 08 	ret                                            
40009ad0:	81 e8 00 00 	restore                                        
      break;                                                          
    case _PC_VDISABLE:                                                
      return_value = the_limits->posix_vdisable;                      
      break;                                                          
    case _PC_ASYNC_IO:                                                
      return_value = the_limits->posix_async_io;                      
40009ad4:	f0 00 60 18 	ld  [ %g1 + 0x18 ], %i0                        
      break;                                                          
40009ad8:	81 c7 e0 08 	ret                                            
40009adc:	81 e8 00 00 	restore                                        
      break;                                                          
    case _PC_NO_TRUNC:                                                
      return_value = the_limits->posix_no_trunc;                      
      break;                                                          
    case _PC_VDISABLE:                                                
      return_value = the_limits->posix_vdisable;                      
40009ae0:	f0 00 60 2c 	ld  [ %g1 + 0x2c ], %i0                        
      break;                                                          
40009ae4:	81 c7 e0 08 	ret                                            
40009ae8:	81 e8 00 00 	restore                                        
      break;                                                          
    case _PC_CHOWN_RESTRICTED:                                        
      return_value = the_limits->posix_chown_restrictions;            
      break;                                                          
    case _PC_NO_TRUNC:                                                
      return_value = the_limits->posix_no_trunc;                      
40009aec:	f0 00 60 20 	ld  [ %g1 + 0x20 ], %i0                        
      break;                                                          
40009af0:	81 c7 e0 08 	ret                                            
40009af4:	81 e8 00 00 	restore                                        
      break;                                                          
    case _PC_PIPE_BUF:                                                
      return_value = the_limits->pipe_buf;                            
      break;                                                          
    case _PC_CHOWN_RESTRICTED:                                        
      return_value = the_limits->posix_chown_restrictions;            
40009af8:	f0 00 60 1c 	ld  [ %g1 + 0x1c ], %i0                        
      break;                                                          
40009afc:	81 c7 e0 08 	ret                                            
40009b00:	81 e8 00 00 	restore                                        
      break;                                                          
    case _PC_PATH_MAX:                                                
      return_value = the_limits->path_max;                            
      break;                                                          
    case _PC_PIPE_BUF:                                                
      return_value = the_limits->pipe_buf;                            
40009b04:	f0 00 60 14 	ld  [ %g1 + 0x14 ], %i0                        
      break;                                                          
40009b08:	81 c7 e0 08 	ret                                            
40009b0c:	81 e8 00 00 	restore                                        
      break;                                                          
    case _PC_NAME_MAX:                                                
      return_value = the_limits->name_max;                            
      break;                                                          
    case _PC_PATH_MAX:                                                
      return_value = the_limits->path_max;                            
40009b10:	f0 00 60 10 	ld  [ %g1 + 0x10 ], %i0                        
      break;                                                          
40009b14:	81 c7 e0 08 	ret                                            
40009b18:	81 e8 00 00 	restore                                        
      break;                                                          
    case _PC_MAX_INPUT:                                               
      return_value = the_limits->max_input;                           
      break;                                                          
    case _PC_NAME_MAX:                                                
      return_value = the_limits->name_max;                            
40009b1c:	f0 00 60 0c 	ld  [ %g1 + 0xc ], %i0                         
      break;                                                          
40009b20:	81 c7 e0 08 	ret                                            
40009b24:	81 e8 00 00 	restore                                        
      break;                                                          
    case _PC_MAX_CANON:                                               
      return_value = the_limits->max_canon;                           
      break;                                                          
    case _PC_MAX_INPUT:                                               
      return_value = the_limits->max_input;                           
40009b28:	f0 00 60 08 	ld  [ %g1 + 8 ], %i0                           
      break;                                                          
40009b2c:	81 c7 e0 08 	ret                                            
40009b30:	81 e8 00 00 	restore                                        
  switch ( name ) {                                                   
    case _PC_LINK_MAX:                                                
      return_value = the_limits->link_max;                            
      break;                                                          
    case _PC_MAX_CANON:                                               
      return_value = the_limits->max_canon;                           
40009b34:	f0 00 60 04 	ld  [ %g1 + 4 ], %i0                           
      break;                                                          
40009b38:	81 c7 e0 08 	ret                                            
40009b3c:	81 e8 00 00 	restore                                        
                                                                      
  the_limits = iop->pathinfo.mt_entry->pathconf_limits_and_options;   
                                                                      
  switch ( name ) {                                                   
    case _PC_LINK_MAX:                                                
      return_value = the_limits->link_max;                            
40009b40:	f0 00 40 00 	ld  [ %g1 ], %i0                               
      break;                                                          
40009b44:	81 c7 e0 08 	ret                                            
40009b48:	81 e8 00 00 	restore                                        
      break;                                                          
    case _PC_PRIO_IO:                                                 
      return_value = the_limits->posix_prio_io;                       
      break;                                                          
    case _PC_SYNC_IO:                                                 
      return_value = the_limits->posix_sync_io;                       
40009b4c:	f0 00 60 28 	ld  [ %g1 + 0x28 ], %i0                        
      break;                                                          
40009b50:	81 c7 e0 08 	ret                                            
40009b54:	81 e8 00 00 	restore                                        
  rtems_libio_t                          *iop;                        
  const rtems_filesystem_limits_and_options_t *the_limits;            
                                                                      
  rtems_libio_check_fd(fd);                                           
  iop = rtems_libio_iop(fd);                                          
  rtems_libio_check_is_open(iop);                                     
40009b58:	40 00 09 42 	call  4000c060 <__errno>                       
40009b5c:	b0 10 3f ff 	mov  -1, %i0                                   
40009b60:	82 10 20 09 	mov  9, %g1                                    
40009b64:	c2 22 00 00 	st  %g1, [ %o0 ]                               
40009b68:	81 c7 e0 08 	ret                                            
40009b6c:	81 e8 00 00 	restore                                        
                                                                      

40003028 <free>: #include <stdlib.h> void free( void *ptr ) {
40003028:	9d e3 bf a0 	save  %sp, -96, %sp                            
  MSBUMP(free_calls, 1);                                              
4000302c:	03 10 00 7b 	sethi  %hi(0x4001ec00), %g1                    
40003030:	82 10 61 40 	or  %g1, 0x140, %g1	! 4001ed40 <rtems_malloc_statistics>
40003034:	c4 00 60 0c 	ld  [ %g1 + 0xc ], %g2                         
#include <stdlib.h>                                                   
                                                                      
void free(                                                            
  void *ptr                                                           
)                                                                     
{                                                                     
40003038:	b2 10 00 18 	mov  %i0, %i1                                  
  MSBUMP(free_calls, 1);                                              
4000303c:	84 00 a0 01 	inc  %g2                                       
                                                                      
  if ( !ptr )                                                         
40003040:	80 a6 20 00 	cmp  %i0, 0                                    
40003044:	02 80 00 15 	be  40003098 <free+0x70>                       
40003048:	c4 20 60 0c 	st  %g2, [ %g1 + 0xc ]                         
    return;                                                           
                                                                      
  /*                                                                  
   *  Do not attempt to free memory if in a critical section or ISR.  
   */                                                                 
  if ( _System_state_Is_up(_System_state_Get()) &&                    
4000304c:	03 10 00 7c 	sethi  %hi(0x4001f000), %g1                    
40003050:	c2 00 63 c8 	ld  [ %g1 + 0x3c8 ], %g1	! 4001f3c8 <_System_state_Current>
40003054:	80 a0 60 03 	cmp  %g1, 3                                    
40003058:	02 80 00 17 	be  400030b4 <free+0x8c>                       <== ALWAYS TAKEN
4000305c:	03 10 00 7a 	sethi  %hi(0x4001e800), %g1                    
  }                                                                   
                                                                      
  /*                                                                  
   *  If configured, update the statistics                            
   */                                                                 
  if ( rtems_malloc_statistics_helpers )                              
40003060:	c2 00 62 90 	ld  [ %g1 + 0x290 ], %g1	! 4001ea90 <rtems_malloc_statistics_helpers>
40003064:	80 a0 60 00 	cmp  %g1, 0                                    
40003068:	02 80 00 06 	be  40003080 <free+0x58>                       
4000306c:	3b 10 00 78 	sethi  %hi(0x4001e000), %i5                    
    (*rtems_malloc_statistics_helpers->at_free)(ptr);                 
40003070:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
40003074:	9f c0 40 00 	call  %g1                                      
40003078:	90 10 00 19 	mov  %i1, %o0                                  
                                                                      
  if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {            
4000307c:	3b 10 00 78 	sethi  %hi(0x4001e000), %i5                    
40003080:	d0 07 63 60 	ld  [ %i5 + 0x360 ], %o0	! 4001e360 <RTEMS_Malloc_Heap>
40003084:	40 00 18 86 	call  4000929c <_Protected_heap_Free>          
40003088:	92 10 00 19 	mov  %i1, %o1                                  
4000308c:	80 8a 20 ff 	btst  0xff, %o0                                
40003090:	02 80 00 04 	be  400030a0 <free+0x78>                       
40003094:	c2 07 63 60 	ld  [ %i5 + 0x360 ], %g1                       
40003098:	81 c7 e0 08 	ret                                            
4000309c:	81 e8 00 00 	restore                                        
    printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
400030a0:	31 10 00 73 	sethi  %hi(0x4001cc00), %i0                    
400030a4:	f4 00 60 18 	ld  [ %g1 + 0x18 ], %i2                        
400030a8:	f6 00 60 1c 	ld  [ %g1 + 0x1c ], %i3                        
400030ac:	40 00 03 81 	call  40003eb0 <printk>                        
400030b0:	91 ee 22 c0 	restore  %i0, 0x2c0, %o0                       
                                                                      
  /*                                                                  
   *  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() ) {                               
400030b4:	40 00 00 67 	call  40003250 <malloc_is_system_state_OK>     
400030b8:	01 00 00 00 	nop                                            
    return;                                                           
                                                                      
  /*                                                                  
   *  Do not attempt to free memory if in a critical section or ISR.  
   */                                                                 
  if ( _System_state_Is_up(_System_state_Get()) &&                    
400030bc:	80 8a 20 ff 	btst  0xff, %o0                                
400030c0:	12 bf ff e8 	bne  40003060 <free+0x38>                      
400030c4:	03 10 00 7a 	sethi  %hi(0x4001e800), %g1                    
       !malloc_is_system_state_OK() ) {                               
      malloc_deferred_free(ptr);                                      
400030c8:	40 00 00 7c 	call  400032b8 <malloc_deferred_free>          
400030cc:	81 e8 00 00 	restore                                        
                                                                      

4001b54c <fstat>: int fstat( int fd, struct stat *sbuf ) {
4001b54c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_libio_t *iop;                                                 
                                                                      
  /*                                                                  
   *  Check to see if we were passed a valid pointer.                 
   */                                                                 
  if ( !sbuf )                                                        
4001b550:	80 a6 60 00 	cmp  %i1, 0                                    
4001b554:	02 80 00 1f 	be  4001b5d0 <fstat+0x84>                      <== NEVER TAKEN
4001b558:	03 10 00 78 	sethi  %hi(0x4001e000), %g1                    
    rtems_set_errno_and_return_minus_one( EFAULT );                   
                                                                      
  /*                                                                  
   *  Now process the stat() request.                                 
   */                                                                 
  iop = rtems_libio_iop( fd );                                        
4001b55c:	c2 00 63 a4 	ld  [ %g1 + 0x3a4 ], %g1	! 4001e3a4 <rtems_libio_number_iops>
4001b560:	80 a6 00 01 	cmp  %i0, %g1                                  
4001b564:	1a 80 00 15 	bcc  4001b5b8 <fstat+0x6c>                     
4001b568:	03 10 00 7b 	sethi  %hi(0x4001ec00), %g1                    
4001b56c:	c2 00 61 30 	ld  [ %g1 + 0x130 ], %g1	! 4001ed30 <rtems_libio_iops>
4001b570:	85 2e 20 03 	sll  %i0, 3, %g2                               
4001b574:	b1 2e 20 06 	sll  %i0, 6, %i0                               
4001b578:	b0 26 00 02 	sub  %i0, %g2, %i0                             
4001b57c:	b0 00 40 18 	add  %g1, %i0, %i0                             
  rtems_libio_check_fd( fd );                                         
  rtems_libio_check_is_open(iop);                                     
4001b580:	c2 06 20 10 	ld  [ %i0 + 0x10 ], %g1                        
4001b584:	80 88 61 00 	btst  0x100, %g1                               
4001b588:	02 80 00 0c 	be  4001b5b8 <fstat+0x6c>                      
4001b58c:	94 10 20 48 	mov  0x48, %o2                                 
                                                                      
  /*                                                                  
   *  Zero out the stat structure so the various support              
   *  versions of stat don't have to.                                 
   */                                                                 
  memset( sbuf, 0, sizeof(struct stat) );                             
4001b590:	92 10 20 00 	clr  %o1                                       
4001b594:	7f ff d2 f9 	call  40010178 <memset>                        
4001b598:	90 10 00 19 	mov  %i1, %o0                                  
                                                                      
  return (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf );  
4001b59c:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
4001b5a0:	90 06 20 14 	add  %i0, 0x14, %o0                            
4001b5a4:	c2 00 60 18 	ld  [ %g1 + 0x18 ], %g1                        
4001b5a8:	9f c0 40 00 	call  %g1                                      
4001b5ac:	92 10 00 19 	mov  %i1, %o1                                  
}                                                                     
4001b5b0:	81 c7 e0 08 	ret                                            
4001b5b4:	91 e8 00 08 	restore  %g0, %o0, %o0                         
  /*                                                                  
   *  Now process the stat() request.                                 
   */                                                                 
  iop = rtems_libio_iop( fd );                                        
  rtems_libio_check_fd( fd );                                         
  rtems_libio_check_is_open(iop);                                     
4001b5b8:	7f ff d0 62 	call  4000f740 <__errno>                       
4001b5bc:	b0 10 3f ff 	mov  -1, %i0                                   
4001b5c0:	82 10 20 09 	mov  9, %g1                                    
4001b5c4:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4001b5c8:	81 c7 e0 08 	ret                                            
4001b5cc:	81 e8 00 00 	restore                                        
                                                                      
  /*                                                                  
   *  Check to see if we were passed a valid pointer.                 
   */                                                                 
  if ( !sbuf )                                                        
    rtems_set_errno_and_return_minus_one( EFAULT );                   
4001b5d0:	7f ff d0 5c 	call  4000f740 <__errno>                       <== NOT EXECUTED
4001b5d4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4001b5d8:	82 10 20 0e 	mov  0xe, %g1                                  <== NOT EXECUTED
4001b5dc:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4001b5e0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001b5e4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40002dfc <get_disk_entry>: rtems_device_major_number major = 0; rtems_device_minor_number minor = 0; rtems_filesystem_split_dev_t(dev, major, minor); if (major < disktab_size && disktab != NULL) {
40002dfc:	03 10 00 6b 	sethi  %hi(0x4001ac00), %g1                    
40002e00:	c2 00 62 18 	ld  [ %g1 + 0x218 ], %g1	! 4001ae18 <disktab_size>
40002e04:	80 a0 40 08 	cmp  %g1, %o0                                  
40002e08:	08 80 00 20 	bleu  40002e88 <get_disk_entry+0x8c>           <== NEVER TAKEN
40002e0c:	03 10 00 6b 	sethi  %hi(0x4001ac00), %g1                    
40002e10:	c2 00 62 1c 	ld  [ %g1 + 0x21c ], %g1	! 4001ae1c <disktab>  
40002e14:	80 a0 60 00 	cmp  %g1, 0                                    
40002e18:	02 80 00 1c 	be  40002e88 <get_disk_entry+0x8c>             <== NEVER TAKEN
40002e1c:	01 00 00 00 	nop                                            
    rtems_disk_device_table *dtab = disktab + major;                  
40002e20:	91 2a 20 03 	sll  %o0, 3, %o0                               
40002e24:	84 00 40 08 	add  %g1, %o0, %g2                             
                                                                      
    if (minor < dtab->size && dtab->minor != NULL) {                  
40002e28:	c4 00 a0 04 	ld  [ %g2 + 4 ], %g2                           
40002e2c:	80 a0 80 09 	cmp  %g2, %o1                                  
40002e30:	08 80 00 16 	bleu  40002e88 <get_disk_entry+0x8c>           <== NEVER TAKEN
40002e34:	01 00 00 00 	nop                                            
40002e38:	c2 00 40 08 	ld  [ %g1 + %o0 ], %g1                         
40002e3c:	80 a0 60 00 	cmp  %g1, 0                                    
40002e40:	02 80 00 12 	be  40002e88 <get_disk_entry+0x8c>             <== NEVER TAKEN
40002e44:	93 2a 60 02 	sll  %o1, 2, %o1                               
      rtems_disk_device *dd = dtab->minor [minor];                    
                                                                      
      if (dd != NULL && !lookup_only) {                               
40002e48:	80 a2 a0 01 	cmp  %o2, 1                                    
40002e4c:	12 80 00 04 	bne  40002e5c <get_disk_entry+0x60>            
40002e50:	d0 00 40 09 	ld  [ %g1 + %o1 ], %o0                         
      return dd;                                                      
    }                                                                 
  }                                                                   
                                                                      
  return NULL;                                                        
}                                                                     
40002e54:	81 c3 e0 08 	retl                                           
40002e58:	01 00 00 00 	nop                                            
    rtems_disk_device_table *dtab = disktab + major;                  
                                                                      
    if (minor < dtab->size && dtab->minor != NULL) {                  
      rtems_disk_device *dd = dtab->minor [minor];                    
                                                                      
      if (dd != NULL && !lookup_only) {                               
40002e5c:	80 a2 20 00 	cmp  %o0, 0                                    
40002e60:	02 bf ff fd 	be  40002e54 <get_disk_entry+0x58>             <== NEVER TAKEN
40002e64:	01 00 00 00 	nop                                            
        if (!dd->deleted) {                                           
40002e68:	c2 0a 20 40 	ldub  [ %o0 + 0x40 ], %g1                      
40002e6c:	80 a0 60 00 	cmp  %g1, 0                                    
40002e70:	12 80 00 06 	bne  40002e88 <get_disk_entry+0x8c>            
40002e74:	01 00 00 00 	nop                                            
          ++dd->uses;                                                 
40002e78:	c2 02 20 14 	ld  [ %o0 + 0x14 ], %g1                        
40002e7c:	82 00 60 01 	inc  %g1                                       
40002e80:	81 c3 e0 08 	retl                                           
40002e84:	c2 22 20 14 	st  %g1, [ %o0 + 0x14 ]                        
      return dd;                                                      
    }                                                                 
  }                                                                   
                                                                      
  return NULL;                                                        
}                                                                     
40002e88:	81 c3 e0 08 	retl                                           
40002e8c:	90 10 20 00 	clr  %o0                                       
                                                                      

400044e4 <get_sector.part.0>: * NOTES: * get_sector() operates with device via bdbuf library, * and does not support devices with sector size other than 512 bytes */ static rtems_status_code get_sector(int fd,
400044e4:	9d e3 bf a0 	save  %sp, -96, %sp                            
    new_off = lseek(fd, off, SEEK_SET);                               
    if (new_off != off) {                                             
        return RTEMS_IO_ERROR;                                        
    }                                                                 
                                                                      
    s = (rtems_sector_data_t *) malloc(sizeof(rtems_sector_data_t) + RTEMS_IDE_SECTOR_SIZE);
400044e8:	40 00 05 41 	call  400059ec <malloc>                        
400044ec:	90 10 22 04 	mov  0x204, %o0                                
    if (s == NULL)                                                    
    {                                                                 
        return RTEMS_NO_MEMORY;                                       
400044f0:	82 10 20 1a 	mov  0x1a, %g1                                 
    if (new_off != off) {                                             
        return RTEMS_IO_ERROR;                                        
    }                                                                 
                                                                      
    s = (rtems_sector_data_t *) malloc(sizeof(rtems_sector_data_t) + RTEMS_IDE_SECTOR_SIZE);
    if (s == NULL)                                                    
400044f4:	80 a2 20 00 	cmp  %o0, 0                                    
400044f8:	02 80 00 0c 	be  40004528 <get_sector.part.0+0x44>          <== NEVER TAKEN
400044fc:	ba 10 00 08 	mov  %o0, %i5                                  
    {                                                                 
        return RTEMS_NO_MEMORY;                                       
    }                                                                 
                                                                      
    n = read(fd, s->data, RTEMS_IDE_SECTOR_SIZE);                     
40004500:	90 10 00 18 	mov  %i0, %o0                                  
40004504:	92 07 60 04 	add  %i5, 4, %o1                               
40004508:	40 00 07 eb 	call  400064b4 <read>                          
4000450c:	94 10 22 00 	mov  0x200, %o2                                
    if (n != RTEMS_IDE_SECTOR_SIZE)                                   
40004510:	80 a2 22 00 	cmp  %o0, 0x200                                
40004514:	02 80 00 07 	be  40004530 <get_sector.part.0+0x4c>          <== ALWAYS TAKEN
40004518:	82 10 20 00 	clr  %g1                                       
    {                                                                 
        free(s);                                                      
4000451c:	40 00 03 97 	call  40005378 <free>                          <== NOT EXECUTED
40004520:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
        return RTEMS_IO_ERROR;                                        
40004524:	82 10 20 1b 	mov  0x1b, %g1                                 <== NOT EXECUTED
    s->sector_num = sector_num;                                       
                                                                      
    *sector = s;                                                      
                                                                      
    return RTEMS_SUCCESSFUL;                                          
}                                                                     
40004528:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000452c:	91 e8 00 01 	restore  %g0, %g1, %o0                         <== NOT EXECUTED
    {                                                                 
        free(s);                                                      
        return RTEMS_IO_ERROR;                                        
    }                                                                 
                                                                      
    s->sector_num = sector_num;                                       
40004530:	f2 27 40 00 	st  %i1, [ %i5 ]                               
                                                                      
    *sector = s;                                                      
40004534:	fa 26 80 00 	st  %i5, [ %i2 ]                               
                                                                      
    return RTEMS_SUCCESSFUL;                                          
}                                                                     
40004538:	81 c7 e0 08 	ret                                            
4000453c:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      

400331f0 <getdents>: int getdents( int dd_fd, char *dd_buf, int dd_len ) {
400331f0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_filesystem_node_types_t type;                                 
                                                                      
  /*                                                                  
   *  Get the file control block structure associated with the file descriptor
   */                                                                 
  iop = rtems_libio_iop( dd_fd );                                     
400331f4:	03 10 00 e4 	sethi  %hi(0x40039000), %g1                    
400331f8:	c2 00 61 ac 	ld  [ %g1 + 0x1ac ], %g1	! 400391ac <rtems_libio_number_iops>
400331fc:	80 a6 00 01 	cmp  %i0, %g1                                  
40033200:	1a 80 00 08 	bcc  40033220 <getdents+0x30>                  <== NEVER TAKEN
40033204:	ba 10 20 00 	clr  %i5                                       
40033208:	03 10 01 27 	sethi  %hi(0x40049c00), %g1                    
4003320c:	fa 00 60 90 	ld  [ %g1 + 0x90 ], %i5	! 40049c90 <rtems_libio_iops>
40033210:	83 2e 20 03 	sll  %i0, 3, %g1                               
40033214:	b1 2e 20 06 	sll  %i0, 6, %i0                               
40033218:	b0 26 00 01 	sub  %i0, %g1, %i0                             
4003321c:	ba 07 40 18 	add  %i5, %i0, %i5                             
                                                                      
  /*                                                                  
   *  Make sure we are working on a directory                         
   */                                                                 
  type = rtems_filesystem_node_type( &iop->pathinfo );                
40033220:	7f ff 5b 61 	call  40009fa4 <rtems_filesystem_node_type>    
40033224:	90 07 60 14 	add  %i5, 0x14, %o0                            
  if ( type != RTEMS_FILESYSTEM_DIRECTORY )                           
40033228:	80 a2 20 00 	cmp  %o0, 0                                    
4003322c:	12 80 00 09 	bne  40033250 <getdents+0x60>                  
40033230:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  /*                                                                  
   *  Return the number of bytes that were actually transfered as a result
   *  of the read attempt.                                            
   */                                                                 
  return (*iop->pathinfo.handlers->read_h)( iop, dd_buf, dd_len  );   
40033234:	c2 07 60 24 	ld  [ %i5 + 0x24 ], %g1                        
40033238:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
4003323c:	92 10 00 19 	mov  %i1, %o1                                  
40033240:	9f c0 40 00 	call  %g1                                      
40033244:	94 10 00 1a 	mov  %i2, %o2                                  
}                                                                     
40033248:	81 c7 e0 08 	ret                                            
4003324c:	91 e8 00 08 	restore  %g0, %o0, %o0                         
  /*                                                                  
   *  Make sure we are working on a directory                         
   */                                                                 
  type = rtems_filesystem_node_type( &iop->pathinfo );                
  if ( type != RTEMS_FILESYSTEM_DIRECTORY )                           
    rtems_set_errno_and_return_minus_one( ENOTDIR );                  
40033250:	7f ff bd ba 	call  40022938 <__errno>                       
40033254:	b0 10 3f ff 	mov  -1, %i0                                   
40033258:	82 10 20 14 	mov  0x14, %g1                                 
4003325c:	c2 22 00 00 	st  %g1, [ %o0 ]                               
40033260:	81 c7 e0 08 	ret                                            
40033264:	81 e8 00 00 	restore                                        
                                                                      

4000eaec <imfs_dir_read>: ssize_t imfs_dir_read( rtems_libio_t *iop, void *buffer, size_t count ) {
4000eaec:	9d e3 be 88 	save  %sp, -376, %sp                           
                                                                      
static inline void rtems_filesystem_instance_lock(                    
  const rtems_filesystem_location_info_t *loc                         
)                                                                     
{                                                                     
  const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
4000eaf0:	d0 06 20 28 	ld  [ %i0 + 0x28 ], %o0                        
                                                                      
  (*mt_entry->ops->lock_h)( mt_entry );                               
4000eaf4:	c4 02 20 0c 	ld  [ %o0 + 0xc ], %g2                         
4000eaf8:	c2 00 80 00 	ld  [ %g2 ], %g1                               
4000eafc:	9f c0 40 00 	call  %g1                                      
4000eb00:	01 00 00 00 	nop                                            
   int                  last_entry;                                   
   struct dirent        tmp_dirent;                                   
                                                                      
   rtems_filesystem_instance_lock( &iop->pathinfo );                  
                                                                      
   the_jnode = (IMFS_jnode_t *)iop->pathinfo.node_access;             
4000eb04:	e4 06 20 1c 	ld  [ %i0 + 0x1c ], %l2                        
   the_chain = &the_jnode->info.directory.Entries;                    
                                                                      
   /* Move to the first of the desired directory entries */           
                                                                      
   bytes_transferred = 0;                                             
   first_entry = iop->offset;                                         
4000eb08:	e0 06 20 0c 	ld  [ %i0 + 0xc ], %l0                         
   /* protect against using sizes that are not exact multiples of the */
   /* -dirent- size. These could result in unexpected results          */
   last_entry = first_entry                                           
     + (count / sizeof( struct dirent )) * sizeof( struct dirent );   
4000eb0c:	90 10 00 1a 	mov  %i2, %o0                                  
4000eb10:	40 00 27 59 	call  40018874 <.udiv>                         
4000eb14:	92 10 21 18 	mov  0x118, %o1                                
4000eb18:	83 2a 20 03 	sll  %o0, 3, %g1                               
4000eb1c:	91 2a 20 05 	sll  %o0, 5, %o0                               
4000eb20:	82 00 40 08 	add  %g1, %o0, %g1                             
4000eb24:	a3 28 60 03 	sll  %g1, 3, %l1                               
4000eb28:	a2 24 40 01 	sub  %l1, %g1, %l1                             
4000eb2c:	a2 04 40 10 	add  %l1, %l0, %l1                             
                                                                      
   /* The directory was not empty so try to move to the desired entry in chain*/
   for (                                                              
4000eb30:	80 a4 60 00 	cmp  %l1, 0                                    
4000eb34:	04 80 00 34 	ble  4000ec04 <imfs_dir_read+0x118>            <== NEVER TAKEN
4000eb38:	f4 04 a0 50 	ld  [ %l2 + 0x50 ], %i2                        
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(                             
  const Chain_Control *the_chain,                                     
  const Chain_Node    *the_node                                       
)                                                                     
{                                                                     
  return (the_node == _Chain_Immutable_tail( the_chain ));            
4000eb3c:	a4 04 a0 54 	add  %l2, 0x54, %l2                            
      current_entry = 0,                                              
        the_node = rtems_chain_first( the_chain );                    
      current_entry < last_entry                                      
        && !rtems_chain_is_tail( the_chain, the_node );               
4000eb40:	80 a6 80 12 	cmp  %i2, %l2                                  
4000eb44:	02 80 00 29 	be  4000ebe8 <imfs_dir_read+0xfc>              
4000eb48:	a6 10 20 00 	clr  %l3                                       
4000eb4c:	b6 10 20 00 	clr  %i3                                       
        the_node = rtems_chain_next( the_node )                       
   ) {                                                                
      if( current_entry >= first_entry ) {                            
         /* Move the entry to the return buffer */                    
         tmp_dirent.d_off = current_entry;                            
         tmp_dirent.d_reclen = sizeof( struct dirent );               
4000eb50:	10 80 00 08 	b  4000eb70 <imfs_dir_read+0x84>               
4000eb54:	a8 10 21 18 	mov  0x118, %l4                                
   /* -dirent- size. These could result in unexpected results          */
   last_entry = first_entry                                           
     + (count / sizeof( struct dirent )) * sizeof( struct dirent );   
                                                                      
   /* The directory was not empty so try to move to the desired entry in chain*/
   for (                                                              
4000eb58:	80 a4 40 1b 	cmp  %l1, %i3                                  
4000eb5c:	04 80 00 23 	ble  4000ebe8 <imfs_dir_read+0xfc>             <== NEVER TAKEN
4000eb60:	f4 06 80 00 	ld  [ %i2 ], %i2                               
      current_entry = 0,                                              
        the_node = rtems_chain_first( the_chain );                    
      current_entry < last_entry                                      
        && !rtems_chain_is_tail( the_chain, the_node );               
4000eb64:	80 a6 80 12 	cmp  %i2, %l2                                  
4000eb68:	22 80 00 21 	be,a   4000ebec <imfs_dir_read+0x100>          
4000eb6c:	d0 06 20 28 	ld  [ %i0 + 0x28 ], %o0                        
      current_entry +=  sizeof( struct dirent ),                      
        the_node = rtems_chain_next( the_node )                       
   ) {                                                                
      if( current_entry >= first_entry ) {                            
4000eb70:	80 a4 00 1b 	cmp  %l0, %i3                                  
4000eb74:	34 bf ff f9 	bg,a   4000eb58 <imfs_dir_read+0x6c>           
4000eb78:	b6 06 e1 18 	add  %i3, 0x118, %i3                           
         /* Move the entry to the return buffer */                    
         tmp_dirent.d_off = current_entry;                            
         tmp_dirent.d_reclen = sizeof( struct dirent );               
         the_jnode = (IMFS_jnode_t *) the_node;                       
         tmp_dirent.d_ino = the_jnode->st_ino;                        
4000eb7c:	c2 06 a0 38 	ld  [ %i2 + 0x38 ], %g1                        
      current_entry +=  sizeof( struct dirent ),                      
        the_node = rtems_chain_next( the_node )                       
   ) {                                                                
      if( current_entry >= first_entry ) {                            
         /* Move the entry to the return buffer */                    
         tmp_dirent.d_off = current_entry;                            
4000eb80:	85 3e e0 1f 	sra  %i3, 0x1f, %g2                            
         tmp_dirent.d_reclen = sizeof( struct dirent );               
         the_jnode = (IMFS_jnode_t *) the_node;                       
         tmp_dirent.d_ino = the_jnode->st_ino;                        
         tmp_dirent.d_namlen = strlen( the_jnode->name );             
4000eb84:	ba 06 a0 0c 	add  %i2, 0xc, %i5                             
      current_entry +=  sizeof( struct dirent ),                      
        the_node = rtems_chain_next( the_node )                       
   ) {                                                                
      if( current_entry >= first_entry ) {                            
         /* Move the entry to the return buffer */                    
         tmp_dirent.d_off = current_entry;                            
4000eb88:	c4 27 be f0 	st  %g2, [ %fp + -272 ]                        
         tmp_dirent.d_reclen = sizeof( struct dirent );               
         the_jnode = (IMFS_jnode_t *) the_node;                       
         tmp_dirent.d_ino = the_jnode->st_ino;                        
4000eb8c:	c2 27 be e8 	st  %g1, [ %fp + -280 ]                        
      current_entry +=  sizeof( struct dirent ),                      
        the_node = rtems_chain_next( the_node )                       
   ) {                                                                
      if( current_entry >= first_entry ) {                            
         /* Move the entry to the return buffer */                    
         tmp_dirent.d_off = current_entry;                            
4000eb90:	f6 27 be f4 	st  %i3, [ %fp + -268 ]                        
         tmp_dirent.d_reclen = sizeof( struct dirent );               
         the_jnode = (IMFS_jnode_t *) the_node;                       
         tmp_dirent.d_ino = the_jnode->st_ino;                        
         tmp_dirent.d_namlen = strlen( the_jnode->name );             
4000eb94:	90 10 00 1d 	mov  %i5, %o0                                  
4000eb98:	40 00 08 4f 	call  40010cd4 <strlen>                        
4000eb9c:	e8 37 be f8 	sth  %l4, [ %fp + -264 ]                       
         strcpy( tmp_dirent.d_name, the_jnode->name );                
4000eba0:	92 10 00 1d 	mov  %i5, %o1                                  
4000eba4:	94 02 20 01 	add  %o0, 1, %o2                               
         /* Move the entry to the return buffer */                    
         tmp_dirent.d_off = current_entry;                            
         tmp_dirent.d_reclen = sizeof( struct dirent );               
         the_jnode = (IMFS_jnode_t *) the_node;                       
         tmp_dirent.d_ino = the_jnode->st_ino;                        
         tmp_dirent.d_namlen = strlen( the_jnode->name );             
4000eba8:	d0 37 be fa 	sth  %o0, [ %fp + -262 ]                       
         strcpy( tmp_dirent.d_name, the_jnode->name );                
4000ebac:	40 00 05 36 	call  40010084 <memcpy>                        
4000ebb0:	90 07 be fc 	add  %fp, -260, %o0                            
         memcpy(                                                      
4000ebb4:	90 06 40 13 	add  %i1, %l3, %o0                             
4000ebb8:	92 07 be e8 	add  %fp, -280, %o1                            
4000ebbc:	40 00 05 32 	call  40010084 <memcpy>                        
4000ebc0:	94 10 21 18 	mov  0x118, %o2                                
            buffer + bytes_transferred,                               
            (void *)&tmp_dirent,                                      
            sizeof( struct dirent )                                   
         );                                                           
         iop->offset += sizeof( struct dirent );                      
4000ebc4:	c4 1e 20 08 	ldd  [ %i0 + 8 ], %g2                          
#include "imfs.h"                                                     
                                                                      
#include <string.h>                                                   
#include <dirent.h>                                                   
                                                                      
ssize_t imfs_dir_read(                                                
4000ebc8:	b6 06 e1 18 	add  %i3, 0x118, %i3                           
         memcpy(                                                      
            buffer + bytes_transferred,                               
            (void *)&tmp_dirent,                                      
            sizeof( struct dirent )                                   
         );                                                           
         iop->offset += sizeof( struct dirent );                      
4000ebcc:	ba 80 e1 18 	addcc  %g3, 0x118, %i5                         
4000ebd0:	b8 40 a0 00 	addx  %g2, 0, %i4                              
4000ebd4:	f8 3e 20 08 	std  %i4, [ %i0 + 8 ]                          
         bytes_transferred += sizeof( struct dirent );                
4000ebd8:	a6 04 e1 18 	add  %l3, 0x118, %l3                           
   /* -dirent- size. These could result in unexpected results          */
   last_entry = first_entry                                           
     + (count / sizeof( struct dirent )) * sizeof( struct dirent );   
                                                                      
   /* The directory was not empty so try to move to the desired entry in chain*/
   for (                                                              
4000ebdc:	80 a4 40 1b 	cmp  %l1, %i3                                  
4000ebe0:	14 bf ff e1 	bg  4000eb64 <imfs_dir_read+0x78>              <== NEVER TAKEN
4000ebe4:	f4 06 80 00 	ld  [ %i2 ], %i2                               
                                                                      
static inline void rtems_filesystem_instance_unlock(                  
  const rtems_filesystem_location_info_t *loc                         
)                                                                     
{                                                                     
  const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
4000ebe8:	d0 06 20 28 	ld  [ %i0 + 0x28 ], %o0                        
                                                                      
  (*mt_entry->ops->unlock_h)( mt_entry );                             
4000ebec:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
4000ebf0:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
4000ebf4:	9f c0 40 00 	call  %g1                                      
4000ebf8:	b0 10 00 13 	mov  %l3, %i0                                  
   }                                                                  
                                                                      
   rtems_filesystem_instance_unlock( &iop->pathinfo );                
                                                                      
   return bytes_transferred;                                          
}                                                                     
4000ebfc:	81 c7 e0 08 	ret                                            
4000ec00:	81 e8 00 00 	restore                                        
   the_jnode = (IMFS_jnode_t *)iop->pathinfo.node_access;             
   the_chain = &the_jnode->info.directory.Entries;                    
                                                                      
   /* Move to the first of the desired directory entries */           
                                                                      
   bytes_transferred = 0;                                             
4000ec04:	10 bf ff f9 	b  4000ebe8 <imfs_dir_read+0xfc>               <== NOT EXECUTED
4000ec08:	a6 10 20 00 	clr  %l3                                       <== NOT EXECUTED
                                                                      

400271a0 <init_etc_passwd_group>: /** * Initialize useable but dummy databases */ void init_etc_passwd_group(void) {
400271a0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  FILE *fp;                                                           
  static char etc_passwd_initted = 0;                                 
                                                                      
  if (etc_passwd_initted)                                             
400271a4:	03 10 01 9f 	sethi  %hi(0x40067c00), %g1                    
400271a8:	c4 48 61 18 	ldsb  [ %g1 + 0x118 ], %g2	! 40067d18 <etc_passwd_initted.7068>
400271ac:	80 a0 a0 00 	cmp  %g2, 0                                    
400271b0:	02 80 00 04 	be  400271c0 <init_etc_passwd_group+0x20>      
400271b4:	84 10 20 01 	mov  1, %g2                                    
400271b8:	81 c7 e0 08 	ret                                            
400271bc:	81 e8 00 00 	restore                                        
    return;                                                           
  etc_passwd_initted = 1;                                             
  mkdir("/etc", 0777);                                                
400271c0:	92 10 21 ff 	mov  0x1ff, %o1                                
  FILE *fp;                                                           
  static char etc_passwd_initted = 0;                                 
                                                                      
  if (etc_passwd_initted)                                             
    return;                                                           
  etc_passwd_initted = 1;                                             
400271c4:	c4 28 61 18 	stb  %g2, [ %g1 + 0x118 ]                      
  mkdir("/etc", 0777);                                                
400271c8:	11 10 01 7d 	sethi  %hi(0x4005f400), %o0                    
400271cc:	7f ff 6f 88 	call  40002fec <mkdir>                         
400271d0:	90 12 20 10 	or  %o0, 0x10, %o0	! 4005f410 <rtems_status_assoc+0x168>
                                                                      
  /*                                                                  
   *  Initialize /etc/passwd                                          
   */                                                                 
  if ((fp = fopen("/etc/passwd", "r")) != NULL) {                     
400271d4:	39 10 01 7d 	sethi  %hi(0x4005f400), %i4                    
400271d8:	3b 10 01 8e 	sethi  %hi(0x40063800), %i5                    
400271dc:	90 17 20 18 	or  %i4, 0x18, %o0                             
400271e0:	40 00 53 92 	call  4003c028 <fopen>                         
400271e4:	92 17 62 a0 	or  %i5, 0x2a0, %o1                            
400271e8:	80 a2 20 00 	cmp  %o0, 0                                    
400271ec:	22 80 00 0d 	be,a   40027220 <init_etc_passwd_group+0x80>   
400271f0:	90 17 20 18 	or  %i4, 0x18, %o0                             
  }                                                                   
  else if ((fp = fopen("/etc/passwd", "w")) != NULL) {                
    fprintf(fp, "root:*:0:0:root::/:/bin/sh\n"                        
                 "rtems:*:1:1:RTEMS Application::/:/bin/sh\n"         
                 "tty:!:2:2:tty owner::/:/bin/false\n" );             
    fclose(fp);                                                       
400271f4:	40 00 51 2f 	call  4003b6b0 <fclose>                        
400271f8:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  /*                                                                  
   *  Initialize /etc/group                                           
   */                                                                 
  if ((fp = fopen("/etc/group", "r")) != NULL) {                      
400271fc:	39 10 01 7d 	sethi  %hi(0x4005f400), %i4                    
40027200:	92 17 62 a0 	or  %i5, 0x2a0, %o1                            
40027204:	40 00 53 89 	call  4003c028 <fopen>                         
40027208:	90 17 20 90 	or  %i4, 0x90, %o0                             
4002720c:	80 a2 20 00 	cmp  %o0, 0                                    
40027210:	22 80 00 11 	be,a   40027254 <init_etc_passwd_group+0xb4>   
40027214:	90 17 20 90 	or  %i4, 0x90, %o0                             
    fclose(fp);                                                       
40027218:	40 00 51 26 	call  4003b6b0 <fclose>                        
4002721c:	91 e8 00 08 	restore  %g0, %o0, %o0                         
   *  Initialize /etc/passwd                                          
   */                                                                 
  if ((fp = fopen("/etc/passwd", "r")) != NULL) {                     
    fclose(fp);                                                       
  }                                                                   
  else if ((fp = fopen("/etc/passwd", "w")) != NULL) {                
40027220:	13 10 01 73 	sethi  %hi(0x4005cc00), %o1                    
40027224:	40 00 53 81 	call  4003c028 <fopen>                         
40027228:	92 12 62 f0 	or  %o1, 0x2f0, %o1	! 4005cef0 <rtems_rtc_shell_usage+0x4e8>
4002722c:	b8 92 20 00 	orcc  %o0, 0, %i4                              
40027230:	02 bf ff f3 	be  400271fc <init_etc_passwd_group+0x5c>      <== NEVER TAKEN
40027234:	92 10 20 01 	mov  1, %o1                                    
    fprintf(fp, "root:*:0:0:root::/:/bin/sh\n"                        
40027238:	94 10 20 66 	mov  0x66, %o2                                 
4002723c:	96 10 00 1c 	mov  %i4, %o3                                  
40027240:	11 10 01 7d 	sethi  %hi(0x4005f400), %o0                    
40027244:	40 00 58 48 	call  4003d364 <fwrite>                        
40027248:	90 12 20 28 	or  %o0, 0x28, %o0	! 4005f428 <rtems_status_assoc+0x180>
                 "rtems:*:1:1:RTEMS Application::/:/bin/sh\n"         
                 "tty:!:2:2:tty owner::/:/bin/false\n" );             
    fclose(fp);                                                       
4002724c:	10 bf ff ea 	b  400271f4 <init_etc_passwd_group+0x54>       
40027250:	90 10 00 1c 	mov  %i4, %o0                                  
   *  Initialize /etc/group                                           
   */                                                                 
  if ((fp = fopen("/etc/group", "r")) != NULL) {                      
    fclose(fp);                                                       
  }                                                                   
  else if ((fp = fopen("/etc/group", "w")) != NULL) {                 
40027254:	13 10 01 73 	sethi  %hi(0x4005cc00), %o1                    
40027258:	40 00 53 74 	call  4003c028 <fopen>                         
4002725c:	92 12 62 f0 	or  %o1, 0x2f0, %o1	! 4005cef0 <rtems_rtc_shell_usage+0x4e8>
40027260:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40027264:	02 bf ff d5 	be  400271b8 <init_etc_passwd_group+0x18>      <== NEVER TAKEN
40027268:	92 10 20 01 	mov  1, %o1                                    
    fprintf( fp, "root:x:0:root\n"                                    
4002726c:	11 10 01 7d 	sethi  %hi(0x4005f400), %o0                    
40027270:	94 10 20 2a 	mov  0x2a, %o2                                 
40027274:	96 10 00 18 	mov  %i0, %o3                                  
40027278:	40 00 58 3b 	call  4003d364 <fwrite>                        
4002727c:	90 12 20 a0 	or  %o0, 0xa0, %o0                             
                 "rtems:x:1:rtems\n"                                  
                 "tty:x:2:tty\n" );                                   
    fclose(fp);                                                       
40027280:	40 00 51 0c 	call  4003b6b0 <fclose>                        
40027284:	81 e8 00 00 	restore                                        
                                                                      

40005c44 <iproc>: /* * Process a single input character */ static int iproc (unsigned char c, struct rtems_termios_tty *tty) {
40005c44:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if (tty->termios.c_iflag & ISTRIP)                                  
40005c48:	c2 06 60 30 	ld  [ %i1 + 0x30 ], %g1                        
40005c4c:	80 88 60 20 	btst  0x20, %g1                                
40005c50:	32 80 00 02 	bne,a   40005c58 <iproc+0x14>                  <== NEVER TAKEN
40005c54:	b0 0e 20 7f 	and  %i0, 0x7f, %i0                            <== NOT EXECUTED
    c &= 0x7f;                                                        
                                                                      
  if (tty->termios.c_iflag & IUCLC)                                   
40005c58:	80 88 62 00 	btst  0x200, %g1                               
40005c5c:	02 80 00 0d 	be  40005c90 <iproc+0x4c>                      
40005c60:	80 a6 20 0d 	cmp  %i0, 0xd                                  
    c = tolower (c);                                                  
40005c64:	05 10 00 79 	sethi  %hi(0x4001e400), %g2                    
40005c68:	c6 00 a1 60 	ld  [ %g2 + 0x160 ], %g3	! 4001e560 <__ctype_ptr__>
40005c6c:	84 10 00 18 	mov  %i0, %g2                                  
40005c70:	b0 00 c0 18 	add  %g3, %i0, %i0                             
40005c74:	c6 0e 20 01 	ldub  [ %i0 + 1 ], %g3                         
40005c78:	86 08 e0 03 	and  %g3, 3, %g3                               
40005c7c:	80 a0 e0 01 	cmp  %g3, 1                                    
40005c80:	22 80 00 02 	be,a   40005c88 <iproc+0x44>                   
40005c84:	84 00 a0 20 	add  %g2, 0x20, %g2                            
40005c88:	b0 08 a0 ff 	and  %g2, 0xff, %i0                            
                                                                      
  if (c == '\r') {                                                    
40005c8c:	80 a6 20 0d 	cmp  %i0, 0xd                                  
40005c90:	02 80 00 1d 	be  40005d04 <iproc+0xc0>                      
40005c94:	80 a6 20 0a 	cmp  %i0, 0xa                                  
    if (tty->termios.c_iflag & IGNCR)                                 
      return 0;                                                       
    if (tty->termios.c_iflag & ICRNL)                                 
      c = '\n';                                                       
  } else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {         
40005c98:	02 80 00 44 	be  40005da8 <iproc+0x164>                     
40005c9c:	80 a6 20 00 	cmp  %i0, 0                                    
    c = '\r';                                                         
  }                                                                   
                                                                      
  if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {               
40005ca0:	32 80 00 1f 	bne,a   40005d1c <iproc+0xd8>                  <== ALWAYS TAKEN
40005ca4:	c2 06 60 3c 	ld  [ %i1 + 0x3c ], %g1                        
  }                                                                   
                                                                      
  /*                                                                  
   * FIXME: Should do IMAXBEL handling somehow                        
   */                                                                 
  if (tty->ccount < (CBUFSIZE-1)) {                                   
40005ca8:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        <== NOT EXECUTED
40005cac:	05 10 00 78 	sethi  %hi(0x4001e000), %g2                    
40005cb0:	c4 00 a3 e4 	ld  [ %g2 + 0x3e4 ], %g2	! 4001e3e4 <rtems_termios_cbufsize>
40005cb4:	84 00 bf ff 	add  %g2, -1, %g2                              
40005cb8:	80 a0 40 02 	cmp  %g1, %g2                                  
40005cbc:	1a 80 00 10 	bcc  40005cfc <iproc+0xb8>                     <== NEVER TAKEN
40005cc0:	01 00 00 00 	nop                                            
    if (tty->termios.c_lflag & ECHO)                                  
40005cc4:	c4 06 60 3c 	ld  [ %i1 + 0x3c ], %g2                        
40005cc8:	80 88 a0 08 	btst  8, %g2                                   
40005ccc:	12 80 00 3c 	bne  40005dbc <iproc+0x178>                    <== ALWAYS TAKEN
40005cd0:	84 00 60 01 	add  %g1, 1, %g2                               
      echo (c, tty);                                                  
    tty->cbuf[tty->ccount++] = c;                                     
40005cd4:	c6 06 60 1c 	ld  [ %i1 + 0x1c ], %g3                        <== NOT EXECUTED
40005cd8:	f0 28 c0 01 	stb  %i0, [ %g3 + %g1 ]                        <== NOT EXECUTED
40005cdc:	c4 26 60 20 	st  %g2, [ %i1 + 0x20 ]                        <== NOT EXECUTED
  }                                                                   
  return 0;                                                           
40005ce0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40005ce4:	91 e8 20 00 	restore  %g0, 0, %o0                           <== NOT EXECUTED
 * FIXME: Some of the tests should check for IEXTEN, too.             
 */                                                                   
static void                                                           
erase (struct rtems_termios_tty *tty, int lineFlag)                   
{                                                                     
  if (tty->ccount == 0)                                               
40005ce8:	80 a0 60 00 	cmp  %g1, 0                                    
40005cec:	02 80 00 04 	be  40005cfc <iproc+0xb8>                      
40005cf0:	90 10 00 19 	mov  %i1, %o0                                  
40005cf4:	7f ff ff 5f 	call  40005a70 <erase.part.2>                  
40005cf8:	92 10 20 00 	clr  %o1                                       
  }                                                                   
                                                                      
  if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {               
    if (c == tty->termios.c_cc[VERASE]) {                             
      erase (tty, 0);                                                 
      return 0;                                                       
40005cfc:	81 c7 e0 08 	ret                                            
40005d00:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      
  if (tty->termios.c_iflag & IUCLC)                                   
    c = tolower (c);                                                  
                                                                      
  if (c == '\r') {                                                    
    if (tty->termios.c_iflag & IGNCR)                                 
40005d04:	80 88 60 80 	btst  0x80, %g1                                
40005d08:	12 bf ff fd 	bne  40005cfc <iproc+0xb8>                     <== NEVER TAKEN
40005d0c:	80 88 61 00 	btst  0x100, %g1                               
      return 0;                                                       
    if (tty->termios.c_iflag & ICRNL)                                 
40005d10:	32 80 00 02 	bne,a   40005d18 <iproc+0xd4>                  <== ALWAYS TAKEN
40005d14:	b0 10 20 0a 	mov  0xa, %i0                                  
      c = '\n';                                                       
  } else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {         
    c = '\r';                                                         
  }                                                                   
                                                                      
  if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {               
40005d18:	c2 06 60 3c 	ld  [ %i1 + 0x3c ], %g1                        
40005d1c:	80 88 60 02 	btst  2, %g1                                   
40005d20:	22 bf ff e3 	be,a   40005cac <iproc+0x68>                   
40005d24:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
    if (c == tty->termios.c_cc[VERASE]) {                             
40005d28:	c4 0e 60 43 	ldub  [ %i1 + 0x43 ], %g2                      
40005d2c:	80 a0 80 18 	cmp  %g2, %i0                                  
40005d30:	22 bf ff ee 	be,a   40005ce8 <iproc+0xa4>                   
40005d34:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
      erase (tty, 0);                                                 
      return 0;                                                       
    }                                                                 
    else if (c == tty->termios.c_cc[VKILL]) {                         
40005d38:	c4 0e 60 44 	ldub  [ %i1 + 0x44 ], %g2                      
40005d3c:	80 a0 80 18 	cmp  %g2, %i0                                  
40005d40:	22 80 00 2d 	be,a   40005df4 <iproc+0x1b0>                  
40005d44:	c4 06 60 20 	ld  [ %i1 + 0x20 ], %g2                        
      erase (tty, 1);                                                 
      return 0;                                                       
    }                                                                 
    else if (c == tty->termios.c_cc[VEOF]) {                          
40005d48:	c4 0e 60 45 	ldub  [ %i1 + 0x45 ], %g2                      
40005d4c:	80 a0 80 18 	cmp  %g2, %i0                                  
40005d50:	02 80 00 42 	be  40005e58 <iproc+0x214>                     <== NEVER TAKEN
40005d54:	80 a6 20 0a 	cmp  %i0, 0xa                                  
      return 1;                                                       
    } else if (c == '\n') {                                           
40005d58:	02 80 00 33 	be  40005e24 <iproc+0x1e0>                     
40005d5c:	80 88 60 48 	btst  0x48, %g1                                
      if (tty->termios.c_lflag & (ECHO | ECHONL))                     
        echo (c, tty);                                                
      tty->cbuf[tty->ccount++] = c;                                   
      return 1;                                                       
    } else if ((c == tty->termios.c_cc[VEOL]) ||                      
40005d60:	c4 0e 60 4c 	ldub  [ %i1 + 0x4c ], %g2                      
40005d64:	80 a0 80 18 	cmp  %g2, %i0                                  
40005d68:	02 80 00 07 	be  40005d84 <iproc+0x140>                     <== NEVER TAKEN
40005d6c:	80 88 60 08 	btst  8, %g1                                   
40005d70:	c4 0e 60 51 	ldub  [ %i1 + 0x51 ], %g2                      
40005d74:	80 a0 80 18 	cmp  %g2, %i0                                  
40005d78:	32 bf ff cd 	bne,a   40005cac <iproc+0x68>                  <== ALWAYS TAKEN
40005d7c:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
               (c == tty->termios.c_cc[VEOL2])) {                     
      if (tty->termios.c_lflag & ECHO)                                
40005d80:	80 88 60 08 	btst  8, %g1                                   <== NOT EXECUTED
40005d84:	12 80 00 18 	bne  40005de4 <iproc+0x1a0>                    <== NOT EXECUTED
40005d88:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
        echo (c, tty);                                                
      tty->cbuf[tty->ccount++] = c;                                   
40005d8c:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        <== NOT EXECUTED
40005d90:	c6 06 60 1c 	ld  [ %i1 + 0x1c ], %g3                        <== NOT EXECUTED
40005d94:	84 00 60 01 	add  %g1, 1, %g2                               <== NOT EXECUTED
40005d98:	f0 28 c0 01 	stb  %i0, [ %g3 + %g1 ]                        <== NOT EXECUTED
40005d9c:	c4 26 60 20 	st  %g2, [ %i1 + 0x20 ]                        <== NOT EXECUTED
      return 1;                                                       
40005da0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40005da4:	91 e8 20 01 	restore  %g0, 1, %o0                           <== NOT EXECUTED
  if (c == '\r') {                                                    
    if (tty->termios.c_iflag & IGNCR)                                 
      return 0;                                                       
    if (tty->termios.c_iflag & ICRNL)                                 
      c = '\n';                                                       
  } else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {         
40005da8:	80 88 60 40 	btst  0x40, %g1                                
40005dac:	32 bf ff db 	bne,a   40005d18 <iproc+0xd4>                  <== NEVER TAKEN
40005db0:	b0 10 20 0d 	mov  0xd, %i0                                  <== NOT EXECUTED
    c = '\r';                                                         
  }                                                                   
                                                                      
  if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {               
40005db4:	10 bf ff da 	b  40005d1c <iproc+0xd8>                       
40005db8:	c2 06 60 3c 	ld  [ %i1 + 0x3c ], %g1                        
  /*                                                                  
   * FIXME: Should do IMAXBEL handling somehow                        
   */                                                                 
  if (tty->ccount < (CBUFSIZE-1)) {                                   
    if (tty->termios.c_lflag & ECHO)                                  
      echo (c, tty);                                                  
40005dbc:	90 10 00 18 	mov  %i0, %o0                                  
40005dc0:	7f ff ff 0b 	call  400059ec <echo>                          
40005dc4:	92 10 00 19 	mov  %i1, %o1                                  
40005dc8:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
    tty->cbuf[tty->ccount++] = c;                                     
40005dcc:	c6 06 60 1c 	ld  [ %i1 + 0x1c ], %g3                        
40005dd0:	84 00 60 01 	add  %g1, 1, %g2                               
40005dd4:	f0 28 c0 01 	stb  %i0, [ %g3 + %g1 ]                        
40005dd8:	c4 26 60 20 	st  %g2, [ %i1 + 0x20 ]                        
  }                                                                   
  return 0;                                                           
40005ddc:	81 c7 e0 08 	ret                                            
40005de0:	91 e8 20 00 	restore  %g0, 0, %o0                           
      tty->cbuf[tty->ccount++] = c;                                   
      return 1;                                                       
    } else if ((c == tty->termios.c_cc[VEOL]) ||                      
               (c == tty->termios.c_cc[VEOL2])) {                     
      if (tty->termios.c_lflag & ECHO)                                
        echo (c, tty);                                                
40005de4:	7f ff ff 02 	call  400059ec <echo>                          <== NOT EXECUTED
40005de8:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
      tty->cbuf[tty->ccount++] = c;                                   
40005dec:	10 bf ff e9 	b  40005d90 <iproc+0x14c>                      <== NOT EXECUTED
40005df0:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        <== NOT EXECUTED
 * FIXME: Some of the tests should check for IEXTEN, too.             
 */                                                                   
static void                                                           
erase (struct rtems_termios_tty *tty, int lineFlag)                   
{                                                                     
  if (tty->ccount == 0)                                               
40005df4:	80 a0 a0 00 	cmp  %g2, 0                                    
40005df8:	02 bf ff c1 	be  40005cfc <iproc+0xb8>                      <== NEVER TAKEN
40005dfc:	80 88 60 08 	btst  8, %g1                                   
    return;                                                           
  if (lineFlag) {                                                     
    if (!(tty->termios.c_lflag & ECHO)) {                             
40005e00:	02 80 00 18 	be  40005e60 <iproc+0x21c>                     <== NEVER TAKEN
40005e04:	80 88 60 10 	btst  0x10, %g1                                
      tty->ccount = 0;                                                
      return;                                                         
    }                                                                 
    if (!(tty->termios.c_lflag & ECHOE)) {                            
40005e08:	02 80 00 19 	be  40005e6c <iproc+0x228>                     <== NEVER TAKEN
40005e0c:	90 10 00 19 	mov  %i1, %o0                                  
40005e10:	92 10 20 01 	mov  1, %o1                                    
      erase (tty, 0);                                                 
      return 0;                                                       
    }                                                                 
    else if (c == tty->termios.c_cc[VKILL]) {                         
      erase (tty, 1);                                                 
      return 0;                                                       
40005e14:	7f ff ff 17 	call  40005a70 <erase.part.2>                  
40005e18:	b0 10 20 00 	clr  %i0                                       
40005e1c:	81 c7 e0 08 	ret                                            
40005e20:	81 e8 00 00 	restore                                        
    }                                                                 
    else if (c == tty->termios.c_cc[VEOF]) {                          
      return 1;                                                       
    } else if (c == '\n') {                                           
      if (tty->termios.c_lflag & (ECHO | ECHONL))                     
40005e24:	22 80 00 06 	be,a   40005e3c <iproc+0x1f8>                  <== NEVER TAKEN
40005e28:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        <== NOT EXECUTED
        echo (c, tty);                                                
40005e2c:	90 10 20 0a 	mov  0xa, %o0                                  
40005e30:	7f ff fe ef 	call  400059ec <echo>                          
40005e34:	92 10 00 19 	mov  %i1, %o1                                  
      tty->cbuf[tty->ccount++] = c;                                   
40005e38:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
40005e3c:	c4 06 60 1c 	ld  [ %i1 + 0x1c ], %g2                        
40005e40:	86 10 20 0a 	mov  0xa, %g3                                  
40005e44:	c6 28 80 01 	stb  %g3, [ %g2 + %g1 ]                        
40005e48:	82 00 60 01 	inc  %g1                                       
40005e4c:	c2 26 60 20 	st  %g1, [ %i1 + 0x20 ]                        
      return 1;                                                       
40005e50:	81 c7 e0 08 	ret                                            
40005e54:	91 e8 20 01 	restore  %g0, 1, %o0                           
    if (tty->termios.c_lflag & ECHO)                                  
      echo (c, tty);                                                  
    tty->cbuf[tty->ccount++] = c;                                     
  }                                                                   
  return 0;                                                           
}                                                                     
40005e58:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40005e5c:	91 e8 20 01 	restore  %g0, 1, %o0                           <== NOT EXECUTED
{                                                                     
  if (tty->ccount == 0)                                               
    return;                                                           
  if (lineFlag) {                                                     
    if (!(tty->termios.c_lflag & ECHO)) {                             
      tty->ccount = 0;                                                
40005e60:	c0 26 60 20 	clr  [ %i1 + 0x20 ]                            <== NOT EXECUTED
      erase (tty, 0);                                                 
      return 0;                                                       
    }                                                                 
    else if (c == tty->termios.c_cc[VKILL]) {                         
      erase (tty, 1);                                                 
      return 0;                                                       
40005e64:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40005e68:	91 e8 20 00 	restore  %g0, 0, %o0                           <== NOT EXECUTED
    if (!(tty->termios.c_lflag & ECHO)) {                             
      tty->ccount = 0;                                                
      return;                                                         
    }                                                                 
    if (!(tty->termios.c_lflag & ECHOE)) {                            
      tty->ccount = 0;                                                
40005e6c:	c0 26 60 20 	clr  [ %i1 + 0x20 ]                            <== NOT EXECUTED
      echo (tty->termios.c_cc[VKILL], tty);                           
40005e70:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40005e74:	7f ff fe de 	call  400059ec <echo>                          <== NOT EXECUTED
40005e78:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
      if (tty->termios.c_lflag & ECHOK)                               
40005e7c:	c2 06 60 3c 	ld  [ %i1 + 0x3c ], %g1                        <== NOT EXECUTED
40005e80:	80 88 60 20 	btst  0x20, %g1                                <== NOT EXECUTED
40005e84:	02 bf ff 9e 	be  40005cfc <iproc+0xb8>                      <== NOT EXECUTED
40005e88:	90 10 20 0a 	mov  0xa, %o0                                  <== NOT EXECUTED
        echo ('\n', tty);                                             
40005e8c:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
40005e90:	7f ff fe d7 	call  400059ec <echo>                          <== NOT EXECUTED
40005e94:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
40005e98:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40005e9c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4001b9b8 <killinfo>: int killinfo( pid_t pid, int sig, const union sigval *value ) {
4001b9b8:	9d e3 bf 90 	save  %sp, -112, %sp                           
  POSIX_signals_Siginfo_node  *psiginfo;                              
                                                                      
  /*                                                                  
   *  Only supported for the "calling process" (i.e. this node).      
   */                                                                 
  if ( pid != getpid() )                                              
4001b9bc:	7f ff ff 10 	call  4001b5fc <getpid>                        
4001b9c0:	01 00 00 00 	nop                                            
4001b9c4:	80 a2 00 18 	cmp  %o0, %i0                                  
4001b9c8:	12 80 00 af 	bne  4001bc84 <killinfo+0x2cc>                 
4001b9cc:	80 a6 60 00 	cmp  %i1, 0                                    
    rtems_set_errno_and_return_minus_one( ESRCH );                    
                                                                      
  /*                                                                  
   *  Validate the signal passed.                                     
   */                                                                 
  if ( !sig )                                                         
4001b9d0:	02 80 00 b3 	be  4001bc9c <killinfo+0x2e4>                  
4001b9d4:	82 06 7f ff 	add  %i1, -1, %g1                              
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( !is_valid_signo(sig) )                                         
4001b9d8:	80 a0 60 1f 	cmp  %g1, 0x1f                                 
4001b9dc:	18 80 00 b0 	bgu  4001bc9c <killinfo+0x2e4>                 
4001b9e0:	a1 2e 60 02 	sll  %i1, 2, %l0                               
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  /*                                                                  
   *  If the signal is being ignored, then we are out of here.        
   */                                                                 
  if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN )          
4001b9e4:	31 10 00 7d 	sethi  %hi(0x4001f400), %i0                    
4001b9e8:	a3 2e 60 04 	sll  %i1, 4, %l1                               
4001b9ec:	b0 16 20 30 	or  %i0, 0x30, %i0                             
4001b9f0:	84 24 40 10 	sub  %l1, %l0, %g2                             
4001b9f4:	84 06 00 02 	add  %i0, %g2, %g2                             
4001b9f8:	c4 00 a0 08 	ld  [ %g2 + 8 ], %g2                           
4001b9fc:	80 a0 a0 01 	cmp  %g2, 1                                    
4001ba00:	02 80 00 9f 	be  4001bc7c <killinfo+0x2c4>                  
4001ba04:	80 a6 60 04 	cmp  %i1, 4                                    
  /*                                                                  
   *  P1003.1c/Draft 10, p. 33 says that certain signals should always
   *  be directed to the executing thread such as those caused by hardware
   *  faults.                                                         
   */                                                                 
  if ( (sig == SIGFPE) || (sig == SIGILL) || (sig == SIGSEGV ) )      
4001ba08:	02 80 00 41 	be  4001bb0c <killinfo+0x154>                  
4001ba0c:	80 a6 60 08 	cmp  %i1, 8                                    
4001ba10:	02 80 00 3f 	be  4001bb0c <killinfo+0x154>                  
4001ba14:	80 a6 60 0b 	cmp  %i1, 0xb                                  
4001ba18:	02 80 00 3d 	be  4001bb0c <killinfo+0x154>                  
4001ba1c:	ba 10 20 01 	mov  1, %i5                                    
                                                                      
  /*                                                                  
   *  Build up a siginfo structure                                    
   */                                                                 
  siginfo = &siginfo_struct;                                          
  siginfo->si_signo = sig;                                            
4001ba20:	f2 27 bf f4 	st  %i1, [ %fp + -12 ]                         
  siginfo->si_code = SI_USER;                                         
4001ba24:	fa 27 bf f8 	st  %i5, [ %fp + -8 ]                          
  if ( !value ) {                                                     
4001ba28:	80 a6 a0 00 	cmp  %i2, 0                                    
4001ba2c:	02 80 00 3e 	be  4001bb24 <killinfo+0x16c>                  
4001ba30:	bb 2f 40 01 	sll  %i5, %g1, %i5                             
    siginfo->si_value.sival_int = 0;                                  
  } else {                                                            
    siginfo->si_value = *value;                                       
4001ba34:	c2 06 80 00 	ld  [ %i2 ], %g1                               
4001ba38:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
   *                                                                  
   * This rountine increments the thread dispatch level               
   */                                                                 
  RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
  {                                                                   
    uint32_t level = _Thread_Dispatch_disable_level;                  
4001ba3c:	03 10 00 7b 	sethi  %hi(0x4001ec00), %g1                    
4001ba40:	c4 00 62 c0 	ld  [ %g1 + 0x2c0 ], %g2	! 4001eec0 <_Thread_Dispatch_disable_level>
                                                                      
    ++level;                                                          
4001ba44:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
4001ba48:	c4 20 62 c0 	st  %g2, [ %g1 + 0x2c0 ]                       
 */                                                                   
void _POSIX_signals_Manager_Initialization(void);                     
                                                                      
static inline void _POSIX_signals_Add_post_switch_extension(void)     
{                                                                     
  _API_extensions_Add_post_switch( &_POSIX_signals_Post_switch );     
4001ba4c:	11 10 00 79 	sethi  %hi(0x4001e400), %o0                    
4001ba50:	7f ff b0 ca 	call  40007d78 <_API_extensions_Add_post_switch>
4001ba54:	90 12 20 a8 	or  %o0, 0xa8, %o0	! 4001e4a8 <_POSIX_signals_Post_switch>
                                                                      
  /*                                                                  
   *  Is the currently executing thread interested?  If so then it will
   *  get it an execute it as soon as the dispatcher executes.        
   */                                                                 
  the_thread = _Thread_Executing;                                     
4001ba58:	03 10 00 7c 	sethi  %hi(0x4001f000), %g1                    
4001ba5c:	d0 00 63 e0 	ld  [ %g1 + 0x3e0 ], %o0	! 4001f3e0 <_Per_CPU_Information+0x10>
                                                                      
  api = the_thread->API_Extensions[ THREAD_API_POSIX ];               
  if ( _POSIX_signals_Is_interested( api, mask ) ) {                  
4001ba60:	c2 02 21 50 	ld  [ %o0 + 0x150 ], %g1                       
4001ba64:	c2 00 60 d0 	ld  [ %g1 + 0xd0 ], %g1                        
4001ba68:	80 af 40 01 	andncc  %i5, %g1, %g0                          
4001ba6c:	12 80 00 17 	bne  4001bac8 <killinfo+0x110>                 
4001ba70:	09 10 00 7d 	sethi  %hi(0x4001f400), %g4                    
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return _Chain_Head( the_chain )->next;                              
4001ba74:	c2 01 21 bc 	ld  [ %g4 + 0x1bc ], %g1	! 4001f5bc <_POSIX_signals_Wait_queue>
4001ba78:	88 11 21 bc 	or  %g4, 0x1bc, %g4                            
                                                                      
  /* XXX violation of visibility -- need to define thread queue support */
                                                                      
  the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;                 
                                                                      
  for ( the_node = _Chain_First( the_chain );                         
4001ba7c:	88 01 20 04 	add  %g4, 4, %g4                               
4001ba80:	80 a0 40 04 	cmp  %g1, %g4                                  
4001ba84:	32 80 00 0d 	bne,a   4001bab8 <killinfo+0x100>              
4001ba88:	c4 00 60 30 	ld  [ %g1 + 0x30 ], %g2                        
   *  NOTES:                                                          
   *                                                                  
   *    + rtems internal threads do not receive signals.              
   */                                                                 
  interested = NULL;                                                  
  interested_priority = PRIORITY_MAXIMUM + 1;                         
4001ba8c:	10 80 00 28 	b  4001bb2c <killinfo+0x174>                   
4001ba90:	03 10 00 78 	sethi  %hi(0x4001e000), %g1                    
                                                                      
    /*                                                                
     * Is this thread is blocked waiting for another signal but has   
     * not blocked this one?                                          
     */                                                               
    if (~api->signals_blocked & mask)                                 
4001ba94:	c4 00 e0 d0 	ld  [ %g3 + 0xd0 ], %g2                        
4001ba98:	80 af 40 02 	andncc  %i5, %g2, %g0                          
4001ba9c:	12 80 00 0b 	bne  4001bac8 <killinfo+0x110>                 
4001baa0:	90 10 00 01 	mov  %g1, %o0                                  
                                                                      
  the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;                 
                                                                      
  for ( the_node = _Chain_First( the_chain );                         
        !_Chain_Is_tail( the_chain, the_node ) ;                      
        the_node = the_node->next ) {                                 
4001baa4:	c2 00 40 00 	ld  [ %g1 ], %g1                               
                                                                      
  /* XXX violation of visibility -- need to define thread queue support */
                                                                      
  the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;                 
                                                                      
  for ( the_node = _Chain_First( the_chain );                         
4001baa8:	80 a0 40 04 	cmp  %g1, %g4                                  
4001baac:	22 80 00 20 	be,a   4001bb2c <killinfo+0x174>               <== ALWAYS TAKEN
4001bab0:	03 10 00 78 	sethi  %hi(0x4001e000), %g1                    
    #endif                                                            
                                                                      
    /*                                                                
     * Is this thread is actually blocked waiting for the signal?     
     */                                                               
    if (the_thread->Wait.option & mask)                               
4001bab4:	c4 00 60 30 	ld  [ %g1 + 0x30 ], %g2	! 4001e030 <__mprec_tinytens+0x8><== NOT EXECUTED
4001bab8:	80 8f 40 02 	btst  %i5, %g2                                 
4001babc:	02 bf ff f6 	be  4001ba94 <killinfo+0xdc>                   
4001bac0:	c6 00 61 50 	ld  [ %g1 + 0x150 ], %g3                       
                                                                      
  the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;                 
                                                                      
  for ( the_node = _Chain_First( the_chain );                         
        !_Chain_Is_tail( the_chain, the_node ) ;                      
        the_node = the_node->next ) {                                 
4001bac4:	90 10 00 01 	mov  %g1, %o0                                  
                                                                      
  /*                                                                  
   *  Returns true if the signal was synchronously given to a thread  
   *  blocked waiting for the signal.                                 
   */                                                                 
  if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) {  
4001bac8:	92 10 00 19 	mov  %i1, %o1                                  
4001bacc:	40 00 00 8b 	call  4001bcf8 <_POSIX_signals_Unblock_thread> 
4001bad0:	94 07 bf f4 	add  %fp, -12, %o2                             
4001bad4:	80 8a 20 ff 	btst  0xff, %o0                                
4001bad8:	12 80 00 09 	bne  4001bafc <killinfo+0x144>                 
4001badc:	01 00 00 00 	nop                                            
                                                                      
  /*                                                                  
   *  We may have woken up a thread but we definitely need to post the
   *  signal to the process wide information set.                     
   */                                                                 
  _POSIX_signals_Set_process_signals( mask );                         
4001bae0:	40 00 00 7d 	call  4001bcd4 <_POSIX_signals_Set_process_signals>
4001bae4:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {       
4001bae8:	a0 24 40 10 	sub  %l1, %l0, %l0                             
4001baec:	c2 06 00 10 	ld  [ %i0 + %l0 ], %g1                         
4001baf0:	80 a0 60 02 	cmp  %g1, 2                                    
4001baf4:	02 80 00 4f 	be  4001bc30 <killinfo+0x278>                  
4001baf8:	11 10 00 7d 	sethi  %hi(0x4001f400), %o0                    
  /*                                                                  
   *  Returns true if the signal was synchronously given to a thread  
   *  blocked waiting for the signal.                                 
   */                                                                 
  if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) {  
    _Thread_Enable_dispatch();                                        
4001bafc:	7f ff b8 f3 	call  40009ec8 <_Thread_Enable_dispatch>       
4001bb00:	b0 10 20 00 	clr  %i0                                       
4001bb04:	81 c7 e0 08 	ret                                            
4001bb08:	81 e8 00 00 	restore                                        
   *  P1003.1c/Draft 10, p. 33 says that certain signals should always
   *  be directed to the executing thread such as those caused by hardware
   *  faults.                                                         
   */                                                                 
  if ( (sig == SIGFPE) || (sig == SIGILL) || (sig == SIGSEGV ) )      
      return pthread_kill( pthread_self(), sig );                     
4001bb0c:	40 00 01 13 	call  4001bf58 <pthread_self>                  
4001bb10:	01 00 00 00 	nop                                            
4001bb14:	40 00 00 d2 	call  4001be5c <pthread_kill>                  
4001bb18:	92 10 00 19 	mov  %i1, %o1                                  
4001bb1c:	81 c7 e0 08 	ret                                            
4001bb20:	91 e8 00 08 	restore  %g0, %o0, %o0                         
   */                                                                 
  siginfo = &siginfo_struct;                                          
  siginfo->si_signo = sig;                                            
  siginfo->si_code = SI_USER;                                         
  if ( !value ) {                                                     
    siginfo->si_value.sival_int = 0;                                  
4001bb24:	10 bf ff c6 	b  4001ba3c <killinfo+0x84>                    
4001bb28:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
   *  NOTES:                                                          
   *                                                                  
   *    + rtems internal threads do not receive signals.              
   */                                                                 
  interested = NULL;                                                  
  interested_priority = PRIORITY_MAXIMUM + 1;                         
4001bb2c:	f8 08 62 dc 	ldub  [ %g1 + 0x2dc ], %i4                     
4001bb30:	1b 10 00 7b 	sethi  %hi(0x4001ec00), %o5                    
4001bb34:	b8 07 20 01 	inc  %i4                                       
4001bb38:	9a 13 62 2c 	or  %o5, 0x22c, %o5                            
   *                                                                  
   *  NOTES:                                                          
   *                                                                  
   *    + rtems internal threads do not receive signals.              
   */                                                                 
  interested = NULL;                                                  
4001bb3c:	90 10 20 00 	clr  %o0                                       
 */                                                                   
                                                                      
#define _POSIX_signals_Is_interested( _api, _mask ) \                 
  ( ~(_api)->signals_blocked & (_mask) )                              
                                                                      
int killinfo(                                                         
4001bb40:	98 03 60 08 	add  %o5, 8, %o4                               
 */                                                                   
RTEMS_INLINE_ROUTINE bool _States_Is_interruptible_by_signal (        
  States_Control the_states                                           
)                                                                     
{                                                                     
   return (the_states & STATES_INTERRUPTIBLE_BY_SIGNAL);              
4001bb44:	17 04 00 00 	sethi  %hi(0x10000000), %o3                    
  for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
                                                                      
    /*                                                                
     *  This can occur when no one is interested and an API is not configured.
     */                                                               
    if ( !_Objects_Information_table[ the_api ] )                     
4001bb48:	c2 03 40 00 	ld  [ %o5 ], %g1                               
4001bb4c:	80 a0 60 00 	cmp  %g1, 0                                    
4001bb50:	22 80 00 31 	be,a   4001bc14 <killinfo+0x25c>               <== NEVER TAKEN
4001bb54:	9a 03 60 04 	add  %o5, 4, %o5                               <== NOT EXECUTED
      continue;                                                       
                                                                      
    the_info = _Objects_Information_table[ the_api ][ 1 ];            
4001bb58:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
       */                                                             
      if ( !the_info )                                                
        continue;                                                     
    #endif                                                            
                                                                      
    maximum = the_info->maximum;                                      
4001bb5c:	f6 10 60 10 	lduh  [ %g1 + 0x10 ], %i3                      
    object_table = the_info->local_table;                             
                                                                      
    for ( index = 1 ; index <= maximum ; index++ ) {                  
4001bb60:	80 a6 e0 00 	cmp  %i3, 0                                    
4001bb64:	02 80 00 2b 	be  4001bc10 <killinfo+0x258>                  
4001bb68:	f4 00 60 1c 	ld  [ %g1 + 0x1c ], %i2                        
4001bb6c:	84 10 20 01 	mov  1, %g2                                    
 */                                                                   
                                                                      
#define _POSIX_signals_Is_interested( _api, _mask ) \                 
  ( ~(_api)->signals_blocked & (_mask) )                              
                                                                      
int killinfo(                                                         
4001bb70:	87 28 a0 02 	sll  %g2, 2, %g3                               
                                                                      
    maximum = the_info->maximum;                                      
    object_table = the_info->local_table;                             
                                                                      
    for ( index = 1 ; index <= maximum ; index++ ) {                  
      the_thread = (Thread_Control *) object_table[ index ];          
4001bb74:	c6 06 80 03 	ld  [ %i2 + %g3 ], %g3                         
                                                                      
      if ( !the_thread )                                              
4001bb78:	80 a0 e0 00 	cmp  %g3, 0                                    
4001bb7c:	22 80 00 22 	be,a   4001bc04 <killinfo+0x24c>               
4001bb80:	84 00 a0 01 	inc  %g2                                       
                                                                      
      /*                                                              
       *  If this thread is of lower priority than the interested thread,
       *  go on to the next thread.                                   
       */                                                             
      if ( the_thread->current_priority > interested_priority )       
4001bb84:	c8 00 e0 14 	ld  [ %g3 + 0x14 ], %g4                        
4001bb88:	80 a1 00 1c 	cmp  %g4, %i4                                  
4001bb8c:	38 80 00 1e 	bgu,a   4001bc04 <killinfo+0x24c>              
4001bb90:	84 00 a0 01 	inc  %g2                                       
      #if defined(RTEMS_DEBUG)                                        
        if ( !api )                                                   
          continue;                                                   
      #endif                                                          
                                                                      
      if ( !_POSIX_signals_Is_interested( api, mask ) )               
4001bb94:	de 00 e1 50 	ld  [ %g3 + 0x150 ], %o7                       
4001bb98:	de 03 e0 d0 	ld  [ %o7 + 0xd0 ], %o7                        
4001bb9c:	80 af 40 0f 	andncc  %i5, %o7, %g0                          
4001bba0:	22 80 00 19 	be,a   4001bc04 <killinfo+0x24c>               
4001bba4:	84 00 a0 01 	inc  %g2                                       
       *                                                              
       *  NOTE: We initialized interested_priority to PRIORITY_MAXIMUM + 1
       *        so we never have to worry about deferencing a NULL    
       *        interested thread.                                    
       */                                                             
      if ( the_thread->current_priority < interested_priority ) {     
4001bba8:	80 a1 00 1c 	cmp  %g4, %i4                                  
4001bbac:	2a 80 00 14 	bcs,a   4001bbfc <killinfo+0x244>              
4001bbb0:	b8 10 00 04 	mov  %g4, %i4                                  
       *  and blocking interruptibutable by signal.                   
       *                                                              
       *  If the interested thread is ready, don't think about changing.
       */                                                             
                                                                      
      if ( interested && !_States_Is_ready( interested->current_state ) ) {
4001bbb4:	80 a2 20 00 	cmp  %o0, 0                                    
4001bbb8:	22 80 00 13 	be,a   4001bc04 <killinfo+0x24c>               <== NEVER TAKEN
4001bbbc:	84 00 a0 01 	inc  %g2                                       <== NOT EXECUTED
4001bbc0:	c2 02 20 10 	ld  [ %o0 + 0x10 ], %g1                        
4001bbc4:	80 a0 60 00 	cmp  %g1, 0                                    
4001bbc8:	22 80 00 0f 	be,a   4001bc04 <killinfo+0x24c>               <== NEVER TAKEN
4001bbcc:	84 00 a0 01 	inc  %g2                                       <== NOT EXECUTED
        /* preferred ready over blocked */                            
        DEBUG_STEP("5");                                              
        if ( _States_Is_ready( the_thread->current_state ) ) {        
4001bbd0:	de 00 e0 10 	ld  [ %g3 + 0x10 ], %o7                        
4001bbd4:	80 a3 e0 00 	cmp  %o7, 0                                    
4001bbd8:	22 80 00 09 	be,a   4001bbfc <killinfo+0x244>               
4001bbdc:	b8 10 00 04 	mov  %g4, %i4                                  
          continue;                                                   
        }                                                             
                                                                      
        DEBUG_STEP("6");                                              
        /* prefer blocked/interruptible over blocked/not interruptible */
        if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
4001bbe0:	80 88 40 0b 	btst  %g1, %o3                                 
4001bbe4:	32 80 00 08 	bne,a   4001bc04 <killinfo+0x24c>              
4001bbe8:	84 00 a0 01 	inc  %g2                                       
          DEBUG_STEP("7");                                            
          if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
4001bbec:	80 8b c0 0b 	btst  %o7, %o3                                 
4001bbf0:	22 80 00 05 	be,a   4001bc04 <killinfo+0x24c>               
4001bbf4:	84 00 a0 01 	inc  %g2                                       
       */                                                             
                                                                      
      if ( interested && !_States_Is_ready( interested->current_state ) ) {
        /* preferred ready over blocked */                            
        DEBUG_STEP("5");                                              
        if ( _States_Is_ready( the_thread->current_state ) ) {        
4001bbf8:	b8 10 00 04 	mov  %g4, %i4                                  
4001bbfc:	90 10 00 03 	mov  %g3, %o0                                  
    #endif                                                            
                                                                      
    maximum = the_info->maximum;                                      
    object_table = the_info->local_table;                             
                                                                      
    for ( index = 1 ; index <= maximum ; index++ ) {                  
4001bc00:	84 00 a0 01 	inc  %g2                                       
4001bc04:	80 a6 c0 02 	cmp  %i3, %g2                                  
4001bc08:	1a bf ff db 	bcc  4001bb74 <killinfo+0x1bc>                 
4001bc0c:	87 28 a0 02 	sll  %g2, 2, %g3                               
4001bc10:	9a 03 60 04 	add  %o5, 4, %o5                               
   *    + rtems internal threads do not receive signals.              
   */                                                                 
  interested = NULL;                                                  
  interested_priority = PRIORITY_MAXIMUM + 1;                         
                                                                      
  for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
4001bc14:	80 a3 40 0c 	cmp  %o5, %o4                                  
4001bc18:	32 bf ff cd 	bne,a   4001bb4c <killinfo+0x194>              
4001bc1c:	c2 03 40 00 	ld  [ %o5 ], %g1                               
        }                                                             
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if ( interested ) {                                                 
4001bc20:	80 a2 20 00 	cmp  %o0, 0                                    
4001bc24:	12 bf ff aa 	bne  4001bacc <killinfo+0x114>                 
4001bc28:	92 10 00 19 	mov  %i1, %o1                                  
4001bc2c:	30 bf ff ad 	b,a   4001bae0 <killinfo+0x128>                
   */                                                                 
  _POSIX_signals_Set_process_signals( mask );                         
                                                                      
  if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {       
                                                                      
    psiginfo = (POSIX_signals_Siginfo_node *)                         
4001bc30:	7f ff b0 b7 	call  40007f0c <_Chain_Get>                    
4001bc34:	90 12 21 b0 	or  %o0, 0x1b0, %o0                            
               _Chain_Get( &_POSIX_signals_Inactive_siginfo );        
    if ( !psiginfo ) {                                                
4001bc38:	92 92 20 00 	orcc  %o0, 0, %o1                              
4001bc3c:	02 80 00 1e 	be  4001bcb4 <killinfo+0x2fc>                  
4001bc40:	c2 07 bf f4 	ld  [ %fp + -12 ], %g1                         
      rtems_set_errno_and_return_minus_one( EAGAIN );                 
    }                                                                 
                                                                      
    psiginfo->Info = *siginfo;                                        
                                                                      
    _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 
4001bc44:	11 10 00 7d 	sethi  %hi(0x4001f400), %o0                    
    if ( !psiginfo ) {                                                
      _Thread_Enable_dispatch();                                      
      rtems_set_errno_and_return_minus_one( EAGAIN );                 
    }                                                                 
                                                                      
    psiginfo->Info = *siginfo;                                        
4001bc48:	c2 22 60 08 	st  %g1, [ %o1 + 8 ]                           
4001bc4c:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
                                                                      
    _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 
4001bc50:	90 12 22 28 	or  %o0, 0x228, %o0                            
    if ( !psiginfo ) {                                                
      _Thread_Enable_dispatch();                                      
      rtems_set_errno_and_return_minus_one( EAGAIN );                 
    }                                                                 
                                                                      
    psiginfo->Info = *siginfo;                                        
4001bc54:	c2 22 60 0c 	st  %g1, [ %o1 + 0xc ]                         
4001bc58:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
                                                                      
    _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 
4001bc5c:	90 02 00 10 	add  %o0, %l0, %o0                             
    if ( !psiginfo ) {                                                
      _Thread_Enable_dispatch();                                      
      rtems_set_errno_and_return_minus_one( EAGAIN );                 
    }                                                                 
                                                                      
    psiginfo->Info = *siginfo;                                        
4001bc60:	c2 22 60 10 	st  %g1, [ %o1 + 0x10 ]                        
                                                                      
    _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 
4001bc64:	7f ff b0 9f 	call  40007ee0 <_Chain_Append>                 
4001bc68:	b0 10 20 00 	clr  %i0                                       
  /*                                                                  
   *  Returns true if the signal was synchronously given to a thread  
   *  blocked waiting for the signal.                                 
   */                                                                 
  if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) {  
    _Thread_Enable_dispatch();                                        
4001bc6c:	7f ff b8 97 	call  40009ec8 <_Thread_Enable_dispatch>       
4001bc70:	01 00 00 00 	nop                                            
4001bc74:	81 c7 e0 08 	ret                                            
4001bc78:	81 e8 00 00 	restore                                        
  }                                                                   
                                                                      
  DEBUG_STEP("\n");                                                   
  _Thread_Enable_dispatch();                                          
  return 0;                                                           
}                                                                     
4001bc7c:	81 c7 e0 08 	ret                                            
4001bc80:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      
  /*                                                                  
   *  Only supported for the "calling process" (i.e. this node).      
   */                                                                 
  if ( pid != getpid() )                                              
    rtems_set_errno_and_return_minus_one( ESRCH );                    
4001bc84:	7f ff ce af 	call  4000f740 <__errno>                       
4001bc88:	b0 10 3f ff 	mov  -1, %i0                                   
4001bc8c:	82 10 20 03 	mov  3, %g1                                    
4001bc90:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4001bc94:	81 c7 e0 08 	ret                                            
4001bc98:	81 e8 00 00 	restore                                        
   */                                                                 
  if ( !sig )                                                         
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( !is_valid_signo(sig) )                                         
    rtems_set_errno_and_return_minus_one( EINVAL );                   
4001bc9c:	7f ff ce a9 	call  4000f740 <__errno>                       
4001bca0:	b0 10 3f ff 	mov  -1, %i0                                   
4001bca4:	82 10 20 16 	mov  0x16, %g1                                 
4001bca8:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4001bcac:	81 c7 e0 08 	ret                                            
4001bcb0:	81 e8 00 00 	restore                                        
  if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {       
                                                                      
    psiginfo = (POSIX_signals_Siginfo_node *)                         
               _Chain_Get( &_POSIX_signals_Inactive_siginfo );        
    if ( !psiginfo ) {                                                
      _Thread_Enable_dispatch();                                      
4001bcb4:	7f ff b8 85 	call  40009ec8 <_Thread_Enable_dispatch>       
4001bcb8:	b0 10 3f ff 	mov  -1, %i0                                   
      rtems_set_errno_and_return_minus_one( EAGAIN );                 
4001bcbc:	7f ff ce a1 	call  4000f740 <__errno>                       
4001bcc0:	01 00 00 00 	nop                                            
4001bcc4:	82 10 20 0b 	mov  0xb, %g1	! b <PROM_START+0xb>             
4001bcc8:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4001bccc:	81 c7 e0 08 	ret                                            
4001bcd0:	81 e8 00 00 	restore                                        
                                                                      

400038f4 <libc_wrapup>: extern void _wrapup_reent(struct _reent *); extern void _reclaim_reent(struct _reent *); void libc_wrapup(void) {
400038f4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  /*                                                                  
   *  In case RTEMS is already down, don't do this.  It could be      
   *  dangerous.                                                      
   */                                                                 
                                                                      
  if (!_System_state_Is_up(_System_state_Get()))                      
400038f8:	03 10 00 7c 	sethi  %hi(0x4001f000), %g1                    
400038fc:	c2 00 63 c8 	ld  [ %g1 + 0x3c8 ], %g1	! 4001f3c8 <_System_state_Current>
40003900:	80 a0 60 03 	cmp  %g1, 3                                    
40003904:	02 80 00 04 	be  40003914 <libc_wrapup+0x20>                <== ALWAYS TAKEN
40003908:	3b 10 00 79 	sethi  %hi(0x4001e400), %i5                    
4000390c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40003910:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  /*                                                                  
   *  This was already done if the user called exit() directly .      
  _wrapup_reent(0);                                                   
   */                                                                 
                                                                      
  if (_REENT != _global_impure_ptr) {                                 
40003914:	05 10 00 76 	sethi  %hi(0x4001d800), %g2                    
40003918:	c2 07 61 68 	ld  [ %i5 + 0x168 ], %g1                       
4000391c:	f8 00 a0 b0 	ld  [ %g2 + 0xb0 ], %i4                        
40003920:	80 a0 40 1c 	cmp  %g1, %i4                                  
40003924:	02 80 00 05 	be  40003938 <libc_wrapup+0x44>                
40003928:	01 00 00 00 	nop                                            
      _wrapup_reent(_global_impure_ptr);                              
4000392c:	40 00 32 b4 	call  400103fc <_wrapup_reent>                 
40003930:	90 10 00 1c 	mov  %i4, %o0                                  
      /*  Don't reclaim this one, just in case we do printfs          
       *  on the way out to ROM.                                      
       */                                                             
      _reclaim_reent(&libc_global_reent);                             
#endif                                                                
      _REENT = _global_impure_ptr;                                    
40003934:	f8 27 61 68 	st  %i4, [ %i5 + 0x168 ]                       
   *                                                                  
   * Should this be changed to do *all* file streams?                 
   *    _fwalk (_REENT, fclose);                                      
   */                                                                 
                                                                      
  fclose (stdin);                                                     
40003938:	40 00 2f d4 	call  4000f888 <fclose>                        
4000393c:	d0 07 20 04 	ld  [ %i4 + 4 ], %o0                           
  fclose (stdout);                                                    
40003940:	c2 07 61 68 	ld  [ %i5 + 0x168 ], %g1                       
40003944:	40 00 2f d1 	call  4000f888 <fclose>                        
40003948:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           
  fclose (stderr);                                                    
4000394c:	c2 07 61 68 	ld  [ %i5 + 0x168 ], %g1                       
40003950:	f0 00 60 0c 	ld  [ %g1 + 0xc ], %i0                         
40003954:	40 00 2f cd 	call  4000f888 <fclose>                        
40003958:	81 e8 00 00 	restore                                        
                                                                      

40003390 <malloc>: #include "malloc_p.h" void *malloc( size_t size ) {
40003390:	9d e3 bf a0 	save  %sp, -96, %sp                            
  void        *return_this;                                           
                                                                      
  MSBUMP(malloc_calls, 1);                                            
40003394:	03 10 00 7b 	sethi  %hi(0x4001ec00), %g1                    
40003398:	82 10 61 40 	or  %g1, 0x140, %g1	! 4001ed40 <rtems_malloc_statistics>
4000339c:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
400033a0:	84 00 a0 01 	inc  %g2                                       
                                                                      
  /*                                                                  
   *  If some free's have been deferred, then do them now.            
   */                                                                 
  malloc_deferred_frees_process();                                    
400033a4:	7f ff ff b8 	call  40003284 <malloc_deferred_frees_process> 
400033a8:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
                                                                      
  /*                                                                  
   * Validate the parameters                                          
   */                                                                 
  if ( !size )                                                        
400033ac:	80 a6 20 00 	cmp  %i0, 0                                    
400033b0:	02 80 00 25 	be  40003444 <malloc+0xb4>                     
400033b4:	03 10 00 7c 	sethi  %hi(0x4001f000), %g1                    
    return (void *) 0;                                                
                                                                      
  /*                                                                  
   *  Do not attempt to allocate memory if not in correct system state.
   */                                                                 
  if ( _System_state_Is_up(_System_state_Get()) &&                    
400033b8:	c2 00 63 c8 	ld  [ %g1 + 0x3c8 ], %g1	! 4001f3c8 <_System_state_Current>
400033bc:	80 a0 60 03 	cmp  %g1, 3                                    
400033c0:	02 80 00 1c 	be  40003430 <malloc+0xa0>                     
400033c4:	39 10 00 78 	sethi  %hi(0x4001e000), %i4                    
RTEMS_INLINE_ROUTINE void *_Protected_heap_Allocate(                  
  Heap_Control *heap,                                                 
  uintptr_t size                                                      
)                                                                     
{                                                                     
  return _Protected_heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
400033c8:	d0 07 23 60 	ld  [ %i4 + 0x360 ], %o0	! 4001e360 <RTEMS_Malloc_Heap>
400033cc:	92 10 00 18 	mov  %i0, %o1                                  
400033d0:	94 10 20 00 	clr  %o2                                       
400033d4:	40 00 17 a4 	call  40009264 <_Protected_heap_Allocate_aligned_with_boundary>
400033d8:	96 10 20 00 	clr  %o3                                       
   * If this fails then return a NULL pointer.                        
   */                                                                 
                                                                      
  return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );  
                                                                      
  if ( !return_this ) {                                               
400033dc:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400033e0:	02 80 00 1c 	be  40003450 <malloc+0xc0>                     
400033e4:	d0 07 23 60 	ld  [ %i4 + 0x360 ], %o0                       
  }                                                                   
                                                                      
  /*                                                                  
   *  If the user wants us to dirty the allocated memory, then do it. 
   */                                                                 
  if ( rtems_malloc_dirty_helper )                                    
400033e8:	03 10 00 7a 	sethi  %hi(0x4001e800), %g1                    
400033ec:	c2 00 62 8c 	ld  [ %g1 + 0x28c ], %g1	! 4001ea8c <rtems_malloc_dirty_helper>
400033f0:	80 a0 60 00 	cmp  %g1, 0                                    
400033f4:	02 80 00 04 	be  40003404 <malloc+0x74>                     
400033f8:	90 10 00 1d 	mov  %i5, %o0                                  
    (*rtems_malloc_dirty_helper)( return_this, size );                
400033fc:	9f c0 40 00 	call  %g1                                      
40003400:	92 10 00 18 	mov  %i0, %o1                                  
                                                                      
  /*                                                                  
   *  If configured, update the statistics                            
   */                                                                 
  if ( rtems_malloc_statistics_helpers )                              
40003404:	03 10 00 7a 	sethi  %hi(0x4001e800), %g1                    
40003408:	c2 00 62 90 	ld  [ %g1 + 0x290 ], %g1	! 4001ea90 <rtems_malloc_statistics_helpers>
4000340c:	80 a0 60 00 	cmp  %g1, 0                                    
40003410:	22 80 00 06 	be,a   40003428 <malloc+0x98>                  
40003414:	b0 10 00 1d 	mov  %i5, %i0                                  
    (*rtems_malloc_statistics_helpers->at_malloc)(return_this);       
40003418:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
4000341c:	9f c0 40 00 	call  %g1                                      
40003420:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  return return_this;                                                 
}                                                                     
40003424:	b0 10 00 1d 	mov  %i5, %i0                                  
40003428:	81 c7 e0 08 	ret                                            
4000342c:	81 e8 00 00 	restore                                        
                                                                      
  /*                                                                  
   *  Do not attempt to allocate memory if not in correct system state.
   */                                                                 
  if ( _System_state_Is_up(_System_state_Get()) &&                    
       !malloc_is_system_state_OK() )                                 
40003430:	7f ff ff 88 	call  40003250 <malloc_is_system_state_OK>     
40003434:	01 00 00 00 	nop                                            
    return (void *) 0;                                                
                                                                      
  /*                                                                  
   *  Do not attempt to allocate memory if not in correct system state.
   */                                                                 
  if ( _System_state_Is_up(_System_state_Get()) &&                    
40003438:	80 8a 20 ff 	btst  0xff, %o0                                
4000343c:	12 bf ff e3 	bne  400033c8 <malloc+0x38>                    <== ALWAYS TAKEN
40003440:	01 00 00 00 	nop                                            
                                                                      
  /*                                                                  
   * Validate the parameters                                          
   */                                                                 
  if ( !size )                                                        
    return (void *) 0;                                                
40003444:	ba 10 20 00 	clr  %i5	! 0 <PROM_START>                      
   */                                                                 
  if ( rtems_malloc_statistics_helpers )                              
    (*rtems_malloc_statistics_helpers->at_malloc)(return_this);       
                                                                      
  return return_this;                                                 
}                                                                     
40003448:	81 c7 e0 08 	ret                                            
4000344c:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
   */                                                                 
                                                                      
  return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );  
                                                                      
  if ( !return_this ) {                                               
    return_this = (*rtems_malloc_extend_handler)( RTEMS_Malloc_Heap, size );
40003450:	03 10 00 71 	sethi  %hi(0x4001c400), %g1                    
40003454:	c2 00 60 60 	ld  [ %g1 + 0x60 ], %g1	! 4001c460 <rtems_malloc_extend_handler>
40003458:	9f c0 40 00 	call  %g1                                      
4000345c:	92 10 00 18 	mov  %i0, %o1                                  
    if ( !return_this ) {                                             
40003460:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40003464:	12 bf ff e2 	bne  400033ec <malloc+0x5c>                    <== NEVER TAKEN
40003468:	03 10 00 7a 	sethi  %hi(0x4001e800), %g1                    
      errno = ENOMEM;                                                 
4000346c:	40 00 30 b5 	call  4000f740 <__errno>                       
40003470:	b0 10 00 1d 	mov  %i5, %i0                                  
40003474:	82 10 20 0c 	mov  0xc, %g1                                  
40003478:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4000347c:	81 c7 e0 08 	ret                                            
40003480:	81 e8 00 00 	restore                                        
                                                                      

4000dc0c <memfile_alloc_block>: * Allocate a block for an in-memory file. */ int memfile_blocks_allocated = 0; void *memfile_alloc_block(void) {
4000dc0c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  void *memory;                                                       
                                                                      
  memory = (void *)calloc(1, IMFS_MEMFILE_BYTES_PER_BLOCK);           
4000dc10:	03 10 00 7a 	sethi  %hi(0x4001e800), %g1                    
4000dc14:	d2 00 62 a0 	ld  [ %g1 + 0x2a0 ], %o1	! 4001eaa0 <imfs_memfile_bytes_per_block>
4000dc18:	7f ff d4 55 	call  40002d6c <calloc>                        
4000dc1c:	90 10 20 01 	mov  1, %o0                                    
  if ( memory )                                                       
4000dc20:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4000dc24:	02 80 00 05 	be  4000dc38 <memfile_alloc_block+0x2c>        <== NEVER TAKEN
4000dc28:	03 10 00 7a 	sethi  %hi(0x4001e800), %g1                    
    memfile_blocks_allocated++;                                       
4000dc2c:	c4 00 63 b4 	ld  [ %g1 + 0x3b4 ], %g2	! 4001ebb4 <memfile_blocks_allocated>
4000dc30:	84 00 a0 01 	inc  %g2                                       
4000dc34:	c4 20 63 b4 	st  %g2, [ %g1 + 0x3b4 ]                       
                                                                      
  return memory;                                                      
}                                                                     
4000dc38:	81 c7 e0 08 	ret                                            
4000dc3c:	81 e8 00 00 	restore                                        
                                                                      

4000e184 <memfile_free_blocks_in_table>: */ static void memfile_free_blocks_in_table( block_p **block_table, int entries ) {
4000e184:	9d e3 bf a0 	save  %sp, -96, %sp                            
  /*                                                                  
   *  Now go through all the slots in the table and free the memory.  
   */                                                                 
  b = *block_table;                                                   
                                                                      
  for ( i=0 ; i<entries ; i++ ) {                                     
4000e188:	80 a6 60 00 	cmp  %i1, 0                                    
4000e18c:	04 80 00 0f 	ble  4000e1c8 <memfile_free_blocks_in_table+0x44><== NEVER TAKEN
4000e190:	d0 06 00 00 	ld  [ %i0 ], %o0                               
4000e194:	ba 10 00 08 	mov  %o0, %i5                                  
4000e198:	b8 10 20 00 	clr  %i4                                       
    if ( b[i] ) {                                                     
4000e19c:	d0 07 40 00 	ld  [ %i5 ], %o0                               
4000e1a0:	80 a2 20 00 	cmp  %o0, 0                                    
4000e1a4:	02 80 00 05 	be  4000e1b8 <memfile_free_blocks_in_table+0x34>
4000e1a8:	b8 07 20 01 	inc  %i4                                       
      memfile_free_block( b[i] );                                     
4000e1ac:	7f ff ff ed 	call  4000e160 <memfile_free_block>            
4000e1b0:	01 00 00 00 	nop                                            
      b[i] = 0;                                                       
4000e1b4:	c0 27 40 00 	clr  [ %i5 ]                                   
  /*                                                                  
   *  Now go through all the slots in the table and free the memory.  
   */                                                                 
  b = *block_table;                                                   
                                                                      
  for ( i=0 ; i<entries ; i++ ) {                                     
4000e1b8:	80 a7 00 19 	cmp  %i4, %i1                                  
4000e1bc:	12 bf ff f8 	bne  4000e19c <memfile_free_blocks_in_table+0x18>
4000e1c0:	ba 07 60 04 	add  %i5, 4, %i5                               
4000e1c4:	d0 06 00 00 	ld  [ %i0 ], %o0                               
                                                                      
  /*                                                                  
   *  Now that all the blocks in the block table are free, we can     
   *  free the block table itself.                                    
   */                                                                 
  memfile_free_block( *block_table );                                 
4000e1c8:	7f ff ff e6 	call  4000e160 <memfile_free_block>            
4000e1cc:	01 00 00 00 	nop                                            
  *block_table = 0;                                                   
4000e1d0:	c0 26 00 00 	clr  [ %i0 ]                                   
4000e1d4:	81 c7 e0 08 	ret                                            
4000e1d8:	81 e8 00 00 	restore                                        
                                                                      

4000e818 <memfile_ftruncate>: int memfile_ftruncate( rtems_libio_t *iop, off_t length ) {
4000e818:	9d e3 bf 98 	save  %sp, -104, %sp                           <== NOT EXECUTED
  IMFS_jnode_t   *the_jnode;                                          
                                                                      
  the_jnode = iop->pathinfo.node_access;                              
4000e81c:	fa 06 20 1c 	ld  [ %i0 + 0x1c ], %i5                        <== NOT EXECUTED
   *  POSIX 1003.1b does not specify what happens if you truncate a file
   *  and the new length is greater than the current size.  We treat this
   *  as an extend operation.                                         
   */                                                                 
                                                                      
  if ( length > the_jnode->info.file.size )                           
4000e820:	c2 07 60 50 	ld  [ %i5 + 0x50 ], %g1                        <== NOT EXECUTED
4000e824:	80 a0 40 19 	cmp  %g1, %i1                                  <== NOT EXECUTED
4000e828:	06 80 00 11 	bl  4000e86c <memfile_ftruncate+0x54>          <== NOT EXECUTED
4000e82c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4000e830:	22 80 00 0b 	be,a   4000e85c <memfile_ftruncate+0x44>       <== NOT EXECUTED
4000e834:	c2 07 60 54 	ld  [ %i5 + 0x54 ], %g1                        <== 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;                                 
4000e838:	f2 27 60 50 	st  %i1, [ %i5 + 0x50 ]                        <== NOT EXECUTED
4000e83c:	f4 27 60 54 	st  %i2, [ %i5 + 0x54 ]                        <== NOT EXECUTED
                                                                      
  IMFS_update_atime( the_jnode );                                     
4000e840:	90 07 bf f8 	add  %fp, -8, %o0                              <== NOT EXECUTED
4000e844:	7f ff d2 23 	call  400030d0 <gettimeofday>                  <== NOT EXECUTED
4000e848:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4000e84c:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          <== NOT EXECUTED
4000e850:	c2 27 60 40 	st  %g1, [ %i5 + 0x40 ]                        <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
4000e854:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000e858:	91 e8 20 00 	restore  %g0, 0, %o0                           <== NOT EXECUTED
   *  POSIX 1003.1b does not specify what happens if you truncate a file
   *  and the new length is greater than the current size.  We treat this
   *  as an extend operation.                                         
   */                                                                 
                                                                      
  if ( length > the_jnode->info.file.size )                           
4000e85c:	80 a0 40 1a 	cmp  %g1, %i2                                  <== NOT EXECUTED
4000e860:	3a bf ff f7 	bcc,a   4000e83c <memfile_ftruncate+0x24>      <== NOT EXECUTED
4000e864:	f2 27 60 50 	st  %i1, [ %i5 + 0x50 ]                        <== NOT EXECUTED
    return IMFS_memfile_extend( the_jnode, true, length );            
4000e868:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4000e86c:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
4000e870:	94 10 00 19 	mov  %i1, %o2                                  <== NOT EXECUTED
4000e874:	7f ff fe c4 	call  4000e384 <IMFS_memfile_extend>           <== NOT EXECUTED
4000e878:	96 10 00 1a 	mov  %i2, %o3                                  <== NOT EXECUTED
4000e87c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000e880:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
                                                                      

4000e79c <memfile_open>: rtems_libio_t *iop, const char *pathname, int oflag, mode_t mode ) {
4000e79c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  the_jnode = iop->pathinfo.node_access;                              
                                                                      
  /*                                                                  
   * Perform 'copy on write' for linear files                         
   */                                                                 
  if ((iop->flags & LIBIO_FLAGS_WRITE)                                
4000e7a0:	c2 06 20 10 	ld  [ %i0 + 0x10 ], %g1                        
4000e7a4:	80 88 60 04 	btst  4, %g1                                   
4000e7a8:	02 80 00 07 	be  4000e7c4 <memfile_open+0x28>               
4000e7ac:	d0 06 20 1c 	ld  [ %i0 + 0x1c ], %o0                        
4000e7b0:	c2 02 20 4c 	ld  [ %o0 + 0x4c ], %g1                        
   && (IMFS_type( the_jnode ) == IMFS_LINEAR_FILE)) {                 
4000e7b4:	c2 00 40 00 	ld  [ %g1 ], %g1                               
4000e7b8:	80 a0 60 05 	cmp  %g1, 5                                    
4000e7bc:	22 80 00 04 	be,a   4000e7cc <memfile_open+0x30>            <== NEVER TAKEN
4000e7c0:	d8 02 20 54 	ld  [ %o0 + 0x54 ], %o4                        <== NOT EXECUTED
    if ((count != 0)                                                  
     && (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))      
        return -1;                                                    
  }                                                                   
                                                                      
  return 0;                                                           
4000e7c4:	81 c7 e0 08 	ret                                            
4000e7c8:	91 e8 20 00 	restore  %g0, 0, %o0                           
   * Perform 'copy on write' for linear files                         
   */                                                                 
  if ((iop->flags & LIBIO_FLAGS_WRITE)                                
   && (IMFS_type( the_jnode ) == IMFS_LINEAR_FILE)) {                 
    uint32_t   count = the_jnode->info.linearfile.size;               
    const unsigned char *buffer = the_jnode->info.linearfile.direct;  
4000e7cc:	d6 02 20 58 	ld  [ %o0 + 0x58 ], %o3                        <== NOT EXECUTED
                                                                      
    the_jnode->control = &IMFS_node_control_memfile;                  
4000e7d0:	03 10 00 74 	sethi  %hi(0x4001d000), %g1                    <== NOT EXECUTED
    the_jnode->info.file.size            = 0;                         
4000e7d4:	c0 22 20 50 	clr  [ %o0 + 0x50 ]                            <== NOT EXECUTED
  if ((iop->flags & LIBIO_FLAGS_WRITE)                                
   && (IMFS_type( the_jnode ) == IMFS_LINEAR_FILE)) {                 
    uint32_t   count = the_jnode->info.linearfile.size;               
    const unsigned char *buffer = the_jnode->info.linearfile.direct;  
                                                                      
    the_jnode->control = &IMFS_node_control_memfile;                  
4000e7d8:	82 10 62 dc 	or  %g1, 0x2dc, %g1                            <== NOT EXECUTED
    the_jnode->info.file.size            = 0;                         
4000e7dc:	c0 22 20 54 	clr  [ %o0 + 0x54 ]                            <== NOT EXECUTED
    the_jnode->info.file.indirect        = 0;                         
4000e7e0:	c0 22 20 58 	clr  [ %o0 + 0x58 ]                            <== NOT EXECUTED
  if ((iop->flags & LIBIO_FLAGS_WRITE)                                
   && (IMFS_type( the_jnode ) == IMFS_LINEAR_FILE)) {                 
    uint32_t   count = the_jnode->info.linearfile.size;               
    const unsigned char *buffer = the_jnode->info.linearfile.direct;  
                                                                      
    the_jnode->control = &IMFS_node_control_memfile;                  
4000e7e4:	c2 22 20 4c 	st  %g1, [ %o0 + 0x4c ]                        <== NOT EXECUTED
    the_jnode->info.file.size            = 0;                         
    the_jnode->info.file.indirect        = 0;                         
    the_jnode->info.file.doubly_indirect = 0;                         
4000e7e8:	c0 22 20 5c 	clr  [ %o0 + 0x5c ]                            <== NOT EXECUTED
    the_jnode->info.file.triply_indirect = 0;                         
    if ((count != 0)                                                  
4000e7ec:	80 a3 20 00 	cmp  %o4, 0                                    <== NOT EXECUTED
4000e7f0:	02 bf ff f5 	be  4000e7c4 <memfile_open+0x28>               <== NOT EXECUTED
4000e7f4:	c0 22 20 60 	clr  [ %o0 + 0x60 ]                            <== NOT EXECUTED
     && (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))      
4000e7f8:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4000e7fc:	7f ff ff 53 	call  4000e548 <IMFS_memfile_write>            <== NOT EXECUTED
4000e800:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
        return -1;                                                    
4000e804:	90 38 00 08 	xnor  %g0, %o0, %o0                            <== NOT EXECUTED
4000e808:	80 a0 00 08 	cmp  %g0, %o0                                  <== NOT EXECUTED
4000e80c:	b0 40 3f ff 	addx  %g0, -1, %i0                             <== NOT EXECUTED
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
4000e810:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000e814:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

400035a8 <mount>: const char *target, const char *filesystemtype, rtems_filesystem_options_t options, const void *data ) {
400035a8:	9d e3 bf 50 	save  %sp, -176, %sp                           
  int rv = 0;                                                         
                                                                      
  if (                                                                
400035ac:	80 a6 e0 01 	cmp  %i3, 1                                    
400035b0:	18 80 00 9a 	bgu  40003818 <mount+0x270>                    
400035b4:	01 00 00 00 	nop                                            
    options == RTEMS_FILESYSTEM_READ_ONLY                             
      || options == RTEMS_FILESYSTEM_READ_WRITE                       
  ) {                                                                 
    rtems_filesystem_fsmount_me_t fsmount_me_h =                      
400035b8:	40 00 22 ad 	call  4000c06c <rtems_filesystem_get_mount_handler>
400035bc:	90 10 00 1a 	mov  %i2, %o0                                  
      rtems_filesystem_get_mount_handler( filesystemtype );           
                                                                      
    if ( fsmount_me_h != NULL ) {                                     
400035c0:	a4 92 20 00 	orcc  %o0, 0, %l2                              
400035c4:	02 80 00 95 	be  40003818 <mount+0x270>                     
400035c8:	80 a6 60 00 	cmp  %i1, 0                                    
  const char *target_or_null,                                         
  const char *filesystemtype,                                         
  size_t *target_length_ptr                                           
)                                                                     
{                                                                     
  const char *target = target_or_null != NULL ? target_or_null : "/"; 
400035cc:	02 80 00 7b 	be  400037b8 <mount+0x210>                     
400035d0:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
                                                                      
int mount(                                                            
400035d4:	40 00 35 c0 	call  40010cd4 <strlen>                        
400035d8:	90 10 00 19 	mov  %i1, %o0                                  
400035dc:	a6 02 20 01 	add  %o0, 1, %l3                               
  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;          
400035e0:	40 00 35 bd 	call  40010cd4 <strlen>                        
400035e4:	90 10 00 1a 	mov  %i2, %o0                                  
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
                                                                      
int mount(                                                            
400035e8:	aa 10 00 19 	mov  %i1, %l5                                  
  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;          
400035ec:	ba 10 00 08 	mov  %o0, %i5                                  
  size_t source_size = source_or_null != NULL ?                       
    strlen( source_or_null ) + 1 : 0;                                 
400035f0:	80 a6 20 00 	cmp  %i0, 0                                    
400035f4:	02 80 00 7a 	be  400037dc <mount+0x234>                     
400035f8:	a8 02 20 01 	add  %o0, 1, %l4                               
  size_t target_size = strlen( target ) + 1;                          
  size_t size = sizeof( rtems_filesystem_mount_table_entry_t )        
    + filesystemtype_size + source_size + target_size                 
400035fc:	ba 07 40 13 	add  %i5, %l3, %i5                             
)                                                                     
{                                                                     
  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;                                 
40003600:	40 00 35 b5 	call  40010cd4 <strlen>                        
40003604:	90 10 00 18 	mov  %i0, %o0                                  
  size_t target_size = strlen( target ) + 1;                          
  size_t size = sizeof( rtems_filesystem_mount_table_entry_t )        
    + filesystemtype_size + source_size + target_size                 
40003608:	92 07 60 65 	add  %i5, 0x65, %o1                            
)                                                                     
{                                                                     
  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;                                 
4000360c:	a2 02 20 01 	add  %o0, 1, %l1                               
  size_t target_size = strlen( target ) + 1;                          
  size_t size = sizeof( rtems_filesystem_mount_table_entry_t )        
    + filesystemtype_size + source_size + target_size                 
    + sizeof( rtems_filesystem_global_location_t );                   
  rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size ); 
40003610:	90 10 20 01 	mov  1, %o0                                    
40003614:	7f ff fd d6 	call  40002d6c <calloc>                        
40003618:	92 02 40 11 	add  %o1, %l1, %o1                             
                                                                      
  if ( mt_entry != NULL ) {                                           
4000361c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40003620:	02 80 00 78 	be  40003800 <mount+0x258>                     <== NEVER TAKEN
40003624:	a0 07 60 64 	add  %i5, 0x64, %l0                            
    rtems_filesystem_global_location_t *mt_fs_root =                  
      (rtems_filesystem_global_location_t *)                          
        ((char *) mt_entry + sizeof( *mt_entry ));                    
    char *str = (char *) mt_fs_root + sizeof( *mt_fs_root );          
                                                                      
    memcpy( str, filesystemtype, filesystemtype_size );               
40003628:	92 10 00 1a 	mov  %i2, %o1                                  
4000362c:	90 10 00 10 	mov  %l0, %o0                                  
40003630:	40 00 32 95 	call  40010084 <memcpy>                        
40003634:	94 10 00 14 	mov  %l4, %o2                                  
    mt_entry->type = str;                                             
40003638:	e0 27 60 34 	st  %l0, [ %i5 + 0x34 ]                        
    + filesystemtype_size + source_size + target_size                 
    + sizeof( rtems_filesystem_global_location_t );                   
  rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size ); 
                                                                      
  if ( mt_entry != NULL ) {                                           
    rtems_filesystem_global_location_t *mt_fs_root =                  
4000363c:	ac 07 60 40 	add  %i5, 0x40, %l6                            
                                                                      
    memcpy( str, filesystemtype, filesystemtype_size );               
    mt_entry->type = str;                                             
    str += filesystemtype_size;                                       
                                                                      
    if ( source_or_null != NULL ) {                                   
40003640:	80 a6 20 00 	cmp  %i0, 0                                    
40003644:	02 80 00 08 	be  40003664 <mount+0xbc>                      
40003648:	b4 04 00 14 	add  %l0, %l4, %i2                             
      memcpy( str, source_or_null, source_size );                     
4000364c:	90 10 00 1a 	mov  %i2, %o0                                  
40003650:	92 10 00 18 	mov  %i0, %o1                                  
40003654:	40 00 32 8c 	call  40010084 <memcpy>                        
40003658:	94 10 00 11 	mov  %l1, %o2                                  
      mt_entry->dev = str;                                            
4000365c:	f4 27 60 38 	st  %i2, [ %i5 + 0x38 ]                        
      str += source_size;                                             
40003660:	b4 06 80 11 	add  %i2, %l1, %i2                             
    }                                                                 
                                                                      
    memcpy( str, target, target_size );                               
40003664:	92 10 00 15 	mov  %l5, %o1                                  
40003668:	94 10 00 13 	mov  %l3, %o2                                  
4000366c:	40 00 32 86 	call  40010084 <memcpy>                        
40003670:	90 10 00 1a 	mov  %i2, %o0                                  
    mt_entry->target = str;                                           
    str += target_size;                                               
                                                                      
    mt_entry->mounted = true;                                         
40003674:	82 10 20 01 	mov  1, %g1                                    
40003678:	c2 2f 60 28 	stb  %g1, [ %i5 + 0x28 ]                       
    mt_entry->mt_fs_root = mt_fs_root;                                
    mt_entry->pathconf_limits_and_options = &rtems_filesystem_default_pathconf;
4000367c:	03 10 00 73 	sethi  %hi(0x4001cc00), %g1                    
40003680:	82 10 62 fc 	or  %g1, 0x2fc, %g1	! 4001cefc <rtems_filesystem_default_pathconf>
40003684:	c2 27 60 2c 	st  %g1, [ %i5 + 0x2c ]                        
                                                                      
    mt_fs_root->location.mt_entry = mt_entry;                         
    mt_fs_root->reference_count = 1;                                  
40003688:	82 10 20 01 	mov  1, %g1                                    
  void                *starting_address,                              
  size_t               number_nodes,                                  
  size_t               node_size                                      
)                                                                     
{                                                                     
  _Chain_Initialize( the_chain, starting_address, number_nodes, node_size );
4000368c:	90 07 60 14 	add  %i5, 0x14, %o0                            
40003690:	92 10 00 16 	mov  %l6, %o1                                  
40003694:	94 10 20 01 	mov  1, %o2                                    
40003698:	96 10 20 24 	mov  0x24, %o3                                 
4000369c:	c2 27 60 58 	st  %g1, [ %i5 + 0x58 ]                        
      mt_entry->dev = str;                                            
      str += source_size;                                             
    }                                                                 
                                                                      
    memcpy( str, target, target_size );                               
    mt_entry->target = str;                                           
400036a0:	f4 27 60 30 	st  %i2, [ %i5 + 0x30 ]                        
    str += target_size;                                               
                                                                      
    mt_entry->mounted = true;                                         
    mt_entry->mt_fs_root = mt_fs_root;                                
400036a4:	ec 27 60 24 	st  %l6, [ %i5 + 0x24 ]                        
400036a8:	40 00 12 29 	call  40007f4c <_Chain_Initialize>             
400036ac:	fa 27 60 54 	st  %i5, [ %i5 + 0x54 ]                        
      );                                                              
                                                                      
      if ( mt_entry != NULL ) {                                       
        mt_entry->writeable = options == RTEMS_FILESYSTEM_READ_WRITE; 
                                                                      
        rv = (*fsmount_me_h)( mt_entry, data );                       
400036b0:	90 10 00 1d 	mov  %i5, %o0                                  
        filesystemtype,                                               
        &target_length                                                
      );                                                              
                                                                      
      if ( mt_entry != NULL ) {                                       
        mt_entry->writeable = options == RTEMS_FILESYSTEM_READ_WRITE; 
400036b4:	b6 0e e0 01 	and  %i3, 1, %i3                               
                                                                      
        rv = (*fsmount_me_h)( mt_entry, data );                       
400036b8:	92 10 00 1c 	mov  %i4, %o1                                  
400036bc:	9f c4 80 00 	call  %l2                                      
400036c0:	f6 2f 60 29 	stb  %i3, [ %i5 + 0x29 ]                       
        if ( rv == 0 ) {                                              
400036c4:	b0 92 20 00 	orcc  %o0, 0, %i0                              
400036c8:	12 80 00 29 	bne  4000376c <mount+0x1c4>                    
400036cc:	80 a6 60 00 	cmp  %i1, 0                                    
          if ( target != NULL ) {                                     
400036d0:	02 80 00 58 	be  40003830 <mount+0x288>                     
400036d4:	92 10 00 19 	mov  %i1, %o1                                  
{                                                                     
  int rv = 0;                                                         
  rtems_filesystem_eval_path_context_t ctx;                           
  int eval_flags = RTEMS_FS_PERMS_RWX                                 
    | RTEMS_FS_FOLLOW_LINK;                                           
  rtems_filesystem_location_info_t *currentloc =                      
400036d8:	94 10 20 1f 	mov  0x1f, %o2                                 
400036dc:	40 00 02 e8 	call  4000427c <rtems_filesystem_eval_path_start>
400036e0:	90 07 bf c8 	add  %fp, -56, %o0                             
                                                                      
static inline bool rtems_filesystem_location_is_instance_root(        
  const rtems_filesystem_location_info_t *loc                         
)                                                                     
{                                                                     
  const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
400036e4:	c2 02 20 14 	ld  [ %o0 + 0x14 ], %g1                        
                                                                      
  return (*mt_entry->ops->are_nodes_equal_h)(                         
400036e8:	c4 00 60 0c 	ld  [ %g1 + 0xc ], %g2                         
400036ec:	d2 00 60 24 	ld  [ %g1 + 0x24 ], %o1                        
400036f0:	c2 00 a0 10 	ld  [ %g2 + 0x10 ], %g1                        
400036f4:	9f c0 40 00 	call  %g1                                      
400036f8:	01 00 00 00 	nop                                            
    rtems_filesystem_eval_path_start( &ctx, target, eval_flags );     
                                                                      
  if ( !rtems_filesystem_location_is_instance_root( currentloc ) ) {  
400036fc:	80 8a 20 ff 	btst  0xff, %o0                                
40003700:	12 80 00 70 	bne  400038c0 <mount+0x318>                    
40003704:	92 07 bf e0 	add  %fp, -32, %o1                             
static inline void rtems_filesystem_eval_path_extract_currentloc(     
  rtems_filesystem_eval_path_context_t *ctx,                          
  rtems_filesystem_location_info_t *get                               
)                                                                     
{                                                                     
  rtems_filesystem_location_copy_and_detach(                          
40003708:	40 00 03 d6 	call  40004660 <rtems_filesystem_location_copy_and_detach>
4000370c:	90 07 bf b0 	add  %fp, -80, %o0                             
    rtems_filesystem_location_info_t targetloc;                       
    rtems_filesystem_global_location_t *mt_point_node;                
                                                                      
    rtems_filesystem_eval_path_extract_currentloc( &ctx, &targetloc );
    mt_point_node = rtems_filesystem_location_transform_to_global( &targetloc );
40003710:	40 00 04 63 	call  4000489c <rtems_filesystem_location_transform_to_global>
40003714:	90 07 bf b0 	add  %fp, -80, %o0                             
    mt_entry->mt_point_node = mt_point_node;                          
    rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry );
40003718:	c2 02 20 14 	ld  [ %o0 + 0x14 ], %g1                        
  if ( !rtems_filesystem_location_is_instance_root( currentloc ) ) {  
    rtems_filesystem_location_info_t targetloc;                       
    rtems_filesystem_global_location_t *mt_point_node;                
                                                                      
    rtems_filesystem_eval_path_extract_currentloc( &ctx, &targetloc );
    mt_point_node = rtems_filesystem_location_transform_to_global( &targetloc );
4000371c:	b8 10 00 08 	mov  %o0, %i4                                  
    mt_entry->mt_point_node = mt_point_node;                          
    rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry );
40003720:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
    rtems_filesystem_location_info_t targetloc;                       
    rtems_filesystem_global_location_t *mt_point_node;                
                                                                      
    rtems_filesystem_eval_path_extract_currentloc( &ctx, &targetloc );
    mt_point_node = rtems_filesystem_location_transform_to_global( &targetloc );
    mt_entry->mt_point_node = mt_point_node;                          
40003724:	d0 27 60 20 	st  %o0, [ %i5 + 0x20 ]                        
    rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry );
40003728:	c2 00 60 30 	ld  [ %g1 + 0x30 ], %g1                        
4000372c:	9f c0 40 00 	call  %g1                                      
40003730:	90 10 00 1d 	mov  %i5, %o0                                  
    if ( rv == 0 ) {                                                  
40003734:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40003738:	22 80 00 11 	be,a   4000377c <mount+0x1d4>                  
4000373c:	39 10 00 7b 	sethi  %hi(0x4001ec00), %i4                    
        &rtems_filesystem_mount_table,                                
        &mt_entry->mt_node                                            
      );                                                              
      rtems_filesystem_mt_unlock();                                   
    } else {                                                          
      rtems_filesystem_global_location_release( mt_point_node );      
40003740:	40 00 03 fd 	call  40004734 <rtems_filesystem_global_location_release>
40003744:	90 10 00 1c 	mov  %i4, %o0                                  
  } else {                                                            
    rtems_filesystem_eval_path_error( &ctx, EBUSY );                  
    rv = -1;                                                          
  }                                                                   
                                                                      
  rtems_filesystem_eval_path_cleanup( &ctx );                         
40003748:	40 00 03 0d 	call  4000437c <rtems_filesystem_eval_path_cleanup>
4000374c:	90 07 bf c8 	add  %fp, -56, %o0                             
            rv = register_subordinate_file_system( mt_entry, target );
          } else {                                                    
            rv = register_root_file_system( mt_entry );               
          }                                                           
                                                                      
          if ( rv != 0 ) {                                            
40003750:	80 a6 20 00 	cmp  %i0, 0                                    
40003754:	02 80 00 59 	be  400038b8 <mount+0x310>                     
40003758:	01 00 00 00 	nop                                            
            (*mt_entry->ops->fsunmount_me_h)( mt_entry );             
4000375c:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
40003760:	c2 00 60 3c 	ld  [ %g1 + 0x3c ], %g1                        
40003764:	9f c0 40 00 	call  %g1                                      
40003768:	90 10 00 1d 	mov  %i5, %o0                                  
          }                                                           
        }                                                             
                                                                      
        if ( rv != 0 ) {                                              
          free( mt_entry );                                           
4000376c:	7f ff fe 2f 	call  40003028 <free>                          
40003770:	90 10 00 1d 	mov  %i5, %o0                                  
    errno = EINVAL;                                                   
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
40003774:	81 c7 e0 08 	ret                                            
40003778:	81 e8 00 00 	restore                                        
 */                                                                   
#include <rtems/userenv.h>                                            
                                                                      
static inline void rtems_libio_lock( void )                           
{                                                                     
  rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
4000377c:	d0 07 21 38 	ld  [ %i4 + 0x138 ], %o0                       
40003780:	92 10 20 00 	clr  %o1                                       
40003784:	40 00 0f 02 	call  4000738c <rtems_semaphore_obtain>        
40003788:	94 10 20 00 	clr  %o2                                       
}                                                                     
                                                                      
static inline void rtems_libio_unlock( void )                         
{                                                                     
  rtems_semaphore_release( rtems_libio_semaphore );                   
4000378c:	d0 07 21 38 	ld  [ %i4 + 0x138 ], %o0                       
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
40003790:	03 10 00 78 	sethi  %hi(0x4001e000), %g1                    
40003794:	82 10 63 cc 	or  %g1, 0x3cc, %g1	! 4001e3cc <rtems_filesystem_mount_table>
40003798:	c4 00 60 08 	ld  [ %g1 + 8 ], %g2                           
                                                                      
  the_node->next = tail;                                              
4000379c:	86 00 60 04 	add  %g1, 4, %g3                               
400037a0:	c6 27 40 00 	st  %g3, [ %i5 ]                               
  tail->previous = the_node;                                          
400037a4:	fa 20 60 08 	st  %i5, [ %g1 + 8 ]                           
  old_last->next = the_node;                                          
400037a8:	fa 20 80 00 	st  %i5, [ %g2 ]                               
400037ac:	40 00 0f 47 	call  400074c8 <rtems_semaphore_release>       
400037b0:	c4 27 60 04 	st  %g2, [ %i5 + 4 ]                           
400037b4:	30 bf ff e5 	b,a   40003748 <mount+0x1a0>                   
  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;          
400037b8:	40 00 35 47 	call  40010cd4 <strlen>                        
400037bc:	90 10 00 1a 	mov  %i2, %o0                                  
  const char *target_or_null,                                         
  const char *filesystemtype,                                         
  size_t *target_length_ptr                                           
)                                                                     
{                                                                     
  const char *target = target_or_null != NULL ? target_or_null : "/"; 
400037c0:	2b 10 00 73 	sethi  %hi(0x4001cc00), %l5                    
400037c4:	a6 10 20 02 	mov  2, %l3                                    
400037c8:	aa 15 62 f8 	or  %l5, 0x2f8, %l5                            
  size_t filesystemtype_size = strlen( filesystemtype ) + 1;          
400037cc:	ba 10 00 08 	mov  %o0, %i5                                  
  size_t source_size = source_or_null != NULL ?                       
    strlen( source_or_null ) + 1 : 0;                                 
400037d0:	80 a6 20 00 	cmp  %i0, 0                                    
400037d4:	12 bf ff 8a 	bne  400035fc <mount+0x54>                     <== NEVER TAKEN
400037d8:	a8 02 20 01 	add  %o0, 1, %l4                               
  size_t target_size = strlen( target ) + 1;                          
  size_t size = sizeof( rtems_filesystem_mount_table_entry_t )        
    + filesystemtype_size + source_size + target_size                 
400037dc:	ba 07 40 13 	add  %i5, %l3, %i5                             
)                                                                     
{                                                                     
  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;                                 
400037e0:	a2 10 20 00 	clr  %l1                                       
  size_t target_size = strlen( target ) + 1;                          
  size_t size = sizeof( rtems_filesystem_mount_table_entry_t )        
    + filesystemtype_size + source_size + target_size                 
400037e4:	92 07 60 65 	add  %i5, 0x65, %o1                            
    + sizeof( rtems_filesystem_global_location_t );                   
  rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size ); 
400037e8:	90 10 20 01 	mov  1, %o0                                    
400037ec:	7f ff fd 60 	call  40002d6c <calloc>                        
400037f0:	92 02 40 11 	add  %o1, %l1, %o1                             
                                                                      
  if ( mt_entry != NULL ) {                                           
400037f4:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400037f8:	12 bf ff 8c 	bne  40003628 <mount+0x80>                     <== ALWAYS TAKEN
400037fc:	a0 07 60 64 	add  %i5, 0x64, %l0                            
                                                                      
        if ( rv != 0 ) {                                              
          free( mt_entry );                                           
        }                                                             
      } else {                                                        
        errno = ENOMEM;                                               
40003800:	40 00 2f d0 	call  4000f740 <__errno>                       <== NOT EXECUTED
40003804:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40003808:	82 10 20 0c 	mov  0xc, %g1                                  <== NOT EXECUTED
4000380c:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
40003810:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40003814:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    } else {                                                          
      errno = EINVAL;                                                 
      rv = -1;                                                        
    }                                                                 
  } else {                                                            
    errno = EINVAL;                                                   
40003818:	40 00 2f ca 	call  4000f740 <__errno>                       
4000381c:	b0 10 3f ff 	mov  -1, %i0                                   
40003820:	82 10 20 16 	mov  0x16, %g1                                 
40003824:	c2 22 00 00 	st  %g1, [ %o0 ]                               
40003828:	81 c7 e0 08 	ret                                            
4000382c:	81 e8 00 00 	restore                                        
 */                                                                   
#include <rtems/userenv.h>                                            
                                                                      
static inline void rtems_libio_lock( void )                           
{                                                                     
  rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
40003830:	39 10 00 7b 	sethi  %hi(0x4001ec00), %i4                    
40003834:	d0 07 21 38 	ld  [ %i4 + 0x138 ], %o0	! 4001ed38 <rtems_libio_semaphore>
40003838:	92 10 20 00 	clr  %o1                                       
4000383c:	40 00 0e d4 	call  4000738c <rtems_semaphore_obtain>        
40003840:	94 10 20 00 	clr  %o2                                       
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(        
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_head( the_chain )->next;                    
40003844:	03 10 00 78 	sethi  %hi(0x4001e000), %g1                    
)                                                                     
{                                                                     
  int rv = 0;                                                         
                                                                      
  rtems_filesystem_mt_lock();                                         
  if ( rtems_chain_is_empty( &rtems_filesystem_mount_table ) ) {      
40003848:	c4 00 63 cc 	ld  [ %g1 + 0x3cc ], %g2	! 4001e3cc <rtems_filesystem_mount_table>
4000384c:	82 10 63 cc 	or  %g1, 0x3cc, %g1                            
40003850:	86 00 60 04 	add  %g1, 4, %g3                               
40003854:	80 a0 80 03 	cmp  %g2, %g3                                  
40003858:	12 80 00 1f 	bne  400038d4 <mount+0x32c>                    <== NEVER TAKEN
4000385c:	01 00 00 00 	nop                                            
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
40003860:	c6 00 60 08 	ld  [ %g1 + 8 ], %g3                           
}                                                                     
                                                                      
static inline void rtems_libio_unlock( void )                         
{                                                                     
  rtems_semaphore_release( rtems_libio_semaphore );                   
40003864:	d0 07 21 38 	ld  [ %i4 + 0x138 ], %o0                       
                                                                      
  the_node->next = tail;                                              
40003868:	c4 27 40 00 	st  %g2, [ %i5 ]                               
  tail->previous = the_node;                                          
4000386c:	fa 20 60 08 	st  %i5, [ %g1 + 8 ]                           
  old_last->next = the_node;                                          
40003870:	fa 20 c0 00 	st  %i5, [ %g3 ]                               
40003874:	40 00 0f 15 	call  400074c8 <rtems_semaphore_release>       
40003878:	c6 27 60 04 	st  %g3, [ %i5 + 4 ]                           
  }                                                                   
  rtems_filesystem_mt_unlock();                                       
                                                                      
  if ( rv == 0 ) {                                                    
    rtems_filesystem_global_location_t *new_fs_root =                 
      rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
4000387c:	ba 07 60 24 	add  %i5, 0x24, %i5                            
    rv = -1;                                                          
  }                                                                   
  rtems_filesystem_mt_unlock();                                       
                                                                      
  if ( rv == 0 ) {                                                    
    rtems_filesystem_global_location_t *new_fs_root =                 
40003880:	40 00 03 cd 	call  400047b4 <rtems_filesystem_global_location_obtain>
40003884:	90 10 00 1d 	mov  %i5, %o0                                  
40003888:	b6 10 00 08 	mov  %o0, %i3                                  
      rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
    rtems_filesystem_global_location_t *new_fs_current =              
4000388c:	40 00 03 ca 	call  400047b4 <rtems_filesystem_global_location_obtain>
40003890:	90 10 00 1d 	mov  %i5, %o0                                  
      rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
                                                                      
    rtems_filesystem_global_location_assign(                          
40003894:	39 10 00 78 	sethi  %hi(0x4001e000), %i4                    
  rtems_filesystem_mt_unlock();                                       
                                                                      
  if ( rv == 0 ) {                                                    
    rtems_filesystem_global_location_t *new_fs_root =                 
      rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
    rtems_filesystem_global_location_t *new_fs_current =              
40003898:	ba 10 00 08 	mov  %o0, %i5                                  
      rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
                                                                      
    rtems_filesystem_global_location_assign(                          
4000389c:	d0 07 23 ec 	ld  [ %i4 + 0x3ec ], %o0                       
400038a0:	92 10 00 1b 	mov  %i3, %o1                                  
400038a4:	40 00 03 ba 	call  4000478c <rtems_filesystem_global_location_assign>
400038a8:	90 02 20 04 	add  %o0, 4, %o0                               
      &rtems_filesystem_root,                                         
      new_fs_root                                                     
    );                                                                
    rtems_filesystem_global_location_assign(                          
400038ac:	d0 07 23 ec 	ld  [ %i4 + 0x3ec ], %o0                       
400038b0:	40 00 03 b7 	call  4000478c <rtems_filesystem_global_location_assign>
400038b4:	92 10 00 1d 	mov  %i5, %o1                                  
400038b8:	81 c7 e0 08 	ret                                            
400038bc:	81 e8 00 00 	restore                                        
      rtems_filesystem_mt_unlock();                                   
    } else {                                                          
      rtems_filesystem_global_location_release( mt_point_node );      
    }                                                                 
  } else {                                                            
    rtems_filesystem_eval_path_error( &ctx, EBUSY );                  
400038c0:	90 07 bf c8 	add  %fp, -56, %o0                             
400038c4:	92 10 20 10 	mov  0x10, %o1                                 
400038c8:	40 00 01 b1 	call  40003f8c <rtems_filesystem_eval_path_error>
400038cc:	b0 10 3f ff 	mov  -1, %i0                                   
400038d0:	30 bf ff 9e 	b,a   40003748 <mount+0x1a0>                   
    rtems_chain_append_unprotected(                                   
      &rtems_filesystem_mount_table,                                  
      &mt_entry->mt_node                                              
    );                                                                
  } else {                                                            
    errno = EINVAL;                                                   
400038d4:	40 00 2f 9b 	call  4000f740 <__errno>                       <== NOT EXECUTED
400038d8:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
400038dc:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
400038e0:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
400038e4:	40 00 0e f9 	call  400074c8 <rtems_semaphore_release>       <== NOT EXECUTED
400038e8:	d0 07 21 38 	ld  [ %i4 + 0x138 ], %o0                       <== NOT EXECUTED
          } else {                                                    
            rv = register_root_file_system( mt_entry );               
          }                                                           
                                                                      
          if ( rv != 0 ) {                                            
            (*mt_entry->ops->fsunmount_me_h)( mt_entry );             
400038ec:	10 bf ff 9d 	b  40003760 <mount+0x1b8>                      <== NOT EXECUTED
400038f0:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         <== NOT EXECUTED
                                                                      

400087d4 <mount_and_make_target_path>: const char *target, const char *filesystemtype, rtems_filesystem_options_t options, const void *data ) {
400087d4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rv = -1;                                                        
                                                                      
  if (target != NULL) {                                               
400087d8:	90 96 60 00 	orcc  %i1, 0, %o0                              
400087dc:	02 80 00 0b 	be  40008808 <mount_and_make_target_path+0x34> 
400087e0:	01 00 00 00 	nop                                            
    rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);            
400087e4:	40 00 02 ea 	call  4000938c <rtems_mkdir>                   
400087e8:	92 10 21 ff 	mov  0x1ff, %o1	! 1ff <PROM_START+0x1ff>       
    if (rv == 0) {                                                    
400087ec:	82 92 20 00 	orcc  %o0, 0, %g1                              
400087f0:	02 80 00 04 	be  40008800 <mount_and_make_target_path+0x2c> <== ALWAYS TAKEN
400087f4:	01 00 00 00 	nop                                            
  } else {                                                            
    errno = EINVAL;                                                   
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
400087f8:	81 c7 e0 08 	ret                                            
400087fc:	91 e8 00 01 	restore  %g0, %g1, %o0                         
  int rv = -1;                                                        
                                                                      
  if (target != NULL) {                                               
    rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);            
    if (rv == 0) {                                                    
      rv = mount(                                                     
40008800:	40 00 00 08 	call  40008820 <mount>                         
40008804:	81 e8 00 00 	restore                                        
        options,                                                      
        data                                                          
      );                                                              
    }                                                                 
  } else {                                                            
    errno = EINVAL;                                                   
40008808:	40 00 68 4c 	call  40022938 <__errno>                       
4000880c:	01 00 00 00 	nop                                            
40008810:	84 10 20 16 	mov  0x16, %g2	! 16 <PROM_START+0x16>          
  const char *filesystemtype,                                         
  rtems_filesystem_options_t options,                                 
  const void *data                                                    
)                                                                     
{                                                                     
  int rv = -1;                                                        
40008814:	82 10 3f ff 	mov  -1, %g1                                   
        options,                                                      
        data                                                          
      );                                                              
    }                                                                 
  } else {                                                            
    errno = EINVAL;                                                   
40008818:	10 bf ff f8 	b  400087f8 <mount_and_make_target_path+0x24>  
4000881c:	c4 22 00 00 	st  %g2, [ %o0 ]                               
                                                                      

40007578 <mq_open>: int oflag, ... /* mode_t mode, */ /* struct mq_attr attr */ ) {
40007578:	9d e3 bf 88 	save  %sp, -120, %sp                           
   *                                                                  
   * This rountine increments the thread dispatch level               
   */                                                                 
  RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
  {                                                                   
    uint32_t level = _Thread_Dispatch_disable_level;                  
4000757c:	03 10 00 8e 	sethi  %hi(0x40023800), %g1                    
40007580:	c4 00 60 c0 	ld  [ %g1 + 0xc0 ], %g2	! 400238c0 <_Thread_Dispatch_disable_level>
  size_t                          name_len;                           
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  if ( oflag & O_CREAT ) {                                            
    va_start(arg, oflag);                                             
40007584:	f4 27 a0 4c 	st  %i2, [ %fp + 0x4c ]                        
                                                                      
    ++level;                                                          
40007588:	84 00 a0 01 	inc  %g2                                       
4000758c:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]                        
40007590:	f8 27 a0 54 	st  %i4, [ %fp + 0x54 ]                        
40007594:	fa 27 a0 58 	st  %i5, [ %fp + 0x58 ]                        
    _Thread_Dispatch_disable_level = level;                           
40007598:	c4 20 60 c0 	st  %g2, [ %g1 + 0xc0 ]                        
  Objects_Locations               location;                           
  size_t                          name_len;                           
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  if ( oflag & O_CREAT ) {                                            
4000759c:	a2 8e 62 00 	andcc  %i1, 0x200, %l1                         
400075a0:	12 80 00 36 	bne  40007678 <mq_open+0x100>                  
400075a4:	a0 10 20 00 	clr  %l0                                       
 */                                                                   
                                                                      
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *                 
  _POSIX_Message_queue_Allocate_fd( void )                            
{                                                                     
  return (POSIX_Message_queue_Control_fd *)                           
400075a8:	39 10 00 8f 	sethi  %hi(0x40023c00), %i4                    
400075ac:	40 00 0c 21 	call  4000a630 <_Objects_Allocate>             
400075b0:	90 17 21 90 	or  %i4, 0x190, %o0	! 40023d90 <_POSIX_Message_queue_Information_fds>
    attr = va_arg( arg, struct mq_attr * );                           
    va_end(arg);                                                      
  }                                                                   
                                                                      
  the_mq_fd = _POSIX_Message_queue_Allocate_fd();                     
  if ( !the_mq_fd ) {                                                 
400075b4:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400075b8:	02 80 00 39 	be  4000769c <mq_open+0x124>                   <== NEVER TAKEN
400075bc:	01 00 00 00 	nop                                            
    _Thread_Enable_dispatch();                                        
    rtems_set_errno_and_return_minus_one( ENFILE );                   
  }                                                                   
  the_mq_fd->oflag = oflag;                                           
400075c0:	f2 27 60 14 	st  %i1, [ %i5 + 0x14 ]                        
  const char          *name,                                          
  Objects_Id          *id,                                            
  size_t              *len                                            
)                                                                     
{                                                                     
  return _POSIX_Name_to_id( &_POSIX_Message_queue_Information, name, id, len );
400075c4:	35 10 00 8f 	sethi  %hi(0x40023c00), %i2                    
400075c8:	92 10 00 18 	mov  %i0, %o1                                  
400075cc:	90 16 a0 04 	or  %i2, 4, %o0                                
400075d0:	94 07 bf f0 	add  %fp, -16, %o2                             
400075d4:	40 00 01 42 	call  40007adc <_POSIX_Name_to_id>             
400075d8:	96 07 bf fc 	add  %fp, -4, %o3                              
   *  If the name to id translation worked, then the message queue exists
   *  and we can just return a pointer to the id.  Otherwise we may   
   *  need to check to see if this is a "message queue does not exist"
   *  or some other miscellaneous error on the name.                  
   */                                                                 
  if ( status ) {                                                     
400075dc:	b6 92 20 00 	orcc  %o0, 0, %i3                              
400075e0:	22 80 00 0f 	be,a   4000761c <mq_open+0xa4>                 
400075e4:	b2 0e 6a 00 	and  %i1, 0xa00, %i1                           
    /*                                                                
     * Unless provided a valid name that did not already exist        
     * and we are willing to create then it is an error.              
     */                                                               
    if ( !( status == ENOENT && (oflag & O_CREAT) ) ) {               
400075e8:	80 a6 e0 02 	cmp  %i3, 2                                    
400075ec:	02 80 00 3f 	be  400076e8 <mq_open+0x170>                   
400075f0:	80 a4 60 00 	cmp  %l1, 0                                    
                                                                      
RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free_fd (              
  POSIX_Message_queue_Control_fd *the_mq_fd                           
)                                                                     
{                                                                     
  _Objects_Free( &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object );
400075f4:	90 17 21 90 	or  %i4, 0x190, %o0                            
400075f8:	40 00 0d 06 	call  4000aa10 <_Objects_Free>                 
400075fc:	92 10 00 1d 	mov  %i5, %o1                                  
      _POSIX_Message_queue_Free_fd( the_mq_fd );                      
      _Thread_Enable_dispatch();                                      
40007600:	40 00 11 58 	call  4000bb60 <_Thread_Enable_dispatch>       
40007604:	b0 10 3f ff 	mov  -1, %i0                                   
      rtems_set_errno_and_return_minus_one_cast( status, mqd_t );     
40007608:	40 00 28 15 	call  4001165c <__errno>                       
4000760c:	01 00 00 00 	nop                                            
40007610:	f6 22 00 00 	st  %i3, [ %o0 ]                               
40007614:	81 c7 e0 08 	ret                                            
40007618:	81 e8 00 00 	restore                                        
                                                                      
  } else {                /* name -> ID translation succeeded */      
    /*                                                                
     * Check for existence with creation.                             
     */                                                               
    if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {       
4000761c:	80 a6 6a 00 	cmp  %i1, 0xa00                                
40007620:	02 80 00 27 	be  400076bc <mq_open+0x144>                   
40007624:	d2 07 bf f0 	ld  [ %fp + -16 ], %o1                         
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control *_POSIX_Message_queue_Get (
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (POSIX_Message_queue_Control *)                              
40007628:	94 07 bf f8 	add  %fp, -8, %o2                              
4000762c:	40 00 0d 5f 	call  4000aba8 <_Objects_Get>                  
40007630:	90 16 a0 04 	or  %i2, 4, %o0                                
    /*                                                                
     * In this case we need to do an ID->pointer conversion to        
     * check the mode.                                                
     */                                                               
    the_mq = _POSIX_Message_queue_Get( the_mq_id, &location );        
    the_mq->open_count += 1;                                          
40007634:	c4 02 20 18 	ld  [ %o0 + 0x18 ], %g2                        
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  const char          *name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
40007638:	c2 17 60 0a 	lduh  [ %i5 + 0xa ], %g1                       
4000763c:	84 00 a0 01 	inc  %g2                                       
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
40007640:	b8 17 21 90 	or  %i4, 0x190, %i4                            
40007644:	c4 22 20 18 	st  %g2, [ %o0 + 0x18 ]                        
40007648:	c4 07 20 1c 	ld  [ %i4 + 0x1c ], %g2                        
                                                                      
    /*                                                                
     * In this case we need to do an ID->pointer conversion to        
     * check the mode.                                                
     */                                                               
    the_mq = _POSIX_Message_queue_Get( the_mq_id, &location );        
4000764c:	d0 27 bf f4 	st  %o0, [ %fp + -12 ]                         
    the_mq->open_count += 1;                                          
    the_mq_fd->Queue = the_mq;                                        
40007650:	d0 27 60 10 	st  %o0, [ %i5 + 0x10 ]                        
40007654:	83 28 60 02 	sll  %g1, 2, %g1                               
40007658:	fa 20 80 01 	st  %i5, [ %g2 + %g1 ]                         
    _Objects_Open_string(                                             
      &_POSIX_Message_queue_Information_fds,                          
      &the_mq_fd->Object,                                             
      NULL                                                            
    );                                                                
    _Thread_Enable_dispatch();                                        
4000765c:	40 00 11 41 	call  4000bb60 <_Thread_Enable_dispatch>       
40007660:	c0 27 60 0c 	clr  [ %i5 + 0xc ]                             
    _Thread_Enable_dispatch();                                        
40007664:	40 00 11 3f 	call  4000bb60 <_Thread_Enable_dispatch>       
40007668:	01 00 00 00 	nop                                            
    return (mqd_t)the_mq_fd->Object.id;                               
4000766c:	f0 07 60 08 	ld  [ %i5 + 8 ], %i0                           
40007670:	81 c7 e0 08 	ret                                            
40007674:	81 e8 00 00 	restore                                        
  size_t                          name_len;                           
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  if ( oflag & O_CREAT ) {                                            
    va_start(arg, oflag);                                             
40007678:	82 07 a0 4c 	add  %fp, 0x4c, %g1                            
    mode = va_arg( arg, mode_t );                                     
    attr = va_arg( arg, struct mq_attr * );                           
4000767c:	e0 07 a0 50 	ld  [ %fp + 0x50 ], %l0                        
  size_t                          name_len;                           
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  if ( oflag & O_CREAT ) {                                            
    va_start(arg, oflag);                                             
40007680:	c2 27 bf ec 	st  %g1, [ %fp + -20 ]                         
 */                                                                   
                                                                      
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *                 
  _POSIX_Message_queue_Allocate_fd( void )                            
{                                                                     
  return (POSIX_Message_queue_Control_fd *)                           
40007684:	39 10 00 8f 	sethi  %hi(0x40023c00), %i4                    
40007688:	40 00 0b ea 	call  4000a630 <_Objects_Allocate>             
4000768c:	90 17 21 90 	or  %i4, 0x190, %o0	! 40023d90 <_POSIX_Message_queue_Information_fds>
    attr = va_arg( arg, struct mq_attr * );                           
    va_end(arg);                                                      
  }                                                                   
                                                                      
  the_mq_fd = _POSIX_Message_queue_Allocate_fd();                     
  if ( !the_mq_fd ) {                                                 
40007690:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40007694:	32 bf ff cc 	bne,a   400075c4 <mq_open+0x4c>                
40007698:	f2 27 60 14 	st  %i1, [ %i5 + 0x14 ]                        
    _Thread_Enable_dispatch();                                        
4000769c:	40 00 11 31 	call  4000bb60 <_Thread_Enable_dispatch>       
400076a0:	b0 10 3f ff 	mov  -1, %i0                                   
    rtems_set_errno_and_return_minus_one( ENFILE );                   
400076a4:	40 00 27 ee 	call  4001165c <__errno>                       
400076a8:	01 00 00 00 	nop                                            
400076ac:	82 10 20 17 	mov  0x17, %g1	! 17 <PROM_START+0x17>          
400076b0:	c2 22 00 00 	st  %g1, [ %o0 ]                               
400076b4:	81 c7 e0 08 	ret                                            
400076b8:	81 e8 00 00 	restore                                        
                                                                      
RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free_fd (              
  POSIX_Message_queue_Control_fd *the_mq_fd                           
)                                                                     
{                                                                     
  _Objects_Free( &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object );
400076bc:	90 17 21 90 	or  %i4, 0x190, %o0                            
400076c0:	40 00 0c d4 	call  4000aa10 <_Objects_Free>                 
400076c4:	92 10 00 1d 	mov  %i5, %o1                                  
    /*                                                                
     * Check for existence with creation.                             
     */                                                               
    if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {       
      _POSIX_Message_queue_Free_fd( the_mq_fd );                      
      _Thread_Enable_dispatch();                                      
400076c8:	40 00 11 26 	call  4000bb60 <_Thread_Enable_dispatch>       
400076cc:	b0 10 3f ff 	mov  -1, %i0                                   
      rtems_set_errno_and_return_minus_one_cast( EEXIST, mqd_t );     
400076d0:	40 00 27 e3 	call  4001165c <__errno>                       
400076d4:	01 00 00 00 	nop                                            
400076d8:	82 10 20 11 	mov  0x11, %g1	! 11 <PROM_START+0x11>          
400076dc:	c2 22 00 00 	st  %g1, [ %o0 ]                               
400076e0:	81 c7 e0 08 	ret                                            
400076e4:	81 e8 00 00 	restore                                        
  if ( status ) {                                                     
    /*                                                                
     * Unless provided a valid name that did not already exist        
     * and we are willing to create then it is an error.              
     */                                                               
    if ( !( status == ENOENT && (oflag & O_CREAT) ) ) {               
400076e8:	02 bf ff c4 	be  400075f8 <mq_open+0x80>                    
400076ec:	90 17 21 90 	or  %i4, 0x190, %o0                            
                                                                      
  /*                                                                  
   *  At this point, the message queue does not exist and everything has been
   *  checked. We should go ahead and create a message queue.         
   */                                                                 
  status = _POSIX_Message_queue_Create_support(                       
400076f0:	d2 07 bf fc 	ld  [ %fp + -4 ], %o1                          
400076f4:	90 10 00 18 	mov  %i0, %o0                                  
400076f8:	94 10 20 01 	mov  1, %o2                                    
400076fc:	96 10 00 10 	mov  %l0, %o3                                  
40007700:	40 00 1b a1 	call  4000e584 <_POSIX_Message_queue_Create_support>
40007704:	98 07 bf f4 	add  %fp, -12, %o4                             
  );                                                                  
                                                                      
  /*                                                                  
   * errno was set by Create_support, so don't set it again.          
   */                                                                 
  if ( status == -1 ) {                                               
40007708:	80 a2 3f ff 	cmp  %o0, -1                                   
4000770c:	02 80 00 0d 	be  40007740 <mq_open+0x1c8>                   
40007710:	c6 07 bf f4 	ld  [ %fp + -12 ], %g3                         
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  const char          *name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
40007714:	c2 17 60 0a 	lduh  [ %i5 + 0xa ], %g1                       
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
40007718:	b8 17 21 90 	or  %i4, 0x190, %i4                            
4000771c:	c4 07 20 1c 	ld  [ %i4 + 0x1c ], %g2                        
    _POSIX_Message_queue_Free_fd( the_mq_fd );                        
    _Thread_Enable_dispatch();                                        
    return (mqd_t) -1;                                                
  }                                                                   
                                                                      
  the_mq_fd->Queue = the_mq;                                          
40007720:	c6 27 60 10 	st  %g3, [ %i5 + 0x10 ]                        
40007724:	83 28 60 02 	sll  %g1, 2, %g1                               
40007728:	fa 20 80 01 	st  %i5, [ %g2 + %g1 ]                         
    &_POSIX_Message_queue_Information_fds,                            
    &the_mq_fd->Object,                                               
    NULL                                                              
  );                                                                  
                                                                      
  _Thread_Enable_dispatch();                                          
4000772c:	40 00 11 0d 	call  4000bb60 <_Thread_Enable_dispatch>       
40007730:	c0 27 60 0c 	clr  [ %i5 + 0xc ]                             
                                                                      
  return (mqd_t) the_mq_fd->Object.id;                                
40007734:	f0 07 60 08 	ld  [ %i5 + 8 ], %i0                           
}                                                                     
40007738:	81 c7 e0 08 	ret                                            
4000773c:	81 e8 00 00 	restore                                        
40007740:	90 17 21 90 	or  %i4, 0x190, %o0                            
40007744:	92 10 00 1d 	mov  %i5, %o1                                  
40007748:	40 00 0c b2 	call  4000aa10 <_Objects_Free>                 
4000774c:	b0 10 3f ff 	mov  -1, %i0                                   
  /*                                                                  
   * errno was set by Create_support, so don't set it again.          
   */                                                                 
  if ( status == -1 ) {                                               
    _POSIX_Message_queue_Free_fd( the_mq_fd );                        
    _Thread_Enable_dispatch();                                        
40007750:	40 00 11 04 	call  4000bb60 <_Thread_Enable_dispatch>       
40007754:	01 00 00 00 	nop                                            
40007758:	81 c7 e0 08 	ret                                            
4000775c:	81 e8 00 00 	restore                                        
                                                                      

40018058 <msdos_creat_node>: msdos_node_type_t type, const char *name, int name_len, mode_t mode, const fat_file_fd_t *link_fd) {
40018058:	9d e3 bf 00 	save  %sp, -256, %sp                           
    int               rc = RC_OK;                                     
    ssize_t           ret = 0;                                        
    msdos_fs_info_t  *fs_info = parent_loc->mt_entry->fs_info;        
4001805c:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
    uint32_t          sec = 0;                                        
    uint32_t          byte = 0;                                       
                                                                      
    fat_dir_pos_init(&dir_pos);                                       
                                                                      
    memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);         
40018060:	b8 07 bf 80 	add  %fp, -128, %i4                            
                 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;        
40018064:	e0 00 60 08 	ld  [ %g1 + 8 ], %l0                           
    fat_file_fd_t    *parent_fat_fd = parent_loc->node_access;        
    fat_file_fd_t    *fat_fd = NULL;                                  
40018068:	c0 27 bf 6c 	clr  [ %fp + -148 ]                            
    fat_dir_pos_t *dir_pos                                            
    )                                                                 
{                                                                     
  dir_pos->sname.cln = 0;                                             
  dir_pos->sname.ofs = 0;                                             
  dir_pos->lname.cln = FAT_FILE_SHORT_NAME;                           
4001806c:	82 10 3f ff 	mov  -1, %g1                                   
    time_t            time_ret = 0;                                   
    uint16_t          time_val = 0;                                   
40018070:	c0 37 bf 68 	clrh  [ %fp + -152 ]                           
    uint16_t          date = 0;                                       
40018074:	c0 37 bf 6a 	clrh  [ %fp + -150 ]                           
static inline void                                                    
fat_dir_pos_init(                                                     
    fat_dir_pos_t *dir_pos                                            
    )                                                                 
{                                                                     
  dir_pos->sname.cln = 0;                                             
40018078:	c0 27 bf 70 	clr  [ %fp + -144 ]                            
  dir_pos->sname.ofs = 0;                                             
4001807c:	c0 27 bf 74 	clr  [ %fp + -140 ]                            
  dir_pos->lname.cln = FAT_FILE_SHORT_NAME;                           
40018080:	c2 27 bf 78 	st  %g1, [ %fp + -136 ]                        
  dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;                           
40018084:	c2 27 bf 7c 	st  %g1, [ %fp + -132 ]                        
    uint32_t          sec = 0;                                        
    uint32_t          byte = 0;                                       
                                                                      
    fat_dir_pos_init(&dir_pos);                                       
                                                                      
    memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);         
40018088:	c0 27 bf 80 	clr  [ %fp + -128 ]                            
4001808c:	c0 27 bf 84 	clr  [ %fp + -124 ]                            
40018090:	c0 27 20 08 	clr  [ %i4 + 8 ]                               
40018094:	c0 27 20 0c 	clr  [ %i4 + 0xc ]                             
40018098:	c0 27 20 10 	clr  [ %i4 + 0x10 ]                            
4001809c:	c0 27 20 14 	clr  [ %i4 + 0x14 ]                            
400180a0:	c0 27 20 18 	clr  [ %i4 + 0x18 ]                            
400180a4:	c0 27 20 1c 	clr  [ %i4 + 0x1c ]                            
    memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);     
400180a8:	c0 27 bf c0 	clr  [ %fp + -64 ]                             
400180ac:	c0 27 bf c4 	clr  [ %fp + -60 ]                             
400180b0:	c0 27 bf c8 	clr  [ %fp + -56 ]                             
400180b4:	c0 27 bf cc 	clr  [ %fp + -52 ]                             
400180b8:	c0 27 bf d0 	clr  [ %fp + -48 ]                             
400180bc:	c0 27 bf d4 	clr  [ %fp + -44 ]                             
400180c0:	c0 27 bf d8 	clr  [ %fp + -40 ]                             
400180c4:	c0 27 bf dc 	clr  [ %fp + -36 ]                             
400180c8:	c0 27 bf e0 	clr  [ %fp + -32 ]                             
400180cc:	c0 27 bf e4 	clr  [ %fp + -28 ]                             
400180d0:	c0 27 bf e8 	clr  [ %fp + -24 ]                             
400180d4:	c0 27 bf ec 	clr  [ %fp + -20 ]                             
400180d8:	c0 27 bf f0 	clr  [ %fp + -16 ]                             
400180dc:	c0 27 bf f4 	clr  [ %fp + -12 ]                             
400180e0:	c0 27 bf f8 	clr  [ %fp + -8 ]                              
400180e4:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
                                                                      
    if (name_len > MSDOS_NAME_MAX_LFN_WITH_DOT) {                     
400180e8:	80 a6 e1 04 	cmp  %i3, 0x104                                
400180ec:	14 80 00 e3 	bg  40018478 <msdos_creat_node+0x420>          <== NEVER TAKEN
400180f0:	e2 06 20 08 	ld  [ %i0 + 8 ], %l1                           
        rtems_set_errno_and_return_minus_one(ENAMETOOLONG);           
    }                                                                 
                                                                      
    name_type = msdos_long_to_short (name, name_len,                  
400180f4:	90 10 00 1a 	mov  %i2, %o0                                  
400180f8:	92 10 00 1b 	mov  %i3, %o1                                  
400180fc:	94 10 00 1c 	mov  %i4, %o2                                  
40018100:	40 00 01 37 	call  400185dc <msdos_long_to_short>           
40018104:	96 10 20 0b 	mov  0xb, %o3                                  
                                     MSDOS_DIR_NAME(short_node),      
                                     MSDOS_NAME_MAX);                 
    if (name_type == MSDOS_NAME_INVALID) {                            
40018108:	a4 92 20 00 	orcc  %o0, 0, %l2                              
4001810c:	02 80 00 e0 	be  4001848c <msdos_creat_node+0x434>          <== NEVER TAKEN
40018110:	01 00 00 00 	nop                                            
        rtems_set_errno_and_return_minus_one(EINVAL);                 
    }                                                                 
                                                                      
    /* fill reserved field */                                         
    *MSDOS_DIR_NT_RES(short_node) = MSDOS_RES_NT_VALUE;               
40018114:	c0 2f bf 8c 	clrb  [ %fp + -116 ]                           
                                                                      
    /* set up last write date and time */                             
    time_ret = time(NULL);                                            
40018118:	40 00 22 21 	call  4002099c <time>                          
4001811c:	90 10 20 00 	clr  %o0                                       
    if ( time_ret == -1 )                                             
40018120:	80 a2 3f ff 	cmp  %o0, -1                                   
40018124:	02 80 00 df 	be  400184a0 <msdos_creat_node+0x448>          <== NEVER TAKEN
40018128:	92 07 bf 6a 	add  %fp, -150, %o1                            
        return -1;                                                    
                                                                      
    msdos_date_unix2dos(time_ret, &date, &time_val);                  
4001812c:	40 00 0c 87 	call  4001b348 <msdos_date_unix2dos>           
40018130:	94 07 bf 68 	add  %fp, -152, %o2                            
    *MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);              
40018134:	c8 17 bf 68 	lduh  [ %fp + -152 ], %g4                      
    *MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);                  
40018138:	c6 17 bf 6a 	lduh  [ %fp + -150 ], %g3                      
    time_ret = time(NULL);                                            
    if ( time_ret == -1 )                                             
        return -1;                                                    
                                                                      
    msdos_date_unix2dos(time_ret, &date, &time_val);                  
    *MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);              
4001813c:	89 29 20 10 	sll  %g4, 0x10, %g4                            
    *MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);                  
40018140:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
    time_ret = time(NULL);                                            
    if ( time_ret == -1 )                                             
        return -1;                                                    
                                                                      
    msdos_date_unix2dos(time_ret, &date, &time_val);                  
    *MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);              
40018144:	85 31 20 08 	srl  %g4, 8, %g2                               
    *MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);                  
40018148:	83 30 e0 08 	srl  %g3, 8, %g1                               
    time_ret = time(NULL);                                            
    if ( time_ret == -1 )                                             
        return -1;                                                    
                                                                      
    msdos_date_unix2dos(time_ret, &date, &time_val);                  
    *MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);              
4001814c:	89 31 20 18 	srl  %g4, 0x18, %g4                            
    *MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);                  
40018150:	87 30 e0 18 	srl  %g3, 0x18, %g3                            
    time_ret = time(NULL);                                            
    if ( time_ret == -1 )                                             
        return -1;                                                    
                                                                      
    msdos_date_unix2dos(time_ret, &date, &time_val);                  
    *MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);              
40018154:	84 10 80 04 	or  %g2, %g4, %g2                              
    *MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);                  
40018158:	82 10 40 03 	or  %g1, %g3, %g1                              
    time_ret = time(NULL);                                            
    if ( time_ret == -1 )                                             
        return -1;                                                    
                                                                      
    msdos_date_unix2dos(time_ret, &date, &time_val);                  
    *MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);              
4001815c:	c4 37 bf 8e 	sth  %g2, [ %fp + -114 ]                       
    *MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);                  
    *MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);            
40018160:	c4 37 bf 96 	sth  %g2, [ %fp + -106 ]                       
    if ( time_ret == -1 )                                             
        return -1;                                                    
                                                                      
    msdos_date_unix2dos(time_ret, &date, &time_val);                  
    *MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);              
    *MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);                  
40018164:	c2 37 bf 90 	sth  %g1, [ %fp + -112 ]                       
    *MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);            
    *MSDOS_DIR_WRITE_DATE(short_node) = CT_LE_W(date);                
40018168:	c2 37 bf 98 	sth  %g1, [ %fp + -104 ]                       
    *MSDOS_DIR_LAST_ACCESS_DATE(short_node) = CT_LE_W(date);          
4001816c:	c2 37 bf 92 	sth  %g1, [ %fp + -110 ]                       
                                                                      
    /* initialize directory/file size */                              
    *MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;           
                                                                      
    if (type == MSDOS_DIRECTORY) {                                    
40018170:	80 a6 60 00 	cmp  %i1, 0                                    
40018174:	02 80 00 12 	be  400181bc <msdos_creat_node+0x164>          
40018178:	c0 27 bf 9c 	clr  [ %fp + -100 ]                            
      *MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;            
    }                                                                 
    else if (type == MSDOS_HARD_LINK) {                               
4001817c:	80 a6 60 02 	cmp  %i1, 2                                    
40018180:	02 80 00 89 	be  400183a4 <msdos_creat_node+0x34c>          <== NEVER TAKEN
40018184:	c2 0f bf 8b 	ldub  [ %fp + -117 ], %g1                      
       * set "archive bit" due to changes                             
       */                                                             
      *MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;              
    }                                                                 
    else { /* regular file... */                                      
        *MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;            
40018188:	82 10 60 20 	or  %g1, 0x20, %g1                             
4001818c:	c2 2f bf 8b 	stb  %g1, [ %fp + -117 ]                       
                                                                      
    /*                                                                
     * 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,        
40018190:	f8 23 a0 5c 	st  %i4, [ %sp + 0x5c ]                        
40018194:	90 10 00 18 	mov  %i0, %o0                                  
40018198:	92 10 20 01 	mov  1, %o1                                    
4001819c:	94 10 00 1a 	mov  %i2, %o2                                  
400181a0:	96 10 00 1b 	mov  %i3, %o3                                  
400181a4:	98 10 00 12 	mov  %l2, %o4                                  
400181a8:	40 00 06 b8 	call  40019c88 <msdos_get_name_node>           
400181ac:	9a 07 bf 70 	add  %fp, -144, %o5                            
400181b0:	ba 10 00 08 	mov  %o0, %i5                                  
                                                                      
err:                                                                  
    /* mark the used 32bytes structure on the disk as free */         
    msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
    return rc;                                                        
}                                                                     
400181b4:	81 c7 e0 08 	ret                                            
400181b8:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
                                                                      
    /* 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;            
400181bc:	c2 0f bf 8b 	ldub  [ %fp + -117 ], %g1                      
                                                                      
    /*                                                                
     * 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,        
400181c0:	f8 23 a0 5c 	st  %i4, [ %sp + 0x5c ]                        
                                                                      
    /* 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;            
400181c4:	82 10 60 10 	or  %g1, 0x10, %g1                             
                                                                      
    /*                                                                
     * 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,        
400181c8:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
    /* 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;            
400181cc:	c2 2f bf 8b 	stb  %g1, [ %fp + -117 ]                       
                                                                      
    /*                                                                
     * 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,        
400181d0:	92 10 20 01 	mov  1, %o1                                    
400181d4:	94 10 00 1a 	mov  %i2, %o2                                  
400181d8:	96 10 00 1b 	mov  %i3, %o3                                  
400181dc:	98 10 00 12 	mov  %l2, %o4                                  
400181e0:	40 00 06 aa 	call  40019c88 <msdos_get_name_node>           
400181e4:	9a 07 bf 70 	add  %fp, -144, %o5                            
                             name_type, &dir_pos, short_node);        
    if ( rc != RC_OK )                                                
400181e8:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400181ec:	12 bf ff f2 	bne  400181b4 <msdos_creat_node+0x15c>         <== NEVER TAKEN
400181f0:	90 10 00 10 	mov  %l0, %o0                                  
     * to do                                                          
     */                                                               
    if (type == MSDOS_DIRECTORY)                                      
    {                                                                 
        /* open new directory as fat-file */                          
        rc = fat_file_open(&fs_info->fat, &dir_pos, &fat_fd);         
400181f4:	92 07 bf 70 	add  %fp, -144, %o1                            
400181f8:	7f ff e8 ac 	call  400124a8 <fat_file_open>                 
400181fc:	94 07 bf 6c 	add  %fp, -148, %o2                            
        if (rc != RC_OK)                                              
40018200:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40018204:	32 80 00 62 	bne,a   4001838c <msdos_creat_node+0x334>      <== NEVER TAKEN
40018208:	d0 06 20 14 	ld  [ %i0 + 0x14 ], %o0                        <== NOT EXECUTED
                                                                      
        /*                                                            
         * we opened fat-file for node we just created, so initialize fat-file
         * descritor                                                  
         */                                                           
        fat_fd->fat_file_size = 0;                                    
4001820c:	f2 07 bf 6c 	ld  [ %fp + -148 ], %i1                        
        fat_fd->fat_file_type = FAT_DIRECTORY;                        
        fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                    
40018210:	03 00 08 00 	sethi  %hi(0x200000), %g1                      
                                                                      
        /*                                                            
         * we opened fat-file for node we just created, so initialize fat-file
         * descritor                                                  
         */                                                           
        fat_fd->fat_file_size = 0;                                    
40018214:	c0 26 60 18 	clr  [ %i1 + 0x18 ]                            
        fat_fd->fat_file_type = FAT_DIRECTORY;                        
        fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                    
40018218:	c2 26 60 14 	st  %g1, [ %i1 + 0x14 ]                        
        /*                                                            
         * we opened fat-file for node we just created, so initialize fat-file
         * descritor                                                  
         */                                                           
        fat_fd->fat_file_size = 0;                                    
        fat_fd->fat_file_type = FAT_DIRECTORY;                        
4001821c:	c0 26 60 10 	clr  [ %i1 + 0x10 ]                            
         */                                                           
        memcpy(DOT_NODE_P(dot_dotdot), short_node,                    
               MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);                    
        memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,                 
               MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);                    
        memcpy(MSDOS_DIR_NAME(DOT_NODE_P(dot_dotdot)), MSDOS_DOT_NAME,
40018220:	03 10 00 b4 	sethi  %hi(0x4002d000), %g1                    
                                                                      
        /*                                                            
         * dot and dotdot entries are identical to new node except the
         * names                                                      
         */                                                           
        memcpy(DOT_NODE_P(dot_dotdot), short_node,                    
40018224:	d8 1f bf 80 	ldd  [ %fp + -128 ], %o4                       
40018228:	c4 1f bf 98 	ldd  [ %fp + -104 ], %g2                       
4001822c:	f4 1f bf 88 	ldd  [ %fp + -120 ], %i2                       
40018230:	f8 1f bf 90 	ldd  [ %fp + -112 ], %i4                       
               MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);                    
        memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,                 
               MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);                    
        memcpy(MSDOS_DIR_NAME(DOT_NODE_P(dot_dotdot)), MSDOS_DOT_NAME,
40018234:	d2 00 61 b4 	ld  [ %g1 + 0x1b4 ], %o1                       
40018238:	94 10 20 0b 	mov  0xb, %o2                                  
                                                                      
        /*                                                            
         * dot and dotdot entries are identical to new node except the
         * names                                                      
         */                                                           
        memcpy(DOT_NODE_P(dot_dotdot), short_node,                    
4001823c:	d8 3f bf c0 	std  %o4, [ %fp + -64 ]                        
40018240:	c4 3f bf d8 	std  %g2, [ %fp + -40 ]                        
               MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);                    
        memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,                 
40018244:	d8 3f bf e0 	std  %o4, [ %fp + -32 ]                        
40018248:	c4 3f bf f8 	std  %g2, [ %fp + -8 ]                         
                                                                      
        /*                                                            
         * dot and dotdot entries are identical to new node except the
         * names                                                      
         */                                                           
        memcpy(DOT_NODE_P(dot_dotdot), short_node,                    
4001824c:	f4 3f bf c8 	std  %i2, [ %fp + -56 ]                        
40018250:	f8 3f bf d0 	std  %i4, [ %fp + -48 ]                        
               MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);                    
        memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,                 
40018254:	f4 3f bf e8 	std  %i2, [ %fp + -24 ]                        
40018258:	f8 3f bf f0 	std  %i4, [ %fp + -16 ]                        
               MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);                    
        memcpy(MSDOS_DIR_NAME(DOT_NODE_P(dot_dotdot)), MSDOS_DOT_NAME,
4001825c:	40 00 12 f2 	call  4001ce24 <memcpy>                        
40018260:	90 07 bf c0 	add  %fp, -64, %o0                             
               MSDOS_NAME_MAX);                                       
        memcpy(MSDOS_DIR_NAME(DOTDOT_NODE_P(dot_dotdot)), MSDOS_DOTDOT_NAME,
40018264:	03 10 00 b4 	sethi  %hi(0x4002d000), %g1                    
40018268:	d2 00 61 b0 	ld  [ %g1 + 0x1b0 ], %o1	! 4002d1b0 <MSDOS_DOTDOT_NAME>
4001826c:	90 07 bf e0 	add  %fp, -32, %o0                             
40018270:	40 00 12 ed 	call  4001ce24 <memcpy>                        
40018274:	94 10 20 0b 	mov  0xb, %o2                                  
        /*                                                            
         * 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)) &&                    
40018278:	c2 04 60 20 	ld  [ %l1 + 0x20 ], %g1                        
4001827c:	80 a0 60 01 	cmp  %g1, 1                                    
40018280:	22 80 00 73 	be,a   4001844c <msdos_creat_node+0x3f4>       
40018284:	c2 04 60 24 	ld  [ %l1 + 0x24 ], %g1                        
            *MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
        }                                                             
        else                                                          
        {                                                             
            *MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 
                CT_LE_W((uint16_t  )((parent_fat_fd->cln) & 0x0000FFFF));
40018288:	c2 04 60 1c 	ld  [ %l1 + 0x1c ], %g1                        
                                                                      
err:                                                                  
    /* mark the used 32bytes structure on the disk as free */         
    msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
    return rc;                                                        
}                                                                     
4001828c:	07 00 00 3f 	sethi  %hi(0xfc00), %g3                        
        else                                                          
        {                                                             
            *MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 
                CT_LE_W((uint16_t  )((parent_fat_fd->cln) & 0x0000FFFF));
            *MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =  
                CT_LE_W((uint16_t  )(((parent_fat_fd->cln) & 0xFFFF0000)>>16));
40018290:	85 30 60 10 	srl  %g1, 0x10, %g2                            
                                                                      
err:                                                                  
    /* mark the used 32bytes structure on the disk as free */         
    msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
    return rc;                                                        
}                                                                     
40018294:	86 10 e3 ff 	or  %g3, 0x3ff, %g3                            
            *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)) = 
40018298:	89 28 60 10 	sll  %g1, 0x10, %g4                            
                                                                      
err:                                                                  
    /* mark the used 32bytes structure on the disk as free */         
    msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
    return rc;                                                        
}                                                                     
4001829c:	82 08 40 03 	and  %g1, %g3, %g1                             
            *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)) = 
400182a0:	89 31 20 18 	srl  %g4, 0x18, %g4                            
                                                                      
err:                                                                  
    /* mark the used 32bytes structure on the disk as free */         
    msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
    return rc;                                                        
}                                                                     
400182a4:	86 08 80 03 	and  %g2, %g3, %g3                             
            *MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
        }                                                             
        else                                                          
        {                                                             
            *MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 
                CT_LE_W((uint16_t  )((parent_fat_fd->cln) & 0x0000FFFF));
400182a8:	83 28 60 08 	sll  %g1, 8, %g1                               
            *MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =  
                CT_LE_W((uint16_t  )(((parent_fat_fd->cln) & 0xFFFF0000)>>16));
400182ac:	87 28 e0 08 	sll  %g3, 8, %g3                               
            *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)) = 
400182b0:	82 10 40 04 	or  %g1, %g4, %g1                              
                CT_LE_W((uint16_t  )((parent_fat_fd->cln) & 0x0000FFFF));
            *MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =  
400182b4:	85 30 a0 08 	srl  %g2, 8, %g2                               
            *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)) = 
400182b8:	c2 37 bf fa 	sth  %g1, [ %fp + -6 ]                         
                CT_LE_W((uint16_t  )((parent_fat_fd->cln) & 0x0000FFFF));
            *MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =  
400182bc:	84 10 c0 02 	or  %g3, %g2, %g2                              
400182c0:	c4 37 bf f4 	sth  %g2, [ %fp + -12 ]                        
        /*                                                            
         * 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(&fs_info->fat, fat_fd, 0,                
400182c4:	90 10 00 10 	mov  %l0, %o0                                  
400182c8:	92 10 00 19 	mov  %i1, %o1                                  
400182cc:	94 10 20 00 	clr  %o2                                       
400182d0:	96 10 20 40 	mov  0x40, %o3                                 
400182d4:	7f ff ea e7 	call  40012e70 <fat_file_write>                
400182d8:	98 07 bf c0 	add  %fp, -64, %o4                             
                             MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2,   
                             (uint8_t *)dot_dotdot);                  
        if (ret < 0)                                                  
400182dc:	80 a2 20 00 	cmp  %o0, 0                                    
400182e0:	06 80 00 26 	bl  40018378 <msdos_creat_node+0x320>          <== NEVER TAKEN
400182e4:	d2 07 bf 6c 	ld  [ %fp + -148 ], %o1                        
            rc = -1;                                                  
            goto error;                                               
        }                                                             
                                                                      
        /* increment fat-file size by cluster size */                 
        fat_fd->fat_file_size += fs_info->fat.vol.bpc;                
400182e8:	c4 14 20 06 	lduh  [ %l0 + 6 ], %g2                         
400182ec:	c6 02 60 18 	ld  [ %o1 + 0x18 ], %g3                        
                                                                      
        /* 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));    
400182f0:	c2 02 60 1c 	ld  [ %o1 + 0x1c ], %g1                        
            rc = -1;                                                  
            goto error;                                               
        }                                                             
                                                                      
        /* increment fat-file size by cluster size */                 
        fat_fd->fat_file_size += fs_info->fat.vol.bpc;                
400182f4:	84 00 c0 02 	add  %g3, %g2, %g2                             
                                                                      
        /* set up cluster num for dot entry */                        
        *MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =        
400182f8:	bb 28 60 10 	sll  %g1, 0x10, %i5                            
                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));
400182fc:	87 30 60 10 	srl  %g1, 0x10, %g3                            
            rc = -1;                                                  
            goto error;                                               
        }                                                             
                                                                      
        /* increment fat-file size by cluster size */                 
        fat_fd->fat_file_size += fs_info->fat.vol.bpc;                
40018300:	c4 22 60 18 	st  %g2, [ %o1 + 0x18 ]                        
                                                                      
        /* 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)) =         
40018304:	89 30 e0 08 	srl  %g3, 8, %g4                               
                                                                      
        /* 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)) =        
40018308:	bb 37 60 18 	srl  %i5, 0x18, %i5                            
                                                                      
err:                                                                  
    /* mark the used 32bytes structure on the disk as free */         
    msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
    return rc;                                                        
}                                                                     
4001830c:	05 00 00 3f 	sethi  %hi(0xfc00), %g2                        
40018310:	84 10 a3 ff 	or  %g2, 0x3ff, %g2	! ffff <PROM_START+0xffff> 
40018314:	82 08 40 02 	and  %g1, %g2, %g1                             
40018318:	84 08 c0 02 	and  %g3, %g2, %g2                             
        /* 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)) =        
                CT_LE_W((uint16_t  )((fat_fd->cln) & 0x0000FFFF));    
4001831c:	83 28 60 08 	sll  %g1, 8, %g1                               
        *MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =         
                CT_LE_W((uint16_t  )(((fat_fd->cln) & 0xFFFF0000) >> 16));
40018320:	85 28 a0 08 	sll  %g2, 8, %g2                               
                                                                      
        /* 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)) =        
40018324:	82 10 40 1d 	or  %g1, %i5, %g1                              
                CT_LE_W((uint16_t  )((fat_fd->cln) & 0x0000FFFF));    
        *MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =         
40018328:	84 10 80 04 	or  %g2, %g4, %g2                              
                CT_LE_W((uint16_t  )(((fat_fd->cln) & 0xFFFF0000) >> 16));
                                                                      
        /* rewrite dot entry */                                       
        ret = fat_file_write(&fs_info->fat, fat_fd, 0,                
4001832c:	90 10 00 10 	mov  %l0, %o0                                  
                                                                      
        /* 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)) =        
40018330:	c2 37 bf da 	sth  %g1, [ %fp + -38 ]                        
                CT_LE_W((uint16_t  )((fat_fd->cln) & 0x0000FFFF));    
        *MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =         
40018334:	c4 37 bf d4 	sth  %g2, [ %fp + -44 ]                        
                CT_LE_W((uint16_t  )(((fat_fd->cln) & 0xFFFF0000) >> 16));
                                                                      
        /* rewrite dot entry */                                       
        ret = fat_file_write(&fs_info->fat, fat_fd, 0,                
40018338:	94 10 20 00 	clr  %o2                                       
4001833c:	96 10 20 20 	mov  0x20, %o3                                 
40018340:	7f ff ea cc 	call  40012e70 <fat_file_write>                
40018344:	98 07 bf c0 	add  %fp, -64, %o4                             
                             MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,       
                             (uint8_t *)DOT_NODE_P(dot_dotdot));      
        if (ret < 0)                                                  
40018348:	80 a2 20 00 	cmp  %o0, 0                                    
4001834c:	06 80 00 0c 	bl  4001837c <msdos_creat_node+0x324>          <== NEVER TAKEN
40018350:	ba 10 3f ff 	mov  -1, %i5                                   
            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);
40018354:	d0 06 20 14 	ld  [ %i0 + 0x14 ], %o0                        
40018358:	40 00 01 74 	call  40018928 <msdos_set_first_cluster_num>   
4001835c:	d2 07 bf 6c 	ld  [ %fp + -148 ], %o1                        
        if (rc != RC_OK)                                              
40018360:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40018364:	12 80 00 07 	bne  40018380 <msdos_creat_node+0x328>         <== NEVER TAKEN
40018368:	d2 07 bf 6c 	ld  [ %fp + -148 ], %o1                        
            goto error;                                               
                                                                      
        fat_file_close(&fs_info->fat, fat_fd);                        
4001836c:	7f ff e9 c9 	call  40012a90 <fat_file_close>                
40018370:	90 10 00 10 	mov  %l0, %o0                                  
40018374:	30 bf ff 90 	b,a   400181b4 <msdos_creat_node+0x15c>        
        ret = fat_file_write(&fs_info->fat, fat_fd, 0,                
                             MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2,   
                             (uint8_t *)dot_dotdot);                  
        if (ret < 0)                                                  
        {                                                             
            rc = -1;                                                  
40018378:	ba 10 3f ff 	mov  -1, %i5                                   <== NOT EXECUTED
        fat_file_close(&fs_info->fat, fat_fd);                        
    }                                                                 
    return RC_OK;                                                     
                                                                      
error:                                                                
    fat_file_close(&fs_info->fat, fat_fd);                            
4001837c:	d2 07 bf 6c 	ld  [ %fp + -148 ], %o1                        <== NOT EXECUTED
40018380:	7f ff e9 c4 	call  40012a90 <fat_file_close>                <== NOT EXECUTED
40018384:	90 10 00 10 	mov  %l0, %o0                                  <== 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);
40018388:	d0 06 20 14 	ld  [ %i0 + 0x14 ], %o0                        <== NOT EXECUTED
4001838c:	92 07 bf 70 	add  %fp, -144, %o1                            <== NOT EXECUTED
40018390:	94 10 20 e5 	mov  0xe5, %o2                                 <== NOT EXECUTED
40018394:	40 00 01 c9 	call  40018ab8 <msdos_set_first_char4file_name><== NOT EXECUTED
40018398:	b0 10 00 1d 	mov  %i5, %i0                                  <== NOT EXECUTED
    return rc;                                                        
}                                                                     
4001839c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400183a0:	81 e8 00 00 	restore                                        <== NOT EXECUTED
       * node to the newly created                                    
       */                                                             
      /*                                                              
       * read the original directory entry                            
       */                                                             
      sec = fat_cluster_num_to_sector_num(&fs_info->fat,              
400183a4:	c2 07 60 20 	ld  [ %i5 + 0x20 ], %g1                        <== NOT EXECUTED
fat_cluster_num_to_sector_num(                                        
    const fat_fs_info_t *fs_info,                                     
    uint32_t             cln                                          
    )                                                                 
{                                                                     
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
400183a8:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
400183ac:	32 80 00 07 	bne,a   400183c8 <msdos_creat_node+0x370>      <== NOT EXECUTED
400183b0:	c6 0c 20 05 	ldub  [ %l0 + 5 ], %g3                         <== NOT EXECUTED
400183b4:	c4 0c 20 0e 	ldub  [ %l0 + 0xe ], %g2                       <== NOT EXECUTED
400183b8:	80 88 a0 03 	btst  3, %g2                                   <== NOT EXECUTED
400183bc:	32 80 00 07 	bne,a   400183d8 <msdos_creat_node+0x380>      <== NOT EXECUTED
400183c0:	d2 04 20 20 	ld  [ %l0 + 0x20 ], %o1                        <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
                                                                      
    return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +        
400183c4:	c6 0c 20 05 	ldub  [ %l0 + 5 ], %g3                         <== NOT EXECUTED
400183c8:	c4 04 20 34 	ld  [ %l0 + 0x34 ], %g2                        <== NOT EXECUTED
400183cc:	92 00 7f fe 	add  %g1, -2, %o1                              <== NOT EXECUTED
400183d0:	93 2a 40 03 	sll  %o1, %g3, %o1                             <== NOT EXECUTED
400183d4:	92 02 40 02 	add  %o1, %g2, %o1                             <== NOT EXECUTED
                                          link_fd->dir_pos.sname.cln);
      sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
400183d8:	c2 07 60 24 	ld  [ %i5 + 0x24 ], %g1                        <== NOT EXECUTED
400183dc:	c4 0c 20 02 	ldub  [ %l0 + 2 ], %g2                         <== NOT EXECUTED
      byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
400183e0:	d4 14 00 00 	lduh  [ %l0 ], %o2                             <== NOT EXECUTED
      /*                                                              
       * read the original directory entry                            
       */                                                             
      sec = fat_cluster_num_to_sector_num(&fs_info->fat,              
                                          link_fd->dir_pos.sname.cln);
      sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
400183e4:	85 30 40 02 	srl  %g1, %g2, %g2                             <== NOT EXECUTED
      byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
400183e8:	94 02 bf ff 	add  %o2, -1, %o2                              <== NOT EXECUTED
                                                                      
      ret = _fat_block_read(&fs_info->fat,                            
400183ec:	90 10 00 10 	mov  %l0, %o0                                  <== NOT EXECUTED
400183f0:	92 02 40 02 	add  %o1, %g2, %o1                             <== NOT EXECUTED
400183f4:	94 0a 80 01 	and  %o2, %g1, %o2                             <== NOT EXECUTED
400183f8:	96 10 20 20 	mov  0x20, %o3                                 <== NOT EXECUTED
400183fc:	7f ff ec 37 	call  400134d8 <_fat_block_read>               <== NOT EXECUTED
40018400:	98 07 bf a0 	add  %fp, -96, %o4                             <== NOT EXECUTED
                            sec, byte, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
                            link_node);                               
      if (ret < 0) {                                                  
40018404:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40018408:	06 80 00 26 	bl  400184a0 <msdos_creat_node+0x448>          <== NOT EXECUTED
4001840c:	c4 0f bf ad 	ldub  [ %fp + -83 ], %g2                       <== NOT EXECUTED
          return -1;                                                  
      }                                                               
      /*                                                              
       * copy various attributes                                      
       */                                                             
      *MSDOS_DIR_ATTR(short_node)          =*MSDOS_DIR_ATTR(link_node);
40018410:	c2 0f bf ab 	ldub  [ %fp + -85 ], %g1                       <== NOT EXECUTED
      *MSDOS_DIR_CRT_TIME_TENTH(short_node)=*MSDOS_DIR_CRT_TIME_TENTH(link_node);
40018414:	c4 2f bf 8d 	stb  %g2, [ %fp + -115 ]                       <== NOT EXECUTED
      *MSDOS_DIR_CRT_TIME(short_node)      =*MSDOS_DIR_CRT_TIME(link_node);
40018418:	c4 17 bf ae 	lduh  [ %fp + -82 ], %g2                       <== 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;              
4001841c:	82 10 60 20 	or  %g1, 0x20, %g1                             <== 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);
40018420:	c4 37 bf 8e 	sth  %g2, [ %fp + -114 ]                       <== NOT EXECUTED
      *MSDOS_DIR_CRT_DATE(short_node)      =*MSDOS_DIR_CRT_DATE(link_node);
40018424:	c4 17 bf b0 	lduh  [ %fp + -80 ], %g2                       <== 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;              
40018428:	c2 2f bf 8b 	stb  %g1, [ %fp + -117 ]                       <== 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);
4001842c:	c4 37 bf 90 	sth  %g2, [ %fp + -112 ]                       <== NOT EXECUTED
                                                                      
      /*                                                              
       * copy/set "file size", "first cluster"                        
       */                                                             
      *MSDOS_DIR_FILE_SIZE(short_node)     =*MSDOS_DIR_FILE_SIZE(link_node);
40018430:	c4 07 bf bc 	ld  [ %fp + -68 ], %g2                         <== NOT EXECUTED
40018434:	c4 27 bf 9c 	st  %g2, [ %fp + -100 ]                        <== NOT EXECUTED
                                                                      
      *MSDOS_DIR_FIRST_CLUSTER_LOW(short_node) =                      
40018438:	c4 17 bf ba 	lduh  [ %fp + -70 ], %g2                       <== NOT EXECUTED
4001843c:	c4 37 bf 9a 	sth  %g2, [ %fp + -102 ]                       <== NOT EXECUTED
           *MSDOS_DIR_FIRST_CLUSTER_LOW(link_node);                   
      *MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =                       
40018440:	c4 17 bf b4 	lduh  [ %fp + -76 ], %g2                       <== NOT EXECUTED
40018444:	10 bf ff 53 	b  40018190 <msdos_creat_node+0x138>           <== NOT EXECUTED
40018448:	c4 37 bf 94 	sth  %g2, [ %fp + -108 ]                       <== 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)) &&                    
4001844c:	80 a0 60 00 	cmp  %g1, 0                                    
40018450:	32 bf ff 8f 	bne,a   4001828c <msdos_creat_node+0x234>      <== NEVER TAKEN
40018454:	c2 04 60 1c 	ld  [ %l1 + 0x1c ], %g1                        <== NOT EXECUTED
            (fs_info->fat.vol.type & FAT_FAT32))                      
40018458:	c2 0c 20 0e 	ldub  [ %l0 + 0xe ], %g1                       
        /*                                                            
         * 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)) &&                    
4001845c:	82 08 60 04 	and  %g1, 4, %g1                               
40018460:	80 88 60 ff 	btst  0xff, %g1                                
40018464:	22 bf ff 8a 	be,a   4001828c <msdos_creat_node+0x234>       <== ALWAYS TAKEN
40018468:	c2 04 60 1c 	ld  [ %l1 + 0x1c ], %g1                        
            (fs_info->fat.vol.type & FAT_FAT32))                      
        {                                                             
            *MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
4001846c:	c0 37 bf fa 	clrh  [ %fp + -6 ]                             <== NOT EXECUTED
            *MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
40018470:	10 bf ff 95 	b  400182c4 <msdos_creat_node+0x26c>           <== NOT EXECUTED
40018474:	c0 37 bf f4 	clrh  [ %fp + -12 ]                            <== NOT EXECUTED
                                                                      
    memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);         
    memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);     
                                                                      
    if (name_len > MSDOS_NAME_MAX_LFN_WITH_DOT) {                     
        rtems_set_errno_and_return_minus_one(ENAMETOOLONG);           
40018478:	40 00 0f c6 	call  4001c390 <__errno>                       <== NOT EXECUTED
4001847c:	ba 10 3f ff 	mov  -1, %i5                                   <== NOT EXECUTED
40018480:	82 10 20 5b 	mov  0x5b, %g1                                 <== NOT EXECUTED
40018484:	10 bf ff 4c 	b  400181b4 <msdos_creat_node+0x15c>           <== NOT EXECUTED
40018488:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
                                                                      
    name_type = msdos_long_to_short (name, name_len,                  
                                     MSDOS_DIR_NAME(short_node),      
                                     MSDOS_NAME_MAX);                 
    if (name_type == MSDOS_NAME_INVALID) {                            
        rtems_set_errno_and_return_minus_one(EINVAL);                 
4001848c:	40 00 0f c1 	call  4001c390 <__errno>                       <== NOT EXECUTED
40018490:	ba 10 3f ff 	mov  -1, %i5                                   <== NOT EXECUTED
40018494:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
40018498:	10 bf ff 47 	b  400181b4 <msdos_creat_node+0x15c>           <== NOT EXECUTED
4001849c:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
    *MSDOS_DIR_NT_RES(short_node) = MSDOS_RES_NT_VALUE;               
                                                                      
    /* set up last write date and time */                             
    time_ret = time(NULL);                                            
    if ( time_ret == -1 )                                             
        return -1;                                                    
400184a0:	10 bf ff 45 	b  400181b4 <msdos_creat_node+0x15c>           <== NOT EXECUTED
400184a4:	ba 10 3f ff 	mov  -1, %i5                                   <== NOT EXECUTED
                                                                      

4001b4c0 <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) {
4001b4c0:	09 10 00 b8 	sethi  %hi(0x4002e000), %g4                    
4001b4c4:	da 11 22 52 	lduh  [ %g4 + 0x252 ], %o5	! 4002e252 <lastdosdate>
	uint32_t y, year;                                                    
	uint32_t days;                                                       
	uint16_t *months;                                                    
                                                                      
	seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
	    + ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60  
4001b4c8:	86 0a 67 e0 	and  %o1, 0x7e0, %g3                           
	    + ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;   
4001b4cc:	85 32 60 0b 	srl  %o1, 0xb, %g2                             
	uint32_t y, year;                                                    
	uint32_t days;                                                       
	uint16_t *months;                                                    
                                                                      
	seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
	    + ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60  
4001b4d0:	83 30 e0 04 	srl  %g3, 4, %g1                               
	    + ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;   
4001b4d4:	84 08 a0 1f 	and  %g2, 0x1f, %g2                            
	uint32_t y, year;                                                    
	uint32_t days;                                                       
	uint16_t *months;                                                    
                                                                      
	seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
	    + ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60  
4001b4d8:	86 20 c0 01 	sub  %g3, %g1, %g3                             
	    + ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;   
4001b4dc:	99 28 a0 03 	sll  %g2, 3, %o4                               
4001b4e0:	83 28 a0 07 	sll  %g2, 7, %g1                               
	uint32_t m, month;                                                   
	uint32_t y, year;                                                    
	uint32_t days;                                                       
	uint16_t *months;                                                    
                                                                      
	seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
4001b4e4:	92 0a 60 1f 	and  %o1, 0x1f, %o1                            
	    + ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60  
	    + ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;   
4001b4e8:	82 20 40 0c 	sub  %g1, %o4, %g1                             
	/*                                                                   
	 * If the year, month, and day from the last conversion are the      
	 * same then use the saved value.                                    
	 */                                                                  
	if (lastdosdate != dd) {                                             
4001b4ec:	80 a3 40 08 	cmp  %o5, %o0                                  
	uint32_t days;                                                       
	uint16_t *months;                                                    
                                                                      
	seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
	    + ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60  
	    + ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;   
4001b4f0:	85 28 60 04 	sll  %g1, 4, %g2                               
4001b4f4:	82 20 80 01 	sub  %g2, %g1, %g1                             
4001b4f8:	82 00 40 03 	add  %g1, %g3, %g1                             
4001b4fc:	92 00 40 09 	add  %g1, %o1, %o1                             
	/*                                                                   
	 * If the year, month, and day from the last conversion are the      
	 * same then use the saved value.                                    
	 */                                                                  
	if (lastdosdate != dd) {                                             
4001b500:	02 80 00 3a 	be  4001b5e8 <msdos_date_dos2unix+0x128>       
4001b504:	93 2a 60 01 	sll  %o1, 1, %o1                               
		lastdosdate = dd;                                                   
4001b508:	d0 31 22 52 	sth  %o0, [ %g4 + 0x252 ]                      
		days = 0;                                                           
		year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;            
		for (y = 0; y < year; y++)                                          
4001b50c:	82 10 20 00 	clr  %g1                                       
	 * same then use the saved value.                                    
	 */                                                                  
	if (lastdosdate != dd) {                                             
		lastdosdate = dd;                                                   
		days = 0;                                                           
		year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;            
4001b510:	89 32 20 09 	srl  %o0, 9, %g4                               
		for (y = 0; y < year; y++)                                          
4001b514:	84 10 20 00 	clr  %g2                                       
4001b518:	88 89 20 7f 	andcc  %g4, 0x7f, %g4                          
4001b51c:	12 80 00 08 	bne  4001b53c <msdos_date_dos2unix+0x7c>       <== ALWAYS TAKEN
4001b520:	86 10 21 6e 	mov  0x16e, %g3                                
			days += y & 0x03 ? 365 : 366;                                      
		months = year & 0x03 ? regyear : leapyear;                          
4001b524:	10 80 00 2f 	b  4001b5e0 <msdos_date_dos2unix+0x120>        <== NOT EXECUTED
4001b528:	09 10 00 b6 	sethi  %hi(0x4002d800), %g4                    <== 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++)                                          
			days += y & 0x03 ? 365 : 366;                                      
4001b52c:	86 08 a0 03 	and  %g2, 3, %g3                               
4001b530:	80 a0 00 03 	cmp  %g0, %g3                                  
4001b534:	86 60 3f ff 	subx  %g0, -1, %g3                             
4001b538:	86 00 e1 6d 	add  %g3, 0x16d, %g3                           
	 */                                                                  
	if (lastdosdate != dd) {                                             
		lastdosdate = dd;                                                   
		days = 0;                                                           
		year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;            
		for (y = 0; y < year; y++)                                          
4001b53c:	84 00 a0 01 	inc  %g2                                       
4001b540:	80 a0 80 04 	cmp  %g2, %g4                                  
4001b544:	12 bf ff fa 	bne  4001b52c <msdos_date_dos2unix+0x6c>       
4001b548:	82 00 40 03 	add  %g1, %g3, %g1                             
			days += y & 0x03 ? 365 : 366;                                      
		months = year & 0x03 ? regyear : leapyear;                          
4001b54c:	80 88 a0 03 	btst  3, %g2                                   
4001b550:	02 80 00 24 	be  4001b5e0 <msdos_date_dos2unix+0x120>       <== ALWAYS TAKEN
4001b554:	09 10 00 b6 	sethi  %hi(0x4002d800), %g4                    
4001b558:	09 10 00 b6 	sethi  %hi(0x4002d800), %g4                    <== NOT EXECUTED
4001b55c:	88 11 23 14 	or  %g4, 0x314, %g4	! 4002db14 <regyear>       <== NOT EXECUTED
		/*                                                                  
		 * Prevent going from 0 to 0xffffffff in the following              
		 * loop.                                                            
		 */                                                                 
		month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;         
4001b560:	9a 0a 21 e0 	and  %o0, 0x1e0, %o5                           
4001b564:	9b 33 60 05 	srl  %o5, 5, %o5                               
		if (month == 0) {                                                   
4001b568:	80 a3 60 00 	cmp  %o5, 0                                    
4001b56c:	22 80 00 0d 	be,a   4001b5a0 <msdos_date_dos2unix+0xe0>     <== NEVER TAKEN
4001b570:	90 0a 20 1f 	and  %o0, 0x1f, %o0                            <== NOT EXECUTED
			month = 1;                                                         
		}                                                                   
		for (m = 0; m < month - 1; m++)                                     
4001b574:	80 a3 60 01 	cmp  %o5, 1                                    
4001b578:	02 80 00 09 	be  4001b59c <msdos_date_dos2unix+0xdc>        <== ALWAYS TAKEN
4001b57c:	84 10 20 00 	clr  %g2                                       
 * Convert from dos' idea of time to unix'. This will probably only be
 * 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)                 
4001b580:	9a 03 7f ff 	add  %o5, -1, %o5                              <== NOT EXECUTED
4001b584:	9b 2b 60 01 	sll  %o5, 1, %o5                               <== NOT EXECUTED
		month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;         
		if (month == 0) {                                                   
			month = 1;                                                         
		}                                                                   
		for (m = 0; m < month - 1; m++)                                     
			days += months[m];                                                 
4001b588:	c6 11 00 02 	lduh  [ %g4 + %g2 ], %g3                       <== NOT EXECUTED
4001b58c:	84 00 a0 02 	add  %g2, 2, %g2                               <== NOT EXECUTED
		 */                                                                 
		month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;         
		if (month == 0) {                                                   
			month = 1;                                                         
		}                                                                   
		for (m = 0; m < month - 1; m++)                                     
4001b590:	80 a0 80 0d 	cmp  %g2, %o5                                  <== NOT EXECUTED
4001b594:	12 bf ff fd 	bne  4001b588 <msdos_date_dos2unix+0xc8>       <== NOT EXECUTED
4001b598:	82 00 40 03 	add  %g1, %g3, %g1                             <== NOT EXECUTED
			days += months[m];                                                 
		days += ((dd & MSDOS_DD_DAY_MASK) >> MSDOS_DD_DAY_SHIFT) - 1;       
4001b59c:	90 0a 20 1f 	and  %o0, 0x1f, %o0                            
4001b5a0:	90 02 3f ff 	add  %o0, -1, %o0                              
4001b5a4:	82 02 00 01 	add  %o0, %g1, %g1                             
		lastseconds = (days + DAYSTO1980) * SECONDSPERDAY;                  
4001b5a8:	85 28 60 07 	sll  %g1, 7, %g2                               
4001b5ac:	83 28 60 09 	sll  %g1, 9, %g1                               
4001b5b0:	82 20 40 02 	sub  %g1, %g2, %g1                             
4001b5b4:	85 28 60 04 	sll  %g1, 4, %g2                               
4001b5b8:	82 20 80 01 	sub  %g2, %g1, %g1                             
4001b5bc:	85 28 60 04 	sll  %g1, 4, %g2                               
4001b5c0:	82 20 80 01 	sub  %g2, %g1, %g1                             
4001b5c4:	05 04 b3 a9 	sethi  %hi(0x12cea400), %g2                    
4001b5c8:	84 10 a2 00 	or  %g2, 0x200, %g2	! 12cea600 <RAM_SIZE+0x128ea600>
4001b5cc:	90 00 40 02 	add  %g1, %g2, %o0                             
4001b5d0:	05 10 00 b8 	sethi  %hi(0x4002e000), %g2                    
4001b5d4:	d0 20 a2 54 	st  %o0, [ %g2 + 0x254 ]	! 4002e254 <lastseconds>
	}                                                                    
	return seconds + lastseconds;                                        
}                                                                     
4001b5d8:	81 c3 e0 08 	retl                                           
4001b5dc:	90 02 00 09 	add  %o0, %o1, %o0                             
		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;                          
4001b5e0:	10 bf ff e0 	b  4001b560 <msdos_date_dos2unix+0xa0>         
4001b5e4:	88 11 23 2c 	or  %g4, 0x32c, %g4                            
4001b5e8:	03 10 00 b8 	sethi  %hi(0x4002e000), %g1                    
4001b5ec:	d0 00 62 54 	ld  [ %g1 + 0x254 ], %o0	! 4002e254 <lastseconds>
			days += months[m];                                                 
		days += ((dd & MSDOS_DD_DAY_MASK) >> MSDOS_DD_DAY_SHIFT) - 1;       
		lastseconds = (days + DAYSTO1980) * SECONDSPERDAY;                  
	}                                                                    
	return seconds + lastseconds;                                        
}                                                                     
4001b5f0:	81 c3 e0 08 	retl                                           
4001b5f4:	90 02 00 09 	add  %o0, %o1, %o0                             
                                                                      

4001b348 <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) {
4001b348:	9d e3 bf a0 	save  %sp, -96, %sp                            
                                                                      
	/*                                                                   
	 * If the time from the last conversion is the same as now, then     
	 * skip the computations and use the saved result.                   
	 */                                                                  
	if (lasttime != t) {                                                 
4001b34c:	03 10 00 b8 	sethi  %hi(0x4002e000), %g1                    
4001b350:	c4 00 62 44 	ld  [ %g1 + 0x244 ], %g2	! 4002e244 <lasttime> 
4001b354:	80 a0 80 18 	cmp  %g2, %i0                                  
4001b358:	02 80 00 4d 	be  4001b48c <msdos_date_unix2dos+0x144>       
4001b35c:	92 10 20 3c 	mov  0x3c, %o1                                 
		lasttime = t;                                                       
4001b360:	f0 20 62 44 	st  %i0, [ %g1 + 0x244 ]                       
		lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)            
		    + (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)                   
4001b364:	7f ff 9c c4 	call  40002674 <.udiv>                         
4001b368:	90 10 00 18 	mov  %i0, %o0                                  
4001b36c:	40 00 38 63 	call  400294f8 <.urem>                         
4001b370:	92 10 20 3c 	mov  0x3c, %o1                                 
		    + (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);                  
4001b374:	92 10 2e 10 	mov  0xe10, %o1                                
	 * 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)            
4001b378:	bb 2a 20 05 	sll  %o0, 5, %i5                               
		    + (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)                   
		    + (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);                  
4001b37c:	7f ff 9c be 	call  40002674 <.udiv>                         
4001b380:	90 10 00 18 	mov  %i0, %o0                                  
4001b384:	40 00 38 5d 	call  400294f8 <.urem>                         
4001b388:	92 10 20 18 	mov  0x18, %o1                                 
	 * 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)            
4001b38c:	83 2a 20 0b 	sll  %o0, 0xb, %g1                             
4001b390:	92 10 20 3c 	mov  0x3c, %o1                                 
4001b394:	ba 07 40 01 	add  %i5, %g1, %i5                             
4001b398:	40 00 38 58 	call  400294f8 <.urem>                         
4001b39c:	90 10 00 18 	mov  %i0, %o0                                  
4001b3a0:	05 10 00 b8 	sethi  %hi(0x4002e000), %g2                    
4001b3a4:	91 32 20 01 	srl  %o0, 1, %o0                               
4001b3a8:	82 07 40 08 	add  %i5, %o0, %g1                             
		/*                                                                  
		 * 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);                                         
4001b3ac:	13 00 00 54 	sethi  %hi(0x15000), %o1                       
	 * 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)            
4001b3b0:	c2 30 a2 48 	sth  %g1, [ %g2 + 0x248 ]                      
4001b3b4:	ba 10 00 01 	mov  %g1, %i5                                  
		/*                                                                  
		 * 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);                                         
4001b3b8:	90 10 00 18 	mov  %i0, %o0                                  
4001b3bc:	7f ff 9c ae 	call  40002674 <.udiv>                         
4001b3c0:	92 12 61 80 	or  %o1, 0x180, %o1                            
		if (days != lastday) {                                              
4001b3c4:	03 10 00 b8 	sethi  %hi(0x4002e000), %g1                    
4001b3c8:	c4 00 62 4c 	ld  [ %g1 + 0x24c ], %g2	! 4002e24c <lastday>  
4001b3cc:	80 a2 00 02 	cmp  %o0, %g2                                  
4001b3d0:	22 80 00 37 	be,a   4001b4ac <msdos_date_unix2dos+0x164>    
4001b3d4:	03 10 00 b8 	sethi  %hi(0x4002e000), %g1                    
			lastday = days;                                                    
4001b3d8:	d0 20 62 4c 	st  %o0, [ %g1 + 0x24c ]	! 4002e24c <lastday>  
			for (year = 1970;; year++) {                                       
4001b3dc:	10 80 00 03 	b  4001b3e8 <msdos_date_unix2dos+0xa0>         
4001b3e0:	82 10 27 b2 	mov  0x7b2, %g1                                
4001b3e4:	82 00 60 01 	inc  %g1                                       
				inc = year & 0x03 ? 365 : 366;                                    
4001b3e8:	86 08 60 03 	and  %g1, 3, %g3                               
4001b3ec:	80 a0 00 03 	cmp  %g0, %g3                                  
4001b3f0:	84 60 3f ff 	subx  %g0, -1, %g2                             
4001b3f4:	84 00 a1 6d 	add  %g2, 0x16d, %g2                           
				if (days < inc)                                                   
4001b3f8:	80 a2 00 02 	cmp  %o0, %g2                                  
4001b3fc:	3a bf ff fa 	bcc,a   4001b3e4 <msdos_date_unix2dos+0x9c>    
4001b400:	90 22 00 02 	sub  %o0, %g2, %o0                             
					break;                                                           
				days -= inc;                                                      
			}                                                                  
			months = year & 0x03 ? regyear : leapyear;                         
4001b404:	80 a0 e0 00 	cmp  %g3, 0                                    
4001b408:	02 80 00 1d 	be  4001b47c <msdos_date_unix2dos+0x134>       <== ALWAYS TAKEN
4001b40c:	09 10 00 b6 	sethi  %hi(0x4002d800), %g4                    
4001b410:	09 10 00 b6 	sethi  %hi(0x4002d800), %g4                    <== NOT EXECUTED
4001b414:	88 11 23 14 	or  %g4, 0x314, %g4	! 4002db14 <regyear>       <== NOT EXECUTED
			for (month = 0; month < 12; month++) {                             
4001b418:	84 10 20 00 	clr  %g2                                       
/*                                                                    
 * Convert the unix version of time to dos's idea of time to be used in
 * file timestamps. The passed in unix time is assumed to be in GMT.  
 */                                                                   
void                                                                  
msdos_date_unix2dos(unsigned int t, uint16_t *ddp,                    
4001b41c:	87 28 a0 01 	sll  %g2, 1, %g3                               
					break;                                                           
				days -= inc;                                                      
			}                                                                  
			months = year & 0x03 ? regyear : leapyear;                         
			for (month = 0; month < 12; month++) {                             
				if (days < months[month])                                         
4001b420:	c6 11 00 03 	lduh  [ %g4 + %g3 ], %g3                       
4001b424:	80 a0 c0 08 	cmp  %g3, %o0                                  
4001b428:	18 80 00 17 	bgu  4001b484 <msdos_date_unix2dos+0x13c>      <== ALWAYS TAKEN
4001b42c:	84 00 a0 01 	inc  %g2                                       
				if (days < inc)                                                   
					break;                                                           
				days -= inc;                                                      
			}                                                                  
			months = year & 0x03 ? regyear : leapyear;                         
			for (month = 0; month < 12; month++) {                             
4001b430:	80 a0 a0 0c 	cmp  %g2, 0xc                                  <== NOT EXECUTED
4001b434:	12 bf ff fa 	bne  4001b41c <msdos_date_unix2dos+0xd4>       <== NOT EXECUTED
4001b438:	90 22 00 03 	sub  %o0, %g3, %o0                             <== NOT EXECUTED
4001b43c:	84 10 21 a0 	mov  0x1a0, %g2                                <== NOT EXECUTED
				if (days < months[month])                                         
					break;                                                           
				days -= months[month];                                            
			}                                                                  
			lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)                     
4001b440:	84 00 a0 01 	inc  %g2                                       
			 * 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)                                                   
4001b444:	80 a0 67 bc 	cmp  %g1, 0x7bc                                
			for (month = 0; month < 12; month++) {                             
				if (days < months[month])                                         
					break;                                                           
				days -= months[month];                                            
			}                                                                  
			lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)                     
4001b448:	90 00 80 08 	add  %g2, %o0, %o0                             
			 * 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)                                                   
4001b44c:	08 80 00 06 	bleu  4001b464 <msdos_date_unix2dos+0x11c>     <== NEVER TAKEN
4001b450:	84 10 00 08 	mov  %o0, %g2                                  
				lastddate += (year - 1980) <<                                     
4001b454:	82 00 78 44 	add  %g1, -1980, %g1                           
4001b458:	83 28 60 09 	sll  %g1, 9, %g1                               
4001b45c:	90 02 00 01 	add  %o0, %g1, %o0                             
4001b460:	84 10 00 08 	mov  %o0, %g2                                  
				             MSDOS_DD_YEAR_SHIFT;                                 
		}                                                                   
	}                                                                    
	*dtp = lastdtime;                                                    
4001b464:	fa 36 80 00 	sth  %i5, [ %i2 ]                              
			 * 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) <<                                     
4001b468:	03 10 00 b8 	sethi  %hi(0x4002e000), %g1                    
				             MSDOS_DD_YEAR_SHIFT;                                 
		}                                                                   
	}                                                                    
	*dtp = lastdtime;                                                    
	*ddp = lastddate;                                                    
4001b46c:	c4 36 40 00 	sth  %g2, [ %i1 ]                              
			 * 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) <<                                     
4001b470:	d0 30 62 50 	sth  %o0, [ %g1 + 0x250 ]                      
				             MSDOS_DD_YEAR_SHIFT;                                 
		}                                                                   
	}                                                                    
	*dtp = lastdtime;                                                    
	*ddp = lastddate;                                                    
4001b474:	81 c7 e0 08 	ret                                            
4001b478:	81 e8 00 00 	restore                                        
				inc = year & 0x03 ? 365 : 366;                                    
				if (days < inc)                                                   
					break;                                                           
				days -= inc;                                                      
			}                                                                  
			months = year & 0x03 ? regyear : leapyear;                         
4001b47c:	10 bf ff e7 	b  4001b418 <msdos_date_unix2dos+0xd0>         
4001b480:	88 11 23 2c 	or  %g4, 0x32c, %g4                            
4001b484:	10 bf ff ef 	b  4001b440 <msdos_date_unix2dos+0xf8>         
4001b488:	85 28 a0 05 	sll  %g2, 5, %g2                               
4001b48c:	03 10 00 b8 	sethi  %hi(0x4002e000), %g1                    
4001b490:	fa 10 62 48 	lduh  [ %g1 + 0x248 ], %i5	! 4002e248 <lastdtime>
4001b494:	03 10 00 b8 	sethi  %hi(0x4002e000), %g1                    
4001b498:	c4 10 62 50 	lduh  [ %g1 + 0x250 ], %g2	! 4002e250 <lastddate>
			if (year > 1980)                                                   
				lastddate += (year - 1980) <<                                     
				             MSDOS_DD_YEAR_SHIFT;                                 
		}                                                                   
	}                                                                    
	*dtp = lastdtime;                                                    
4001b49c:	fa 36 80 00 	sth  %i5, [ %i2 ]                              
	*ddp = lastddate;                                                    
4001b4a0:	c4 36 40 00 	sth  %g2, [ %i1 ]                              
4001b4a4:	81 c7 e0 08 	ret                                            
4001b4a8:	81 e8 00 00 	restore                                        
4001b4ac:	c4 10 62 50 	lduh  [ %g1 + 0x250 ], %g2                     
			if (year > 1980)                                                   
				lastddate += (year - 1980) <<                                     
				             MSDOS_DD_YEAR_SHIFT;                                 
		}                                                                   
	}                                                                    
	*dtp = lastdtime;                                                    
4001b4b0:	fa 36 80 00 	sth  %i5, [ %i2 ]                              
	*ddp = lastddate;                                                    
4001b4b4:	c4 36 40 00 	sth  %g2, [ %i1 ]                              
4001b4b8:	81 c7 e0 08 	ret                                            
4001b4bc:	81 e8 00 00 	restore                                        
                                                                      

40018c68 <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 ) {
40018c68:	9d e3 bf a0 	save  %sp, -96, %sp                            
    ssize_t          ret = 0;                                         
    msdos_fs_info_t *fs_info = mt_entry->fs_info;                     
40018c6c:	e0 06 20 08 	ld  [ %i0 + 8 ], %l0                           
             */                                                       
            if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==                    
                 MSDOS_THIS_DIR_ENTRY_EMPTY) ||                       
                ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==    
                 MSDOS_ATTR_LFN) ||                                   
                (strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,     
40018c70:	25 10 00 b4 	sethi  %hi(0x4002d000), %l2                    
40018c74:	e2 14 00 00 	lduh  [ %l0 ], %l1                             
40018c78:	ea 04 20 a0 	ld  [ %l0 + 0xa0 ], %l5                        
                         MSDOS_SHORT_NAME_LEN) == 0) ||               
                (strncmp(MSDOS_DIR_NAME((entry)),                     
40018c7c:	29 10 00 b4 	sethi  %hi(0x4002d000), %l4                    
    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;                                                 
40018c80:	c0 2e 80 00 	clrb  [ %i2 ]                                  
    bool                                 *ret_val                     
    )                                                                 
{                                                                     
    ssize_t          ret = 0;                                         
    msdos_fs_info_t *fs_info = mt_entry->fs_info;                     
    uint32_t         j = 0, i = 0;                                    
40018c84:	a6 10 20 00 	clr  %l3                                       
40018c88:	a3 2c 60 10 	sll  %l1, 0x10, %l1                            
             */                                                       
            if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==                    
                 MSDOS_THIS_DIR_ENTRY_EMPTY) ||                       
                ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==    
                 MSDOS_ATTR_LFN) ||                                   
                (strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,     
40018c8c:	a4 14 a1 70 	or  %l2, 0x170, %l2                            
                         MSDOS_SHORT_NAME_LEN) == 0) ||               
                (strncmp(MSDOS_DIR_NAME((entry)),                     
40018c90:	a8 15 21 80 	or  %l4, 0x180, %l4                            
    uint32_t         j = 0, i = 0;                                    
                                                                      
    /* dir is not empty */                                            
    *ret_val = false;                                                 
                                                                      
    while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * fs_info->fat.vol.bps,
40018c94:	a3 34 60 10 	srl  %l1, 0x10, %l1                            
40018c98:	92 10 00 13 	mov  %l3, %o1                                  
40018c9c:	7f ff a6 3c 	call  4000258c <.umul>                         
40018ca0:	90 10 00 11 	mov  %l1, %o0                                  
40018ca4:	92 10 00 19 	mov  %i1, %o1                                  
40018ca8:	94 10 00 08 	mov  %o0, %o2                                  
40018cac:	96 10 00 11 	mov  %l1, %o3                                  
40018cb0:	90 10 00 10 	mov  %l0, %o0                                  
40018cb4:	7f ff e6 b1 	call  40012778 <fat_file_read>                 
40018cb8:	98 10 00 15 	mov  %l5, %o4                                  
40018cbc:	80 a2 20 00 	cmp  %o0, 0                                    
40018cc0:	02 80 00 34 	be  40018d90 <msdos_dir_is_empty+0x128>        <== NEVER TAKEN
40018cc4:	80 a2 20 1f 	cmp  %o0, 0x1f                                 
                                  fs_info->fat.vol.bps,               
                                  fs_info->cl_buf)) != FAT_EOF)       
    {                                                                 
        if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)                  
40018cc8:	04 80 00 27 	ble  40018d64 <msdos_dir_is_empty+0xfc>        <== NEVER TAKEN
40018ccc:	b0 10 3f ff 	mov  -1, %i0                                   
            return -1;                                                
                                                                      
        assert(ret == fs_info->fat.vol.bps);                          
40018cd0:	e2 14 00 00 	lduh  [ %l0 ], %l1                             
40018cd4:	a3 2c 60 10 	sll  %l1, 0x10, %l1                            
40018cd8:	b1 34 60 10 	srl  %l1, 0x10, %i0                            
40018cdc:	80 a6 00 08 	cmp  %i0, %o0                                  
40018ce0:	12 80 00 2e 	bne  40018d98 <msdos_dir_is_empty+0x130>       <== NEVER TAKEN
40018ce4:	80 a6 20 00 	cmp  %i0, 0                                    
                                                                      
        /* have to look at the DIR_NAME as "raw" 8-bit data */        
        for (i = 0;                                                   
40018ce8:	02 80 00 27 	be  40018d84 <msdos_dir_is_empty+0x11c>        <== NEVER TAKEN
40018cec:	b8 10 20 00 	clr  %i4                                       
40018cf0:	ea 04 20 a0 	ld  [ %l0 + 0xa0 ], %l5                        
40018cf4:	ba 10 00 15 	mov  %l5, %i5                                  
             * 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)) ==                    
40018cf8:	f6 0f 40 00 	ldub  [ %i5 ], %i3                             
40018cfc:	80 a6 e0 e5 	cmp  %i3, 0xe5                                 
40018d00:	22 80 00 1c 	be,a   40018d70 <msdos_dir_is_empty+0x108>     <== NEVER TAKEN
40018d04:	b8 07 20 20 	add  %i4, 0x20, %i4                            <== NOT EXECUTED
                 MSDOS_THIS_DIR_ENTRY_EMPTY) ||                       
                ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==    
40018d08:	c2 0f 60 0b 	ldub  [ %i5 + 0xb ], %g1                       
             *                                                        
             * Just ignore long file name entries. They must have a short entry to
             * be valid.                                              
             */                                                       
            if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==                    
                 MSDOS_THIS_DIR_ENTRY_EMPTY) ||                       
40018d0c:	82 08 60 3f 	and  %g1, 0x3f, %g1                            
40018d10:	80 a0 60 0f 	cmp  %g1, 0xf                                  
40018d14:	02 80 00 16 	be  40018d6c <msdos_dir_is_empty+0x104>        <== NEVER TAKEN
40018d18:	90 10 00 1d 	mov  %i5, %o0                                  
                ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==    
                 MSDOS_ATTR_LFN) ||                                   
                (strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,     
40018d1c:	92 10 00 12 	mov  %l2, %o1                                  
40018d20:	40 00 14 91 	call  4001df64 <strncmp>                       
40018d24:	94 10 20 0b 	mov  0xb, %o2                                  
             * be valid.                                              
             */                                                       
            if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==                    
                 MSDOS_THIS_DIR_ENTRY_EMPTY) ||                       
                ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==    
                 MSDOS_ATTR_LFN) ||                                   
40018d28:	80 a2 20 00 	cmp  %o0, 0                                    
40018d2c:	22 80 00 11 	be,a   40018d70 <msdos_dir_is_empty+0x108>     
40018d30:	b8 07 20 20 	add  %i4, 0x20, %i4                            
                (strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,     
                         MSDOS_SHORT_NAME_LEN) == 0) ||               
                (strncmp(MSDOS_DIR_NAME((entry)),                     
40018d34:	90 10 00 1d 	mov  %i5, %o0                                  
40018d38:	92 10 00 14 	mov  %l4, %o1                                  
40018d3c:	40 00 14 8a 	call  4001df64 <strncmp>                       
40018d40:	94 10 20 0b 	mov  0xb, %o2                                  
            if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==                    
                 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) ||               
40018d44:	80 a2 20 00 	cmp  %o0, 0                                    
40018d48:	22 80 00 0a 	be,a   40018d70 <msdos_dir_is_empty+0x108>     
40018d4c:	b8 07 20 20 	add  %i4, 0x20, %i4                            
                continue;                                             
                                                                      
            /*                                                        
             * Nothing more to look at.                               
             */                                                       
            if ((*MSDOS_DIR_NAME(entry)) ==                           
40018d50:	80 a6 e0 00 	cmp  %i3, 0                                    
40018d54:	12 80 00 04 	bne  40018d64 <msdos_dir_is_empty+0xfc>        
40018d58:	b0 10 20 00 	clr  %i0                                       
             */                                                       
            return RC_OK;                                             
        }                                                             
        j++;                                                          
    }                                                                 
    *ret_val = true;                                                  
40018d5c:	82 10 20 01 	mov  1, %g1                                    
40018d60:	c2 2e 80 00 	stb  %g1, [ %i2 ]                              
    return RC_OK;                                                     
40018d64:	81 c7 e0 08 	ret                                            
40018d68:	81 e8 00 00 	restore                                        
        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)                  
40018d6c:	b8 07 20 20 	add  %i4, 0x20, %i4                            <== 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;                                                   
40018d70:	80 a7 00 18 	cmp  %i4, %i0                                  
40018d74:	0a bf ff e1 	bcs  40018cf8 <msdos_dir_is_empty+0x90>        <== ALWAYS TAKEN
40018d78:	ba 07 60 20 	add  %i5, 0x20, %i5                            
            /*                                                        
             * Short file name entries mean not empty.                
             */                                                       
            return RC_OK;                                             
        }                                                             
        j++;                                                          
40018d7c:	10 bf ff c6 	b  40018c94 <msdos_dir_is_empty+0x2c>          <== NOT EXECUTED
40018d80:	a6 04 e0 01 	inc  %l3                                       <== NOT EXECUTED
40018d84:	ea 04 20 a0 	ld  [ %l0 + 0xa0 ], %l5                        <== NOT EXECUTED
40018d88:	10 bf ff c3 	b  40018c94 <msdos_dir_is_empty+0x2c>          <== NOT EXECUTED
40018d8c:	a6 04 e0 01 	inc  %l3                                       <== NOT EXECUTED
    }                                                                 
    *ret_val = true;                                                  
    return RC_OK;                                                     
40018d90:	10 bf ff f3 	b  40018d5c <msdos_dir_is_empty+0xf4>          <== NOT EXECUTED
40018d94:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
                                  fs_info->cl_buf)) != FAT_EOF)       
    {                                                                 
        if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)                  
            return -1;                                                
                                                                      
        assert(ret == fs_info->fat.vol.bps);                          
40018d98:	11 10 00 b4 	sethi  %hi(0x4002d000), %o0                    <== NOT EXECUTED
40018d9c:	15 10 00 b4 	sethi  %hi(0x4002d000), %o2                    <== NOT EXECUTED
40018da0:	17 10 00 b4 	sethi  %hi(0x4002d000), %o3                    <== NOT EXECUTED
40018da4:	90 12 21 00 	or  %o0, 0x100, %o0                            <== NOT EXECUTED
40018da8:	92 10 23 65 	mov  0x365, %o1                                <== NOT EXECUTED
40018dac:	94 12 a1 b8 	or  %o2, 0x1b8, %o2                            <== NOT EXECUTED
40018db0:	7f ff af 1b 	call  40004a1c <__assert_func>                 <== NOT EXECUTED
40018db4:	96 12 e1 50 	or  %o3, 0x150, %o3                            <== NOT EXECUTED
                                                                      

4001b7fc <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) {
4001b7fc:	9d e3 be 60 	save  %sp, -416, %sp                           <== NOT EXECUTED
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
4001b800:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        <== 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);                      
4001b804:	d0 1e 20 08 	ldd  [ %i0 + 8 ], %o0                          <== NOT EXECUTED
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;     
    fat_file_fd_t     *fat_fd = iop->pathinfo.node_access;            
4001b808:	ea 06 20 1c 	ld  [ %i0 + 0x1c ], %l5                        <== 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);                      
4001b80c:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
4001b810:	96 10 21 18 	mov  0x118, %o3                                <== 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)        
{                                                                     
4001b814:	a4 10 00 18 	mov  %i0, %l2                                  <== 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->pathinfo.node_access;            
    fat_file_fd_t     *tmp_fat_fd = NULL;                             
4001b818:	c0 27 be d0 	clr  [ %fp + -304 ]                            <== 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;     
4001b81c:	f0 00 60 08 	ld  [ %g1 + 8 ], %i0                           <== 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);                      
4001b820:	7f ff 9a 70 	call  400021e0 <__divdi3>                      <== NOT EXECUTED
4001b824:	c0 27 be d4 	clr  [ %fp + -300 ]                            <== NOT EXECUTED
    count = (count / sizeof(struct dirent)) * sizeof(struct dirent);  
4001b828:	90 10 00 1a 	mov  %i2, %o0                                  <== 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);                      
4001b82c:	b6 10 00 09 	mov  %o1, %i3                                  <== NOT EXECUTED
    count = (count / sizeof(struct dirent)) * sizeof(struct dirent);  
4001b830:	7f ff 9b 91 	call  40002674 <.udiv>                         <== NOT EXECUTED
4001b834:	92 10 21 18 	mov  0x118, %o1                                <== NOT EXECUTED
     * too, so read such set of sectors is quick operation for low-level IO
     * layer.                                                         
     */                                                               
    bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&                           
             (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?     
             fat_fd->fat_file_size                              :     
4001b838:	c2 05 60 20 	ld  [ %l5 + 0x20 ], %g1                        <== 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);                      
    count = (count / sizeof(struct dirent)) * sizeof(struct dirent);  
4001b83c:	a3 2a 20 03 	sll  %o0, 3, %l1                               <== NOT EXECUTED
     * too, so read such set of sectors is quick operation for low-level IO
     * layer.                                                         
     */                                                               
    bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&                           
             (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?     
             fat_fd->fat_file_size                              :     
4001b840:	80 a0 60 01 	cmp  %g1, 1                                    <== 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);                      
    count = (count / sizeof(struct dirent)) * sizeof(struct dirent);  
4001b844:	91 2a 20 05 	sll  %o0, 5, %o0                               <== NOT EXECUTED
4001b848:	90 04 40 08 	add  %l1, %o0, %o0                             <== NOT EXECUTED
4001b84c:	a3 2a 20 03 	sll  %o0, 3, %l1                               <== NOT EXECUTED
     * too, so read such set of sectors is quick operation for low-level IO
     * layer.                                                         
     */                                                               
    bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&                           
             (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?     
             fat_fd->fat_file_size                              :     
4001b850:	02 80 00 f2 	be  4001bc18 <msdos_dir_read+0x41c>            <== NOT EXECUTED
4001b854:	a2 24 40 08 	sub  %l1, %o0, %l1                             <== NOT EXECUTED
4001b858:	c2 16 20 06 	lduh  [ %i0 + 6 ], %g1                         <== NOT EXECUTED
4001b85c:	c2 27 be c4 	st  %g1, [ %fp + -316 ]                        <== NOT EXECUTED
             fs_info->fat.vol.bpc;                                    
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
4001b860:	d0 06 20 9c 	ld  [ %i0 + 0x9c ], %o0                        <== NOT EXECUTED
4001b864:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4001b868:	7f ff b6 e4 	call  400093f8 <rtems_semaphore_obtain>        <== NOT EXECUTED
4001b86c:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
4001b870:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4001b874:	12 80 01 37 	bne  4001bd50 <msdos_dir_read+0x554>           <== NOT EXECUTED
4001b878:	80 a4 60 00 	cmp  %l1, 0                                    <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    while (count > 0)                                                 
4001b87c:	02 80 00 3a 	be  4001b964 <msdos_dir_read+0x168>            <== NOT EXECUTED
4001b880:	b8 10 20 00 	clr  %i4                                       <== NOT EXECUTED
4001b884:	a6 10 20 00 	clr  %l3                                       <== NOT EXECUTED
4001b888:	a8 10 20 00 	clr  %l4                                       <== NOT EXECUTED
4001b88c:	c0 2f be cf 	clrb  [ %fp + -305 ]                           <== NOT EXECUTED
4001b890:	b4 10 3f ff 	mov  -1, %i2                                   <== NOT EXECUTED
4001b894:	a0 10 20 00 	clr  %l0                                       <== 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(&fs_info->fat, fat_fd, (j * bts2rd),      
4001b898:	d8 06 20 a0 	ld  [ %i0 + 0xa0 ], %o4                        <== NOT EXECUTED
4001b89c:	d6 07 be c4 	ld  [ %fp + -316 ], %o3                        <== NOT EXECUTED
4001b8a0:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001b8a4:	92 10 00 15 	mov  %l5, %o1                                  <== NOT EXECUTED
4001b8a8:	7f ff db b4 	call  40012778 <fat_file_read>                 <== NOT EXECUTED
4001b8ac:	94 10 00 13 	mov  %l3, %o2                                  <== NOT EXECUTED
                            bts2rd, fs_info->cl_buf);                 
        if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)                  
4001b8b0:	80 a2 20 1f 	cmp  %o0, 0x1f                                 <== NOT EXECUTED
4001b8b4:	04 80 01 1e 	ble  4001bd2c <msdos_dir_read+0x530>           <== NOT EXECUTED
4001b8b8:	ac 10 00 08 	mov  %o0, %l6                                  <== 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;                
4001b8bc:	fa 06 20 a0 	ld  [ %i0 + 0xa0 ], %i5                        <== NOT EXECUTED
                                                                      
            /*                                                        
             * Is this directory from here on empty ?                 
             */                                                       
            if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==                     
4001b8c0:	c4 0f 40 00 	ldub  [ %i5 ], %g2                             <== NOT EXECUTED
4001b8c4:	86 88 a0 ff 	andcc  %g2, 0xff, %g3                          <== NOT EXECUTED
4001b8c8:	02 80 00 ce 	be  4001bc00 <msdos_dir_read+0x404>            <== NOT EXECUTED
4001b8cc:	ae 10 20 00 	clr  %l7                                       <== NOT EXECUTED
                rtems_semaphore_release(fs_info->vol_sema);           
                return cmpltd;                                        
            }                                                         
                                                                      
            /* Is the directory entry empty */                        
            if ((*MSDOS_DIR_ENTRY_TYPE(entry)) == MSDOS_THIS_DIR_ENTRY_EMPTY)
4001b8d0:	10 80 00 0f 	b  4001b90c <msdos_dir_read+0x110>             <== NOT EXECUTED
4001b8d4:	80 a0 e0 e5 	cmp  %g3, 0xe5                                 <== NOT EXECUTED
                continue;                                             
                                                                      
            /* Is the directory entry empty a volume label */         
            if (((*MSDOS_DIR_ATTR(entry)) & MSDOS_ATTR_VOLUME_ID) &&  
4001b8d8:	80 a0 e0 0f 	cmp  %g3, 0xf                                  <== NOT EXECUTED
4001b8dc:	02 80 00 28 	be  4001b97c <msdos_dir_read+0x180>            <== NOT EXECUTED
4001b8e0:	80 a6 bf ff 	cmp  %i2, -1                                   <== 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)  
4001b8e4:	ae 05 e0 20 	add  %l7, 0x20, %l7                            <== NOT EXECUTED
4001b8e8:	80 a5 c0 16 	cmp  %l7, %l6                                  <== NOT EXECUTED
4001b8ec:	1a 80 00 1a 	bcc  4001b954 <msdos_dir_read+0x158>           <== NOT EXECUTED
4001b8f0:	c2 07 be c4 	ld  [ %fp + -316 ], %g1                        <== NOT EXECUTED
        {                                                             
            char* entry = (char*) fs_info->cl_buf + i;                
4001b8f4:	fa 06 20 a0 	ld  [ %i0 + 0xa0 ], %i5                        <== NOT EXECUTED
                                                                      
            /*                                                        
             * Is this directory from here on empty ?                 
             */                                                       
            if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==                     
4001b8f8:	c4 0f 40 17 	ldub  [ %i5 + %l7 ], %g2                       <== NOT EXECUTED
4001b8fc:	86 88 a0 ff 	andcc  %g2, 0xff, %g3                          <== NOT EXECUTED
4001b900:	02 80 00 c0 	be  4001bc00 <msdos_dir_read+0x404>            <== NOT EXECUTED
4001b904:	ba 07 40 17 	add  %i5, %l7, %i5                             <== NOT EXECUTED
                rtems_semaphore_release(fs_info->vol_sema);           
                return cmpltd;                                        
            }                                                         
                                                                      
            /* Is the directory entry empty */                        
            if ((*MSDOS_DIR_ENTRY_TYPE(entry)) == MSDOS_THIS_DIR_ENTRY_EMPTY)
4001b908:	80 a0 e0 e5 	cmp  %g3, 0xe5                                 <== NOT EXECUTED
4001b90c:	22 bf ff f7 	be,a   4001b8e8 <msdos_dir_read+0xec>          <== NOT EXECUTED
4001b910:	ae 05 e0 20 	add  %l7, 0x20, %l7                            <== NOT EXECUTED
                continue;                                             
                                                                      
            /* Is the directory entry empty a volume label */         
            if (((*MSDOS_DIR_ATTR(entry)) & MSDOS_ATTR_VOLUME_ID) &&  
4001b914:	c6 0f 60 0b 	ldub  [ %i5 + 0xb ], %g3                       <== NOT EXECUTED
4001b918:	b8 08 e0 08 	and  %g3, 8, %i4                               <== NOT EXECUTED
4001b91c:	80 8f 20 ff 	btst  0xff, %i4                                <== NOT EXECUTED
4001b920:	12 bf ff ee 	bne  4001b8d8 <msdos_dir_read+0xdc>            <== NOT EXECUTED
4001b924:	86 08 e0 3f 	and  %g3, 0x3f, %g3                            <== 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) ==     
4001b928:	80 a0 e0 0f 	cmp  %g3, 0xf                                  <== NOT EXECUTED
4001b92c:	02 80 00 13 	be  4001b978 <msdos_dir_read+0x17c>            <== NOT EXECUTED
4001b930:	80 a6 e0 00 	cmp  %i3, 0                                    <== NOT EXECUTED
                fat_dir_pos_t dir_pos;                                
                                                                      
                /*                                                    
                 * Skip active entries until get the entry to start from.
                 */                                                   
                if (start)                                            
4001b934:	02 80 00 3c 	be  4001ba24 <msdos_dir_read+0x228>            <== NOT EXECUTED
4001b938:	90 10 00 18 	mov  %i0, %o0                                  <== 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)  
4001b93c:	ae 05 e0 20 	add  %l7, 0x20, %l7                            <== NOT EXECUTED
                 * Skip active entries until get the entry to start from.
                 */                                                   
                if (start)                                            
                {                                                     
                    lfn_start = FAT_FILE_SHORT_NAME;                  
                    start--;                                          
4001b940:	b6 06 ff ff 	add  %i3, -1, %i3                              <== 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)  
4001b944:	80 a5 c0 16 	cmp  %l7, %l6                                  <== NOT EXECUTED
4001b948:	0a bf ff eb 	bcs  4001b8f4 <msdos_dir_read+0xf8>            <== NOT EXECUTED
4001b94c:	b4 10 3f ff 	mov  -1, %i2                                   <== NOT EXECUTED
4001b950:	c2 07 be c4 	ld  [ %fp + -316 ], %g1                        <== 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)                                                 
4001b954:	80 a4 60 00 	cmp  %l1, 0                                    <== NOT EXECUTED
4001b958:	12 bf ff d0 	bne  4001b898 <msdos_dir_read+0x9c>            <== NOT EXECUTED
4001b95c:	a6 04 c0 01 	add  %l3, %g1, %l3                             <== NOT EXECUTED
4001b960:	b8 10 00 10 	mov  %l0, %i4                                  <== NOT EXECUTED
                break;                                                
        }                                                             
        j++;                                                          
    }                                                                 
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
4001b964:	d0 06 20 9c 	ld  [ %i0 + 0x9c ], %o0                        <== NOT EXECUTED
4001b968:	7f ff b6 f3 	call  40009534 <rtems_semaphore_release>       <== NOT EXECUTED
4001b96c:	b0 10 00 1c 	mov  %i4, %i0                                  <== NOT EXECUTED
    return cmpltd;                                                    
}                                                                     
4001b970:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001b974:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                int   q;                                              
                                                                      
                /*                                                    
                 * Is this is the first entry of a LFN ?              
                 */                                                   
                if (lfn_start == FAT_FILE_SHORT_NAME)                 
4001b978:	80 a6 bf ff 	cmp  %i2, -1                                   <== NOT EXECUTED
4001b97c:	02 80 00 93 	be  4001bbc8 <msdos_dir_read+0x3cc>            <== NOT EXECUTED
4001b980:	86 08 a0 40 	and  %g2, 0x40, %g3                            <== 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) &   
4001b984:	c4 0f 40 00 	ldub  [ %i5 ], %g2                             <== NOT EXECUTED
4001b988:	84 08 a0 3f 	and  %g2, 0x3f, %g2                            <== NOT EXECUTED
4001b98c:	80 a0 80 14 	cmp  %g2, %l4                                  <== NOT EXECUTED
4001b990:	22 80 00 04 	be,a   4001b9a0 <msdos_dir_read+0x1a4>         <== NOT EXECUTED
4001b994:	d8 0f 60 0d 	ldub  [ %i5 + 0xd ], %o4                       <== NOT EXECUTED
                                     MSDOS_LAST_LONG_ENTRY_MASK)) ||  
                    (lfn_checksum != *MSDOS_DIR_LFN_CHECKSUM(entry))) 
                {                                                     
                    lfn_start = FAT_FILE_SHORT_NAME;                  
4001b998:	10 bf ff d3 	b  4001b8e4 <msdos_dir_read+0xe8>              <== NOT EXECUTED
4001b99c:	b4 10 3f ff 	mov  -1, %i2                                   <== NOT EXECUTED
                 * 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) &   
                                     MSDOS_LAST_LONG_ENTRY_MASK)) ||  
4001b9a0:	c4 0f be cf 	ldub  [ %fp + -305 ], %g2                      <== NOT EXECUTED
4001b9a4:	86 0b 20 ff 	and  %o4, 0xff, %g3                            <== NOT EXECUTED
4001b9a8:	80 a0 c0 02 	cmp  %g3, %g2                                  <== NOT EXECUTED
4001b9ac:	32 bf ff ce 	bne,a   4001b8e4 <msdos_dir_read+0xe8>         <== NOT EXECUTED
4001b9b0:	b4 10 3f ff 	mov  -1, %i2                                   <== 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--;                                        
4001b9b4:	a8 05 3f ff 	add  %l4, -1, %l4                              <== NOT EXECUTED
                p = entry + 1;                                        
                o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;            
4001b9b8:	85 2d 20 02 	sll  %l4, 2, %g2                               <== NOT EXECUTED
4001b9bc:	95 2d 20 04 	sll  %l4, 4, %o2                               <== 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;                                        
4001b9c0:	ba 07 60 01 	inc  %i5                                       <== NOT EXECUTED
                o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;            
4001b9c4:	94 22 80 02 	sub  %o2, %g2, %o2                             <== NOT EXECUTED
4001b9c8:	b8 10 20 01 	mov  1, %i4                                    <== NOT EXECUTED
4001b9cc:	94 02 80 14 	add  %o2, %l4, %o2                             <== NOT EXECUTED
4001b9d0:	84 10 00 0a 	mov  %o2, %g2                                  <== 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)        
4001b9d4:	82 07 be e8 	add  %fp, -280, %g1                            <== NOT EXECUTED
4001b9d8:	86 20 80 0a 	sub  %g2, %o2, %g3                             <== NOT EXECUTED
                p = entry + 1;                                        
                o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;            
                                                                      
                for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)         
                {                                                     
                    if (o >= (sizeof(tmp_dirent.d_name) - 1))         
4001b9dc:	80 a0 a0 fe 	cmp  %g2, 0xfe                                 <== NOT EXECUTED
4001b9e0:	18 80 00 99 	bgu  4001bc44 <msdos_dir_read+0x448>           <== NOT EXECUTED
4001b9e4:	9e 00 40 02 	add  %g1, %g2, %o7                             <== NOT EXECUTED
                        break;                                        
                                                                      
                    tmp_dirent.d_name[o++] = *p;                      
4001b9e8:	d6 0f 40 00 	ldub  [ %i5 ], %o3                             <== NOT EXECUTED
4001b9ec:	d6 2b e0 14 	stb  %o3, [ %o7 + 0x14 ]                       <== NOT EXECUTED
                                                                      
                    if (*p == '\0')                                   
4001b9f0:	de 4f 40 00 	ldsb  [ %i5 ], %o7                             <== NOT EXECUTED
4001b9f4:	80 a3 e0 00 	cmp  %o7, 0                                    <== NOT EXECUTED
4001b9f8:	02 80 00 93 	be  4001bc44 <msdos_dir_read+0x448>            <== NOT EXECUTED
4001b9fc:	84 00 a0 01 	inc  %g2                                       <== NOT EXECUTED
                        break;                                        
                                                                      
                    switch (q)                                        
4001ba00:	80 a0 e0 04 	cmp  %g3, 4                                    <== NOT EXECUTED
4001ba04:	02 80 00 92 	be  4001bc4c <msdos_dir_read+0x450>            <== NOT EXECUTED
4001ba08:	80 a0 e0 0a 	cmp  %g3, 0xa                                  <== NOT EXECUTED
4001ba0c:	02 80 00 93 	be  4001bc58 <msdos_dir_read+0x45c>            <== NOT EXECUTED
4001ba10:	80 a7 20 0d 	cmp  %i4, 0xd                                  <== 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++)         
4001ba14:	02 80 00 8c 	be  4001bc44 <msdos_dir_read+0x448>            <== NOT EXECUTED
4001ba18:	ba 07 60 02 	add  %i5, 2, %i5                               <== NOT EXECUTED
4001ba1c:	10 bf ff ef 	b  4001b9d8 <msdos_dir_read+0x1dc>             <== NOT EXECUTED
4001ba20:	b8 07 20 01 	inc  %i4                                       <== 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(&fs_info->fat, fat_fd, F_CLU_NUM, 
4001ba24:	92 10 00 15 	mov  %l5, %o1                                  <== NOT EXECUTED
4001ba28:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
4001ba2c:	96 10 00 13 	mov  %l3, %o3                                  <== NOT EXECUTED
4001ba30:	7f ff dc 46 	call  40012b48 <fat_file_ioctl>                <== NOT EXECUTED
4001ba34:	98 07 be d4 	add  %fp, -300, %o4                            <== NOT EXECUTED
                                    j * bts2rd, &cur_cln);            
                if (rc != RC_OK)                                      
4001ba38:	b8 92 20 00 	orcc  %o0, 0, %i4                              <== NOT EXECUTED
4001ba3c:	12 bf ff ca 	bne  4001b964 <msdos_dir_read+0x168>           <== NOT EXECUTED
4001ba40:	c4 07 be d4 	ld  [ %fp + -300 ], %g2                        <== 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;                           
4001ba44:	82 10 3f ff 	mov  -1, %g1                                   <== NOT EXECUTED
                    rtems_semaphore_release(fs_info->vol_sema);       
                    return rc;                                        
                }                                                     
                                                                      
                fat_dir_pos_init(&dir_pos);                           
                dir_pos.sname.cln = cur_cln;                          
4001ba48:	c4 27 be d8 	st  %g2, [ %fp + -296 ]                        <== NOT EXECUTED
4001ba4c:	c2 27 be e0 	st  %g1, [ %fp + -288 ]                        <== NOT EXECUTED
  dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;                           
4001ba50:	c2 27 be e4 	st  %g1, [ %fp + -284 ]                        <== NOT EXECUTED
                dir_pos.sname.ofs = i;                                
4001ba54:	ee 27 be dc 	st  %l7, [ %fp + -292 ]                        <== NOT EXECUTED
                rc = fat_file_open(&fs_info->fat, &dir_pos, &tmp_fat_fd);
4001ba58:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001ba5c:	92 07 be d8 	add  %fp, -296, %o1                            <== NOT EXECUTED
4001ba60:	7f ff da 92 	call  400124a8 <fat_file_open>                 <== NOT EXECUTED
4001ba64:	94 07 be d0 	add  %fp, -304, %o2                            <== NOT EXECUTED
                if (rc != RC_OK)                                      
4001ba68:	b8 92 20 00 	orcc  %o0, 0, %i4                              <== NOT EXECUTED
4001ba6c:	12 bf ff be 	bne  4001b964 <msdos_dir_read+0x168>           <== NOT EXECUTED
4001ba70:	c4 07 be d0 	ld  [ %fp + -304 ], %g2                        <== 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);          
4001ba74:	82 10 21 18 	mov  0x118, %g1                                <== NOT EXECUTED
                tmp_dirent.d_ino = tmp_fat_fd->ino;                   
4001ba78:	c4 00 a0 0c 	ld  [ %g2 + 0xc ], %g2                         <== 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;                    
4001ba7c:	c0 27 be f0 	clr  [ %fp + -272 ]                            <== NOT EXECUTED
4001ba80:	e0 27 be f4 	st  %l0, [ %fp + -268 ]                        <== NOT EXECUTED
                tmp_dirent.d_reclen = sizeof(struct dirent);          
4001ba84:	c2 37 be f8 	sth  %g1, [ %fp + -264 ]                       <== 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)                 
4001ba88:	80 a6 bf ff 	cmp  %i2, -1                                   <== NOT EXECUTED
4001ba8c:	02 80 00 35 	be  4001bb60 <msdos_dir_read+0x364>            <== NOT EXECUTED
4001ba90:	c4 27 be e8 	st  %g2, [ %fp + -280 ]                        <== 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)        
4001ba94:	9e 07 60 0b 	add  %i5, 0xb, %o7                             <== NOT EXECUTED
4001ba98:	84 10 00 1d 	mov  %i5, %g2                                  <== NOT EXECUTED
4001ba9c:	b8 10 20 00 	clr  %i4                                       <== 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;  
4001baa0:	10 80 00 06 	b  4001bab8 <msdos_dir_read+0x2bc>             <== NOT EXECUTED
4001baa4:	86 10 20 00 	clr  %g3                                       <== NOT EXECUTED
4001baa8:	80 a0 00 0c 	cmp  %g0, %o4                                  <== NOT EXECUTED
4001baac:	86 40 3f ff 	addx  %g0, -1, %g3                             <== NOT EXECUTED
4001bab0:	86 08 e0 80 	and  %g3, 0x80, %g3                            <== NOT EXECUTED
4001bab4:	86 00 ff 80 	add  %g3, -128, %g3                            <== NOT EXECUTED
4001bab8:	d8 08 80 00 	ldub  [ %g2 ], %o4                             <== NOT EXECUTED
4001babc:	b8 0f 20 ff 	and  %i4, 0xff, %i4                            <== NOT EXECUTED
4001bac0:	b9 37 20 01 	srl  %i4, 1, %i4                               <== NOT EXECUTED
4001bac4:	b8 03 00 1c 	add  %o4, %i4, %i4                             <== NOT EXECUTED
                {                                                     
                    uint8_t  cs = 0;                                  
                    uint8_t* p = (uint8_t*) entry;                    
                    int      i;                                       
                                                                      
                    for (i = 0; i < 11; i++, p++)                     
4001bac8:	84 00 a0 01 	inc  %g2                                       <== NOT EXECUTED
                        cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;  
4001bacc:	86 07 00 03 	add  %i4, %g3, %g3                             <== NOT EXECUTED
                {                                                     
                    uint8_t  cs = 0;                                  
                    uint8_t* p = (uint8_t*) entry;                    
                    int      i;                                       
                                                                      
                    for (i = 0; i < 11; i++, p++)                     
4001bad0:	80 a0 80 0f 	cmp  %g2, %o7                                  <== NOT EXECUTED
                        cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;  
4001bad4:	98 08 e0 01 	and  %g3, 1, %o4                               <== NOT EXECUTED
                {                                                     
                    uint8_t  cs = 0;                                  
                    uint8_t* p = (uint8_t*) entry;                    
                    int      i;                                       
                                                                      
                    for (i = 0; i < 11; i++, p++)                     
4001bad8:	12 bf ff f4 	bne  4001baa8 <msdos_dir_read+0x2ac>           <== NOT EXECUTED
4001badc:	b8 10 00 03 	mov  %g3, %i4                                  <== NOT EXECUTED
                        cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;  
                                                                      
                    if (lfn_entries || (lfn_checksum != cs))          
4001bae0:	c2 0f be cf 	ldub  [ %fp + -305 ], %g1                      <== NOT EXECUTED
4001bae4:	b8 18 40 1c 	xor  %g1, %i4, %i4                             <== NOT EXECUTED
4001bae8:	80 8f 20 ff 	btst  0xff, %i4                                <== NOT EXECUTED
4001baec:	12 80 00 1e 	bne  4001bb64 <msdos_dir_read+0x368>           <== NOT EXECUTED
4001baf0:	92 10 20 08 	mov  8, %o1                                    <== NOT EXECUTED
4001baf4:	80 a5 20 00 	cmp  %l4, 0                                    <== NOT EXECUTED
4001baf8:	32 80 00 1c 	bne,a   4001bb68 <msdos_dir_read+0x36c>        <== NOT EXECUTED
4001bafc:	b4 07 40 09 	add  %i5, %o1, %i2                             <== 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);  
4001bb00:	40 00 08 e7 	call  4001de9c <strlen>                        <== NOT EXECUTED
4001bb04:	90 07 be fc 	add  %fp, -260, %o0                            <== NOT EXECUTED
4001bb08:	d0 37 be fa 	sth  %o0, [ %fp + -262 ]                       <== NOT EXECUTED
                }                                                     
                                                                      
                memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
4001bb0c:	90 06 40 10 	add  %i1, %l0, %o0                             <== NOT EXECUTED
4001bb10:	92 07 be e8 	add  %fp, -280, %o1                            <== NOT EXECUTED
4001bb14:	40 00 04 c4 	call  4001ce24 <memcpy>                        <== NOT EXECUTED
4001bb18:	94 10 21 18 	mov  0x118, %o2                                <== NOT EXECUTED
                                                                      
                iop->offset = iop->offset + sizeof(struct dirent);    
4001bb1c:	c4 1c a0 08 	ldd  [ %l2 + 8 ], %g2                          <== NOT EXECUTED
                cmpltd += (sizeof(struct dirent));                    
                count -= (sizeof(struct dirent));                     
                                                                      
                /* inode number extracted, close fat-file */          
                rc = fat_file_close(&fs_info->fat, tmp_fat_fd);       
4001bb20:	d2 07 be d0 	ld  [ %fp + -304 ], %o1                        <== NOT EXECUTED
                    tmp_dirent.d_namlen = strlen(tmp_dirent.d_name);  
                }                                                     
                                                                      
                memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
                                                                      
                iop->offset = iop->offset + sizeof(struct dirent);    
4001bb24:	ba 80 e1 18 	addcc  %g3, 0x118, %i5                         <== NOT EXECUTED
4001bb28:	b8 40 a0 00 	addx  %g2, 0, %i4                              <== NOT EXECUTED
                cmpltd += (sizeof(struct dirent));                    
                count -= (sizeof(struct dirent));                     
                                                                      
                /* inode number extracted, close fat-file */          
                rc = fat_file_close(&fs_info->fat, tmp_fat_fd);       
4001bb2c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
                    tmp_dirent.d_namlen = strlen(tmp_dirent.d_name);  
                }                                                     
                                                                      
                memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
                                                                      
                iop->offset = iop->offset + sizeof(struct dirent);    
4001bb30:	f8 3c a0 08 	std  %i4, [ %l2 + 8 ]                          <== NOT EXECUTED
                cmpltd += (sizeof(struct dirent));                    
                count -= (sizeof(struct dirent));                     
                                                                      
                /* inode number extracted, close fat-file */          
                rc = fat_file_close(&fs_info->fat, tmp_fat_fd);       
4001bb34:	7f ff db d7 	call  40012a90 <fat_file_close>                <== NOT EXECUTED
4001bb38:	a0 04 21 18 	add  %l0, 0x118, %l0                           <== NOT EXECUTED
                                                                      
                memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
                                                                      
                iop->offset = iop->offset + sizeof(struct dirent);    
                cmpltd += (sizeof(struct dirent));                    
                count -= (sizeof(struct dirent));                     
4001bb3c:	a2 04 7e e8 	add  %l1, -280, %l1                            <== NOT EXECUTED
                                                                      
                /* inode number extracted, close fat-file */          
                rc = fat_file_close(&fs_info->fat, tmp_fat_fd);       
                if (rc != RC_OK)                                      
4001bb40:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4001bb44:	12 bf ff 88 	bne  4001b964 <msdos_dir_read+0x168>           <== NOT EXECUTED
4001bb48:	b8 10 00 08 	mov  %o0, %i4                                  <== NOT EXECUTED
                    rtems_semaphore_release(fs_info->vol_sema);       
                    return rc;                                        
                }                                                     
            }                                                         
                                                                      
            if (count <= 0)                                           
4001bb4c:	80 a4 60 00 	cmp  %l1, 0                                    <== NOT EXECUTED
4001bb50:	32 bf ff 66 	bne,a   4001b8e8 <msdos_dir_read+0xec>         <== NOT EXECUTED
4001bb54:	ae 05 e0 20 	add  %l7, 0x20, %l7                            <== NOT EXECUTED
4001bb58:	10 bf ff 83 	b  4001b964 <msdos_dir_read+0x168>             <== NOT EXECUTED
4001bb5c:	b8 10 00 10 	mov  %l0, %i4                                  <== NOT EXECUTED
  const char *src_tmp;                                                
                                                                      
  /*                                                                  
   * find last non-blank character of base name                       
   */                                                                 
  for ((i       =       MSDOS_SHORT_BASE_LEN  ,                       
4001bb60:	92 10 20 08 	mov  8, %o1                                    <== 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)        
4001bb64:	b4 07 40 09 	add  %i5, %o1, %i2                             <== NOT EXECUTED
  /*                                                                  
   * find last non-blank character of base name                       
   */                                                                 
  for ((i       =       MSDOS_SHORT_BASE_LEN  ,                       
	src_tmp = src + MSDOS_SHORT_BASE_LEN-1);                             
       ((i > 0) &&                                                    
4001bb68:	c4 4e bf ff 	ldsb  [ %i2 + -1 ], %g2                        <== NOT EXECUTED
4001bb6c:	80 a0 a0 20 	cmp  %g2, 0x20                                 <== NOT EXECUTED
4001bb70:	12 80 00 3d 	bne  4001bc64 <msdos_dir_read+0x468>           <== NOT EXECUTED
4001bb74:	03 10 00 b6 	sethi  %hi(0x4002d800), %g1                    <== NOT EXECUTED
  const char *src_tmp;                                                
                                                                      
  /*                                                                  
   * find last non-blank character of base name                       
   */                                                                 
  for ((i       =       MSDOS_SHORT_BASE_LEN  ,                       
4001bb78:	92 82 7f ff 	addcc  %o1, -1, %o1                            <== NOT EXECUTED
4001bb7c:	32 bf ff fb 	bne,a   4001bb68 <msdos_dir_read+0x36c>        <== NOT EXECUTED
4001bb80:	b4 07 40 09 	add  %i5, %o1, %i2                             <== 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(
4001bb84:	86 07 be fc 	add  %fp, -260, %g3                            <== NOT EXECUTED
  /*                                                                  
   * find last non-blank character of extension                       
   */                                                                 
  for ((i       =                            MSDOS_SHORT_EXT_LEN  ,   
	src_tmp = src + MSDOS_SHORT_BASE_LEN+MSDOS_SHORT_EXT_LEN-1);         
       ((i > 0) &&                                                    
4001bb88:	c4 4f 60 0a 	ldsb  [ %i5 + 0xa ], %g2                       <== NOT EXECUTED
4001bb8c:	80 a0 a0 20 	cmp  %g2, 0x20                                 <== NOT EXECUTED
4001bb90:	12 80 00 46 	bne  4001bca8 <msdos_dir_read+0x4ac>           <== NOT EXECUTED
4001bb94:	98 10 20 03 	mov  3, %o4                                    <== NOT EXECUTED
4001bb98:	c4 4f 60 09 	ldsb  [ %i5 + 9 ], %g2                         <== NOT EXECUTED
4001bb9c:	80 a0 a0 20 	cmp  %g2, 0x20                                 <== NOT EXECUTED
4001bba0:	32 80 00 42 	bne,a   4001bca8 <msdos_dir_read+0x4ac>        <== NOT EXECUTED
4001bba4:	98 10 20 02 	mov  2, %o4                                    <== NOT EXECUTED
4001bba8:	c4 4f 60 08 	ldsb  [ %i5 + 8 ], %g2                         <== NOT EXECUTED
4001bbac:	80 a0 a0 20 	cmp  %g2, 0x20                                 <== NOT EXECUTED
4001bbb0:	12 80 00 3e 	bne  4001bca8 <msdos_dir_read+0x4ac>           <== NOT EXECUTED
4001bbb4:	98 10 20 01 	mov  1, %o4                                    <== NOT EXECUTED
    while (i-- > 0) {                                                 
      *dst++ = tolower((unsigned char)(*src_tmp++));                  
      len++;                                                          
    }                                                                 
  }                                                                   
  *dst = '\0'; /* terminate string */                                 
4001bbb8:	c0 28 c0 00 	clrb  [ %g3 ]                                  <== 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(
4001bbbc:	d2 37 be fa 	sth  %o1, [ %fp + -262 ]                       <== NOT EXECUTED
4001bbc0:	10 bf ff d3 	b  4001bb0c <msdos_dir_read+0x310>             <== NOT EXECUTED
4001bbc4:	b4 10 3f ff 	mov  -1, %i2                                   <== NOT EXECUTED
                if (lfn_start == FAT_FILE_SHORT_NAME)                 
                {                                                     
                    /*                                                
                     * The first entry must have the last long entry flag set.
                     */                                               
                    if ((*MSDOS_DIR_ENTRY_TYPE(entry) &               
4001bbc8:	80 88 e0 ff 	btst  0xff, %g3                                <== NOT EXECUTED
4001bbcc:	22 bf ff 47 	be,a   4001b8e8 <msdos_dir_read+0xec>          <== NOT EXECUTED
4001bbd0:	ae 05 e0 20 	add  %l7, 0x20, %l7                            <== 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);    
4001bbd4:	c2 0f 60 0d 	ldub  [ %i5 + 0xd ], %g1                       <== 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)        
4001bbd8:	b4 05 c0 13 	add  %l7, %l3, %i2                             <== 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) &     
4001bbdc:	a8 08 a0 3f 	and  %g2, 0x3f, %l4                            <== NOT EXECUTED
                        continue;                                     
                                                                      
                    /*                                                
                     * Remember the start location of the long file name.
                     */                                               
                    lfn_start =                                       
4001bbe0:	b5 36 a0 05 	srl  %i2, 5, %i2                               <== 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);    
4001bbe4:	c2 2f be cf 	stb  %g1, [ %fp + -305 ]                       <== NOT EXECUTED
                    memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
4001bbe8:	90 07 be fc 	add  %fp, -260, %o0                            <== NOT EXECUTED
4001bbec:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4001bbf0:	40 00 04 ca 	call  4001cf18 <memset>                        <== NOT EXECUTED
4001bbf4:	94 10 21 00 	mov  0x100, %o2                                <== 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) &   
4001bbf8:	10 bf ff 64 	b  4001b988 <msdos_dir_read+0x18c>             <== NOT EXECUTED
4001bbfc:	c4 0f 40 00 	ldub  [ %i5 ], %g2                             <== NOT EXECUTED
             * Is this directory from here on empty ?                 
             */                                                       
            if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==                     
                MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)                  
            {                                                         
                rtems_semaphore_release(fs_info->vol_sema);           
4001bc00:	d0 06 20 9c 	ld  [ %i0 + 0x9c ], %o0                        <== NOT EXECUTED
4001bc04:	7f ff b6 4c 	call  40009534 <rtems_semaphore_release>       <== NOT EXECUTED
4001bc08:	b8 10 00 10 	mov  %l0, %i4                                  <== NOT EXECUTED
        j++;                                                          
    }                                                                 
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
    return cmpltd;                                                    
}                                                                     
4001bc0c:	b0 10 00 1c 	mov  %i4, %i0                                  <== NOT EXECUTED
4001bc10:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001bc14:	81 e8 00 00 	restore                                        <== 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) &&                           
4001bc18:	c2 05 60 24 	ld  [ %l5 + 0x24 ], %g1                        <== NOT EXECUTED
4001bc1c:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4001bc20:	32 bf ff 0f 	bne,a   4001b85c <msdos_dir_read+0x60>         <== NOT EXECUTED
4001bc24:	c2 16 20 06 	lduh  [ %i0 + 6 ], %g1                         <== NOT EXECUTED
             (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?     
4001bc28:	c2 0e 20 0e 	ldub  [ %i0 + 0xe ], %g1                       <== 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) &&                           
4001bc2c:	80 88 60 03 	btst  3, %g1                                   <== NOT EXECUTED
4001bc30:	22 bf ff 0b 	be,a   4001b85c <msdos_dir_read+0x60>          <== NOT EXECUTED
4001bc34:	c2 16 20 06 	lduh  [ %i0 + 6 ], %g1                         <== NOT EXECUTED
             (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?     
             fat_fd->fat_file_size                              :     
4001bc38:	c2 05 60 18 	ld  [ %l5 + 0x18 ], %g1                        <== NOT EXECUTED
4001bc3c:	10 bf ff 09 	b  4001b860 <msdos_dir_read+0x64>              <== NOT EXECUTED
4001bc40:	c2 27 be c4 	st  %g1, [ %fp + -316 ]                        <== NOT EXECUTED
                    if (o >= (sizeof(tmp_dirent.d_name) - 1))         
                        break;                                        
                                                                      
                    tmp_dirent.d_name[o++] = *p;                      
                                                                      
                    if (*p == '\0')                                   
4001bc44:	10 bf ff c2 	b  4001bb4c <msdos_dir_read+0x350>             <== NOT EXECUTED
4001bc48:	d8 2f be cf 	stb  %o4, [ %fp + -305 ]                       <== NOT EXECUTED
                        break;                                        
                                                                      
                    switch (q)                                        
                    {                                                 
                        case 4:                                       
                            p += 5;                                   
4001bc4c:	ba 07 60 05 	add  %i5, 5, %i5                               <== NOT EXECUTED
4001bc50:	10 bf ff 61 	b  4001b9d4 <msdos_dir_read+0x1d8>             <== NOT EXECUTED
4001bc54:	b8 07 20 01 	inc  %i4                                       <== NOT EXECUTED
                            break;                                    
                        case 10:                                      
                            p += 4;                                   
4001bc58:	ba 07 60 04 	add  %i5, 4, %i5                               <== NOT EXECUTED
4001bc5c:	10 bf ff 5e 	b  4001b9d4 <msdos_dir_read+0x1d8>             <== NOT EXECUTED
4001bc60:	b8 07 20 01 	inc  %i4                                       <== 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)        
4001bc64:	84 10 00 1d 	mov  %i5, %g2                                  <== NOT EXECUTED
4001bc68:	d8 00 63 44 	ld  [ %g1 + 0x344 ], %o4                       <== 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(
4001bc6c:	10 80 00 06 	b  4001bc84 <msdos_dir_read+0x488>             <== NOT EXECUTED
4001bc70:	86 07 be fc 	add  %fp, -260, %g3                            <== NOT EXECUTED
   * copy base name to destination                                    
   */                                                                 
  src_tmp = src;                                                      
  len = i;                                                            
  while (i-- > 0) {                                                   
    *dst++ = tolower((unsigned char)(*src_tmp++));                    
4001bc74:	f8 28 c0 00 	stb  %i4, [ %g3 ]                              <== NOT EXECUTED
  /*                                                                  
   * copy base name to destination                                    
   */                                                                 
  src_tmp = src;                                                      
  len = i;                                                            
  while (i-- > 0) {                                                   
4001bc78:	80 a0 80 1a 	cmp  %g2, %i2                                  <== NOT EXECUTED
4001bc7c:	02 bf ff c3 	be  4001bb88 <msdos_dir_read+0x38c>            <== NOT EXECUTED
4001bc80:	86 00 e0 01 	inc  %g3                                       <== NOT EXECUTED
    *dst++ = tolower((unsigned char)(*src_tmp++));                    
4001bc84:	f8 08 80 00 	ldub  [ %g2 ], %i4                             <== NOT EXECUTED
4001bc88:	9e 03 00 1c 	add  %o4, %i4, %o7                             <== NOT EXECUTED
4001bc8c:	de 0b e0 01 	ldub  [ %o7 + 1 ], %o7                         <== NOT EXECUTED
4001bc90:	9e 0b e0 03 	and  %o7, 3, %o7                               <== NOT EXECUTED
4001bc94:	80 a3 e0 01 	cmp  %o7, 1                                    <== NOT EXECUTED
4001bc98:	12 bf ff f7 	bne  4001bc74 <msdos_dir_read+0x478>           <== NOT EXECUTED
4001bc9c:	84 00 a0 01 	inc  %g2                                       <== NOT EXECUTED
4001bca0:	10 bf ff f5 	b  4001bc74 <msdos_dir_read+0x478>             <== NOT EXECUTED
4001bca4:	b8 07 20 20 	add  %i4, 0x20, %i4                            <== NOT EXECUTED
    {};                                                               
  /*                                                                  
   * extension is not empty                                           
   */                                                                 
  if (i > 0) {                                                        
    *dst++ = '.'; /* append dot */                                    
4001bca8:	82 10 20 2e 	mov  0x2e, %g1                                 <== NOT EXECUTED
4001bcac:	96 00 e0 01 	add  %g3, 1, %o3                               <== NOT EXECUTED
4001bcb0:	c2 28 c0 00 	stb  %g1, [ %g3 ]                              <== NOT EXECUTED
    len += i + 1; /* extension + dot */                               
4001bcb4:	94 03 20 01 	add  %o4, 1, %o2                               <== 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)        
4001bcb8:	b8 03 20 08 	add  %o4, 8, %i4                               <== NOT EXECUTED
  /*                                                                  
   * extension is not empty                                           
   */                                                                 
  if (i > 0) {                                                        
    *dst++ = '.'; /* append dot */                                    
    len += i + 1; /* extension + dot */                               
4001bcbc:	94 02 40 0a 	add  %o1, %o2, %o2                             <== NOT EXECUTED
    src_tmp = src + MSDOS_SHORT_BASE_LEN;                             
4001bcc0:	84 07 60 08 	add  %i5, 8, %g2                               <== NOT EXECUTED
4001bcc4:	03 10 00 b6 	sethi  %hi(0x4002d800), %g1                    <== NOT EXECUTED
    while (i-- > 0) {                                                 
4001bcc8:	92 03 3f ff 	add  %o4, -1, %o1                              <== NOT EXECUTED
4001bccc:	de 00 63 44 	ld  [ %g1 + 0x344 ], %o7                       <== 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)        
4001bcd0:	ba 07 40 1c 	add  %i5, %i4, %i5                             <== NOT EXECUTED
    {};                                                               
  /*                                                                  
   * extension is not empty                                           
   */                                                                 
  if (i > 0) {                                                        
    *dst++ = '.'; /* append dot */                                    
4001bcd4:	10 80 00 06 	b  4001bcec <msdos_dir_read+0x4f0>             <== NOT EXECUTED
4001bcd8:	86 10 00 0b 	mov  %o3, %g3                                  <== NOT EXECUTED
    len += i + 1; /* extension + dot */                               
    src_tmp = src + MSDOS_SHORT_BASE_LEN;                             
    while (i-- > 0) {                                                 
      *dst++ = tolower((unsigned char)(*src_tmp++));                  
4001bcdc:	f8 28 c0 00 	stb  %i4, [ %g3 ]                              <== NOT EXECUTED
   */                                                                 
  if (i > 0) {                                                        
    *dst++ = '.'; /* append dot */                                    
    len += i + 1; /* extension + dot */                               
    src_tmp = src + MSDOS_SHORT_BASE_LEN;                             
    while (i-- > 0) {                                                 
4001bce0:	80 a0 80 1d 	cmp  %g2, %i5                                  <== NOT EXECUTED
4001bce4:	02 80 00 0e 	be  4001bd1c <msdos_dir_read+0x520>            <== NOT EXECUTED
4001bce8:	86 00 e0 01 	inc  %g3                                       <== NOT EXECUTED
      *dst++ = tolower((unsigned char)(*src_tmp++));                  
4001bcec:	f8 08 80 00 	ldub  [ %g2 ], %i4                             <== NOT EXECUTED
4001bcf0:	b4 03 c0 1c 	add  %o7, %i4, %i2                             <== NOT EXECUTED
4001bcf4:	f4 0e a0 01 	ldub  [ %i2 + 1 ], %i2                         <== NOT EXECUTED
4001bcf8:	b4 0e a0 03 	and  %i2, 3, %i2                               <== NOT EXECUTED
4001bcfc:	80 a6 a0 01 	cmp  %i2, 1                                    <== NOT EXECUTED
4001bd00:	12 bf ff f7 	bne  4001bcdc <msdos_dir_read+0x4e0>           <== NOT EXECUTED
4001bd04:	84 00 a0 01 	inc  %g2                                       <== NOT EXECUTED
4001bd08:	b8 07 20 20 	add  %i4, 0x20, %i4                            <== NOT EXECUTED
4001bd0c:	f8 28 c0 00 	stb  %i4, [ %g3 ]                              <== NOT EXECUTED
   */                                                                 
  if (i > 0) {                                                        
    *dst++ = '.'; /* append dot */                                    
    len += i + 1; /* extension + dot */                               
    src_tmp = src + MSDOS_SHORT_BASE_LEN;                             
    while (i-- > 0) {                                                 
4001bd10:	80 a0 80 1d 	cmp  %g2, %i5                                  <== NOT EXECUTED
4001bd14:	12 bf ff f6 	bne  4001bcec <msdos_dir_read+0x4f0>           <== NOT EXECUTED
4001bd18:	86 00 e0 01 	inc  %g3                                       <== 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)        
4001bd1c:	94 02 a0 01 	inc  %o2                                       <== NOT EXECUTED
4001bd20:	86 02 c0 0c 	add  %o3, %o4, %g3                             <== NOT EXECUTED
4001bd24:	10 bf ff a5 	b  4001bbb8 <msdos_dir_read+0x3bc>             <== NOT EXECUTED
4001bd28:	92 02 80 09 	add  %o2, %o1, %o1                             <== NOT EXECUTED
         */                                                           
        ret = fat_file_read(&fs_info->fat, fat_fd, (j * bts2rd),      
                            bts2rd, fs_info->cl_buf);                 
        if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)                  
        {                                                             
            rtems_semaphore_release(fs_info->vol_sema);               
4001bd2c:	d0 06 20 9c 	ld  [ %i0 + 0x9c ], %o0                        <== NOT EXECUTED
4001bd30:	7f ff b6 01 	call  40009534 <rtems_semaphore_release>       <== NOT EXECUTED
4001bd34:	b8 10 3f ff 	mov  -1, %i4                                   <== NOT EXECUTED
            rtems_set_errno_and_return_minus_one(EIO);                
4001bd38:	40 00 01 96 	call  4001c390 <__errno>                       <== NOT EXECUTED
4001bd3c:	b0 10 00 1c 	mov  %i4, %i0                                  <== NOT EXECUTED
4001bd40:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
4001bd44:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4001bd48:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001bd4c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
             fs_info->fat.vol.bpc;                                    
                                                                      
    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);                    
4001bd50:	40 00 01 90 	call  4001c390 <__errno>                       <== NOT EXECUTED
4001bd54:	b8 10 3f ff 	mov  -1, %i4                                   <== NOT EXECUTED
4001bd58:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
4001bd5c:	10 bf ff ac 	b  4001bc0c <msdos_dir_read+0x410>             <== NOT EXECUTED
4001bd60:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
                                                                      

4001bd64 <msdos_dir_stat>: int msdos_dir_stat( const rtems_filesystem_location_info_t *loc, struct stat *buf ) {
4001bd64:	9d e3 bf a0 	save  %sp, -96, %sp                            
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = loc->mt_entry->fs_info;              
4001bd68:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
    fat_file_fd_t     *fat_fd = loc->node_access;                     
4001bd6c:	f8 06 20 08 	ld  [ %i0 + 8 ], %i4                           
    const 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;              
4001bd70:	fa 00 60 08 	ld  [ %g1 + 8 ], %i5                           
    fat_file_fd_t     *fat_fd = loc->node_access;                     
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
4001bd74:	92 10 20 00 	clr  %o1                                       
4001bd78:	d0 07 60 9c 	ld  [ %i5 + 0x9c ], %o0                        
4001bd7c:	7f ff b5 9f 	call  400093f8 <rtems_semaphore_obtain>        
4001bd80:	94 10 20 00 	clr  %o2                                       
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
4001bd84:	80 a2 20 00 	cmp  %o0, 0                                    
4001bd88:	12 80 00 1a 	bne  4001bdf0 <msdos_dir_stat+0x8c>            <== NEVER TAKEN
4001bd8c:	01 00 00 00 	nop                                            
                                                                      
static inline dev_t rtems_disk_get_device_identifier(                 
  const rtems_disk_device *dd                                         
)                                                                     
{                                                                     
  return dd->dev;                                                     
4001bd90:	c2 07 60 64 	ld  [ %i5 + 0x64 ], %g1                        
    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;     
    buf->st_blksize = fs_info->fat.vol.bps;                           
4001bd94:	f6 17 40 00 	lduh  [ %i5 ], %i3                             
    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 = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
4001bd98:	c4 18 40 00 	ldd  [ %g1 ], %g2                              
    buf->st_ino = fat_fd->ino;                                        
4001bd9c:	f4 07 20 0c 	ld  [ %i4 + 0xc ], %i2                         
    buf->st_mode  = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;            
    buf->st_rdev = 0ll;                                               
    buf->st_size = fat_fd->fat_file_size;                             
4001bda0:	c2 07 20 18 	ld  [ %i4 + 0x18 ], %g1                        
    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;                                    
4001bda4:	c8 07 20 40 	ld  [ %i4 + 0x40 ], %g4                        
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
4001bda8:	d0 07 60 9c 	ld  [ %i5 + 0x9c ], %o0                        
    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 = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
4001bdac:	c4 3e 40 00 	std  %g2, [ %i1 ]                              
    buf->st_ino = fat_fd->ino;                                        
    buf->st_mode  = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;            
4001bdb0:	05 00 00 10 	sethi  %hi(0x4000), %g2                        
4001bdb4:	84 10 a1 ff 	or  %g2, 0x1ff, %g2	! 41ff <PROM_START+0x41ff> 
    buf->st_rdev = 0ll;                                               
    buf->st_size = fat_fd->fat_file_size;                             
    buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;     
4001bdb8:	bb 30 60 09 	srl  %g1, 9, %i5                               
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
    buf->st_ino = fat_fd->ino;                                        
4001bdbc:	f4 26 60 08 	st  %i2, [ %i1 + 8 ]                           
    buf->st_mode  = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;            
    buf->st_rdev = 0ll;                                               
4001bdc0:	c0 26 60 18 	clr  [ %i1 + 0x18 ]                            
4001bdc4:	c0 26 60 1c 	clr  [ %i1 + 0x1c ]                            
    buf->st_size = fat_fd->fat_file_size;                             
4001bdc8:	c0 26 60 20 	clr  [ %i1 + 0x20 ]                            
    if (sc != RTEMS_SUCCESSFUL)                                       
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
    buf->st_ino = fat_fd->ino;                                        
    buf->st_mode  = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;            
4001bdcc:	c4 26 60 0c 	st  %g2, [ %i1 + 0xc ]                         
    buf->st_rdev = 0ll;                                               
    buf->st_size = fat_fd->fat_file_size;                             
4001bdd0:	c2 26 60 24 	st  %g1, [ %i1 + 0x24 ]                        
    buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;     
4001bdd4:	fa 26 60 44 	st  %i5, [ %i1 + 0x44 ]                        
    buf->st_blksize = fs_info->fat.vol.bps;                           
4001bdd8:	f6 26 60 40 	st  %i3, [ %i1 + 0x40 ]                        
    buf->st_mtime = fat_fd->mtime;                                    
4001bddc:	c8 26 60 30 	st  %g4, [ %i1 + 0x30 ]                        
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
4001bde0:	7f ff b5 d5 	call  40009534 <rtems_semaphore_release>       
4001bde4:	b0 10 20 00 	clr  %i0                                       
    return RC_OK;                                                     
}                                                                     
4001bde8:	81 c7 e0 08 	ret                                            
4001bdec:	81 e8 00 00 	restore                                        
    fat_file_fd_t     *fat_fd = loc->node_access;                     
                                                                      
    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);                    
4001bdf0:	40 00 01 68 	call  4001c390 <__errno>                       <== NOT EXECUTED
4001bdf4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4001bdf8:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
4001bdfc:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4001be00:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001be04:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

400184bc <msdos_eval_token>: rtems_filesystem_eval_path_context_t *ctx, void *arg, const char *token, size_t tokenlen ) {
400184bc:	9d e3 bf a0 	save  %sp, -96, %sp                            
400184c0:	80 a6 e0 01 	cmp  %i3, 1                                    
400184c4:	02 80 00 17 	be  40018520 <msdos_eval_token+0x64>           
400184c8:	ba 10 00 18 	mov  %i0, %i5                                  
    rtems_filesystem_eval_path_clear_token(ctx);                      
    status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;             
  } else {                                                            
    rtems_filesystem_location_info_t *currentloc =                    
      rtems_filesystem_eval_path_get_currentloc(ctx);                 
    int rc = msdos_find_name(currentloc, token, tokenlen);            
400184cc:	90 07 60 18 	add  %i5, 0x18, %o0                            
400184d0:	92 10 00 1a 	mov  %i2, %o1                                  
400184d4:	40 00 06 2e 	call  40019d8c <msdos_find_name>               
400184d8:	94 10 00 1b 	mov  %i3, %o2                                  
                                                                      
    if (rc == RC_OK) {                                                
400184dc:	80 a2 20 00 	cmp  %o0, 0                                    
400184e0:	12 80 00 17 	bne  4001853c <msdos_eval_token+0x80>          
400184e4:	03 00 00 1f 	sethi  %hi(0x7c00), %g1                        
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;                       
                                                                      
    if (fat_fd->fat_file_type == FAT_DIRECTORY)                       
400184e8:	c4 07 60 20 	ld  [ %i5 + 0x20 ], %g2                        
 *     None                                                           
 */                                                                   
static void                                                           
msdos_set_handlers(rtems_filesystem_location_info_t *loc)             
{                                                                     
    msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;                
400184ec:	c2 07 60 2c 	ld  [ %i5 + 0x2c ], %g1                        
    fat_file_fd_t   *fat_fd = loc->node_access;                       
                                                                      
    if (fat_fd->fat_file_type == FAT_DIRECTORY)                       
400184f0:	c4 00 a0 10 	ld  [ %g2 + 0x10 ], %g2                        
                                                                      
static inline void rtems_filesystem_eval_path_clear_token(            
  rtems_filesystem_eval_path_context_t *ctx                           
)                                                                     
{                                                                     
  ctx->tokenlen = 0;                                                  
400184f4:	c0 27 60 0c 	clr  [ %i5 + 0xc ]                             
400184f8:	80 a0 a0 00 	cmp  %g2, 0                                    
400184fc:	12 80 00 1a 	bne  40018564 <msdos_eval_token+0xa8>          
40018500:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
        loc->handlers = fs_info->directory_handlers;                  
40018504:	c2 00 60 94 	ld  [ %g1 + 0x94 ], %g1                        
40018508:	c2 27 60 28 	st  %g1, [ %i5 + 0x28 ]                        
    int rc = msdos_find_name(currentloc, token, tokenlen);            
                                                                      
    if (rc == RC_OK) {                                                
      rtems_filesystem_eval_path_clear_token(ctx);                    
      msdos_set_handlers(currentloc);                                 
      if (rtems_filesystem_eval_path_has_path(ctx)) {                 
4001850c:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
  void *arg,                                                          
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  rtems_filesystem_eval_path_generic_status status =                  
40018510:	80 a0 00 01 	cmp  %g0, %g1                                  
40018514:	b0 60 3f ff 	subx  %g0, -1, %i0                             
40018518:	81 c7 e0 08 	ret                                            
4001851c:	81 e8 00 00 	restore                                        
static inline bool rtems_filesystem_is_current_directory(             
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  return tokenlen == 1 && token [0] == '.';                           
40018520:	c2 4e 80 00 	ldsb  [ %i2 ], %g1                             
40018524:	80 a0 60 2e 	cmp  %g1, 0x2e                                 
40018528:	12 bf ff ea 	bne  400184d0 <msdos_eval_token+0x14>          
4001852c:	90 07 60 18 	add  %i5, 0x18, %o0                            
                                                                      
static inline void rtems_filesystem_eval_path_clear_token(            
  rtems_filesystem_eval_path_context_t *ctx                           
)                                                                     
{                                                                     
  ctx->tokenlen = 0;                                                  
40018530:	c0 26 20 0c 	clr  [ %i0 + 0xc ]                             
      rtems_filesystem_eval_path_error(ctx, 0);                       
    }                                                                 
  }                                                                   
                                                                      
  return status;                                                      
}                                                                     
40018534:	81 c7 e0 08 	ret                                            
40018538:	91 e8 20 00 	restore  %g0, 0, %o0                           
      rtems_filesystem_eval_path_clear_token(ctx);                    
      msdos_set_handlers(currentloc);                                 
      if (rtems_filesystem_eval_path_has_path(ctx)) {                 
        status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;         
      }                                                               
    } else if (rc == MSDOS_NAME_NOT_FOUND_ERR) {                      
4001853c:	82 10 61 01 	or  %g1, 0x101, %g1                            
40018540:	80 a2 00 01 	cmp  %o0, %g1                                  
40018544:	02 bf ff f5 	be  40018518 <msdos_eval_token+0x5c>           <== ALWAYS TAKEN
40018548:	b0 10 20 02 	mov  2, %i0                                    
      status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;           
    } else {                                                          
      rtems_filesystem_eval_path_error(ctx, 0);                       
4001854c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40018550:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
40018554:	7f ff b6 19 	call  40005db8 <rtems_filesystem_eval_path_error><== NOT EXECUTED
40018558:	b0 10 20 01 	mov  1, %i0                                    <== NOT EXECUTED
4001855c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40018560:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    fat_file_fd_t   *fat_fd = loc->node_access;                       
                                                                      
    if (fat_fd->fat_file_type == FAT_DIRECTORY)                       
        loc->handlers = fs_info->directory_handlers;                  
    else                                                              
        loc->handlers = fs_info->file_handlers;                       
40018564:	c2 00 60 98 	ld  [ %g1 + 0x98 ], %g1                        
40018568:	10 bf ff e9 	b  4001850c <msdos_eval_token+0x50>            
4001856c:	c2 27 60 28 	st  %g1, [ %i5 + 0x28 ]                        
                                                                      

4001be64 <msdos_file_close>: * RC_OK, if file closed successfully, or -1 if error occured (errno set * appropriately) */ int msdos_file_close(rtems_libio_t *iop) {
4001be64:	9d e3 bf a0 	save  %sp, -96, %sp                            
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
4001be68:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
4001be6c:	92 10 20 00 	clr  %o1                                       
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;     
4001be70:	fa 00 60 08 	ld  [ %g1 + 8 ], %i5                           
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
4001be74:	94 10 20 00 	clr  %o2                                       
4001be78:	7f ff b5 60 	call  400093f8 <rtems_semaphore_obtain>        
4001be7c:	d0 07 60 9c 	ld  [ %i5 + 0x9c ], %o0                        
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
4001be80:	80 a2 20 00 	cmp  %o0, 0                                    
4001be84:	12 80 00 09 	bne  4001bea8 <msdos_file_close+0x44>          <== NEVER TAKEN
4001be88:	01 00 00 00 	nop                                            
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    rc = msdos_file_update(iop);                                      
4001be8c:	7f ff ff df 	call  4001be08 <msdos_file_update>             
4001be90:	90 10 00 18 	mov  %i0, %o0                                  
4001be94:	b0 10 00 08 	mov  %o0, %i0                                  
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
4001be98:	7f ff b5 a7 	call  40009534 <rtems_semaphore_release>       
4001be9c:	d0 07 60 9c 	ld  [ %i5 + 0x9c ], %o0                        
    return rc;                                                        
}                                                                     
4001bea0:	81 c7 e0 08 	ret                                            
4001bea4:	81 e8 00 00 	restore                                        
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
                                                                      
    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);                    
4001bea8:	40 00 01 3a 	call  4001c390 <__errno>                       <== NOT EXECUTED
4001beac:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4001beb0:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
4001beb4:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4001beb8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001bebc:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4001c0c8 <msdos_file_ftruncate>: * RETURNS: * RC_OK on success, or -1 if error occured (errno set appropriately). */ int msdos_file_ftruncate(rtems_libio_t *iop, off_t length) {
4001c0c8:	9d e3 bf 98 	save  %sp, -104, %sp                           
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
4001c0cc:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
    fat_file_fd_t     *fat_fd = iop->pathinfo.node_access;            
4001c0d0:	f8 06 20 1c 	ld  [ %i0 + 0x1c ], %i4                        
int                                                                   
msdos_file_ftruncate(rtems_libio_t *iop, off_t length)                
{                                                                     
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
4001c0d4:	fa 00 60 08 	ld  [ %g1 + 8 ], %i5                           
    fat_file_fd_t     *fat_fd = iop->pathinfo.node_access;            
    uint32_t old_length;                                              
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
4001c0d8:	92 10 20 00 	clr  %o1                                       
4001c0dc:	d0 07 60 9c 	ld  [ %i5 + 0x9c ], %o0                        
4001c0e0:	7f ff b4 c6 	call  400093f8 <rtems_semaphore_obtain>        
4001c0e4:	94 10 20 00 	clr  %o2                                       
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
4001c0e8:	80 a2 20 00 	cmp  %o0, 0                                    
4001c0ec:	12 80 00 31 	bne  4001c1b0 <msdos_file_ftruncate+0xe8>      <== NEVER TAKEN
4001c0f0:	80 a2 00 19 	cmp  %o0, %i1                                  
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    old_length = fat_fd->fat_file_size;                               
    if (length < old_length) {                                        
4001c0f4:	14 80 00 1f 	bg  4001c170 <msdos_file_ftruncate+0xa8>       <== NEVER TAKEN
4001c0f8:	f6 07 20 18 	ld  [ %i4 + 0x18 ], %i3                        
4001c0fc:	80 a2 00 19 	cmp  %o0, %i1                                  
4001c100:	12 80 00 06 	bne  4001c118 <msdos_file_ftruncate+0x50>      <== NEVER TAKEN
4001c104:	90 10 00 1d 	mov  %i5, %o0                                  
4001c108:	80 a6 c0 1a 	cmp  %i3, %i2                                  
4001c10c:	18 80 00 1b 	bgu  4001c178 <msdos_file_ftruncate+0xb0>      
4001c110:	92 10 00 1c 	mov  %i4, %o1                                  
        rc = fat_file_truncate(&fs_info->fat, fat_fd, length);        
    } else {                                                          
        uint32_t new_length;                                          
                                                                      
        rc = fat_file_extend(&fs_info->fat,                           
4001c114:	90 10 00 1d 	mov  %i5, %o0                                  
4001c118:	92 10 00 1c 	mov  %i4, %o1                                  
4001c11c:	94 10 20 01 	mov  1, %o2                                    
4001c120:	96 10 00 1a 	mov  %i2, %o3                                  
4001c124:	7f ff da be 	call  40012c1c <fat_file_extend>               
4001c128:	98 07 bf fc 	add  %fp, -4, %o4                              
                             fat_fd,                                  
                             true,                                    
                             length,                                  
                             &new_length);                            
        if (rc == RC_OK && length != new_length) {                    
4001c12c:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001c130:	12 80 00 17 	bne  4001c18c <msdos_file_ftruncate+0xc4>      <== NEVER TAKEN
4001c134:	80 a6 00 19 	cmp  %i0, %i1                                  
4001c138:	02 80 00 19 	be  4001c19c <msdos_file_ftruncate+0xd4>       <== ALWAYS TAKEN
4001c13c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
            fat_file_truncate(&fs_info->fat, fat_fd, old_length);     
4001c140:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
4001c144:	94 10 00 1b 	mov  %i3, %o2                                  <== NOT EXECUTED
4001c148:	7f ff da 11 	call  4001298c <fat_file_truncate>             <== NOT EXECUTED
4001c14c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
            errno = ENOSPC;                                           
4001c150:	40 00 00 90 	call  4001c390 <__errno>                       <== NOT EXECUTED
4001c154:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4001c158:	82 10 20 1c 	mov  0x1c, %g1                                 <== NOT EXECUTED
4001c15c:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
                                                                      
    if (rc == RC_OK) {                                                
        fat_fd->fat_file_size = length;                               
    }                                                                 
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
4001c160:	7f ff b4 f5 	call  40009534 <rtems_semaphore_release>       <== NOT EXECUTED
4001c164:	d0 07 60 9c 	ld  [ %i5 + 0x9c ], %o0                        <== NOT EXECUTED
                                                                      
    return rc;                                                        
}                                                                     
4001c168:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001c16c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    if (sc != RTEMS_SUCCESSFUL)                                       
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    old_length = fat_fd->fat_file_size;                               
    if (length < old_length) {                                        
        rc = fat_file_truncate(&fs_info->fat, fat_fd, length);        
4001c170:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001c174:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
4001c178:	7f ff da 05 	call  4001298c <fat_file_truncate>             
4001c17c:	94 10 00 1a 	mov  %i2, %o2                                  
            errno = ENOSPC;                                           
            rc = -1;                                                  
        }                                                             
    }                                                                 
                                                                      
    if (rc == RC_OK) {                                                
4001c180:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001c184:	22 80 00 02 	be,a   4001c18c <msdos_file_ftruncate+0xc4>    <== ALWAYS TAKEN
4001c188:	f4 27 20 18 	st  %i2, [ %i4 + 0x18 ]                        
        fat_fd->fat_file_size = length;                               
    }                                                                 
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
4001c18c:	7f ff b4 ea 	call  40009534 <rtems_semaphore_release>       
4001c190:	d0 07 60 9c 	ld  [ %i5 + 0x9c ], %o0                        
                                                                      
    return rc;                                                        
}                                                                     
4001c194:	81 c7 e0 08 	ret                                            
4001c198:	81 e8 00 00 	restore                                        
        rc = fat_file_extend(&fs_info->fat,                           
                             fat_fd,                                  
                             true,                                    
                             length,                                  
                             &new_length);                            
        if (rc == RC_OK && length != new_length) {                    
4001c19c:	80 a0 40 1a 	cmp  %g1, %i2                                  
4001c1a0:	12 bf ff e9 	bne  4001c144 <msdos_file_ftruncate+0x7c>      <== NEVER TAKEN
4001c1a4:	92 10 00 1c 	mov  %i4, %o1                                  
            rc = -1;                                                  
        }                                                             
    }                                                                 
                                                                      
    if (rc == RC_OK) {                                                
        fat_fd->fat_file_size = length;                               
4001c1a8:	10 bf ff f9 	b  4001c18c <msdos_file_ftruncate+0xc4>        
4001c1ac:	f4 27 20 18 	st  %i2, [ %i4 + 0x18 ]                        
    uint32_t old_length;                                              
                                                                      
    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);                    
4001c1b0:	40 00 00 78 	call  4001c390 <__errno>                       <== NOT EXECUTED
4001c1b4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4001c1b8:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
4001c1bc:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4001c1c0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001c1c4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4001bec0 <msdos_file_read>: * 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) {
4001bec0:	9d e3 bf a0 	save  %sp, -96, %sp                            
    ssize_t            ret = 0;                                       
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
4001bec4:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
    fat_file_fd_t     *fat_fd = iop->pathinfo.node_access;            
4001bec8:	fa 06 20 1c 	ld  [ %i0 + 0x1c ], %i5                        
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;     
4001becc:	e0 00 60 08 	ld  [ %g1 + 8 ], %l0                           
    fat_file_fd_t     *fat_fd = iop->pathinfo.node_access;            
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
4001bed0:	92 10 20 00 	clr  %o1                                       
4001bed4:	d0 04 20 9c 	ld  [ %l0 + 0x9c ], %o0                        
4001bed8:	7f ff b5 48 	call  400093f8 <rtems_semaphore_obtain>        
4001bedc:	94 10 20 00 	clr  %o2                                       
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
4001bee0:	80 a2 20 00 	cmp  %o0, 0                                    
4001bee4:	12 80 00 12 	bne  4001bf2c <msdos_file_read+0x6c>           <== NEVER TAKEN
4001bee8:	98 10 00 19 	mov  %i1, %o4                                  
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    ret = fat_file_read(&fs_info->fat, fat_fd, iop->offset, count,    
4001beec:	d4 06 20 0c 	ld  [ %i0 + 0xc ], %o2                         
4001bef0:	90 10 00 10 	mov  %l0, %o0                                  
4001bef4:	92 10 00 1d 	mov  %i5, %o1                                  
4001bef8:	7f ff da 20 	call  40012778 <fat_file_read>                 
4001befc:	96 10 00 1a 	mov  %i2, %o3                                  
                        buffer);                                      
    if (ret > 0)                                                      
4001bf00:	b2 92 20 00 	orcc  %o0, 0, %i1                              
4001bf04:	04 80 00 06 	ble  4001bf1c <msdos_file_read+0x5c>           
4001bf08:	85 3e 60 1f 	sra  %i1, 0x1f, %g2                            
        iop->offset += ret;                                           
4001bf0c:	f8 1e 20 08 	ldd  [ %i0 + 8 ], %i4                          
4001bf10:	b6 87 40 19 	addcc  %i5, %i1, %i3                           
4001bf14:	b4 47 00 02 	addx  %i4, %g2, %i2                            
4001bf18:	f4 3e 20 08 	std  %i2, [ %i0 + 8 ]                          
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
4001bf1c:	7f ff b5 86 	call  40009534 <rtems_semaphore_release>       
4001bf20:	d0 04 20 9c 	ld  [ %l0 + 0x9c ], %o0                        
    return ret;                                                       
}                                                                     
4001bf24:	81 c7 e0 08 	ret                                            
4001bf28:	91 e8 00 19 	restore  %g0, %i1, %o0                         
    fat_file_fd_t     *fat_fd = iop->pathinfo.node_access;            
                                                                      
    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);                    
4001bf2c:	40 00 01 19 	call  4001c390 <__errno>                       <== NOT EXECUTED
4001bf30:	b2 10 3f ff 	mov  -1, %i1                                   <== NOT EXECUTED
4001bf34:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
4001bf38:	10 bf ff fb 	b  4001bf24 <msdos_file_read+0x64>             <== NOT EXECUTED
4001bf3c:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
                                                                      

4001c018 <msdos_file_stat>: int msdos_file_stat( const rtems_filesystem_location_info_t *loc, struct stat *buf ) {
4001c018:	9d e3 bf a0 	save  %sp, -96, %sp                            
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = loc->mt_entry->fs_info;              
4001c01c:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
    fat_file_fd_t     *fat_fd = loc->node_access;                     
4001c020:	f8 06 20 08 	ld  [ %i0 + 8 ], %i4                           
    const 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;              
4001c024:	fa 00 60 08 	ld  [ %g1 + 8 ], %i5                           
    fat_file_fd_t     *fat_fd = loc->node_access;                     
    uint32_t           cl_mask = fs_info->fat.vol.bpc - 1;            
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
4001c028:	92 10 20 00 	clr  %o1                                       
)                                                                     
{                                                                     
    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;                     
    uint32_t           cl_mask = fs_info->fat.vol.bpc - 1;            
4001c02c:	f6 17 60 06 	lduh  [ %i5 + 6 ], %i3                         
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
4001c030:	d0 07 60 9c 	ld  [ %i5 + 0x9c ], %o0                        
4001c034:	94 10 20 00 	clr  %o2                                       
4001c038:	7f ff b4 f0 	call  400093f8 <rtems_semaphore_obtain>        
4001c03c:	b6 06 ff ff 	add  %i3, -1, %i3                              
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
4001c040:	80 a2 20 00 	cmp  %o0, 0                                    
4001c044:	12 80 00 1b 	bne  4001c0b0 <msdos_file_stat+0x98>           <== NEVER TAKEN
4001c048:	01 00 00 00 	nop                                            
4001c04c:	c2 07 60 64 	ld  [ %i5 + 0x64 ], %g1                        
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
    buf->st_ino = fat_fd->ino;                                        
4001c050:	f0 07 20 0c 	ld  [ %i4 + 0xc ], %i0                         
    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 = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
4001c054:	c4 18 40 00 	ldd  [ %g1 ], %g2                              
    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 + cl_mask) & ~cl_mask)   
      >> FAT_SECTOR512_BITS;                                          
    buf->st_blksize = fs_info->fat.vol.bpc;                           
4001c058:	f4 17 60 06 	lduh  [ %i5 + 6 ], %i2                         
                                                                      
    buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
    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;                             
4001c05c:	c2 07 20 18 	ld  [ %i4 + 0x18 ], %g1                        
    buf->st_blocks = ((fat_fd->fat_file_size + cl_mask) & ~cl_mask)   
      >> FAT_SECTOR512_BITS;                                          
    buf->st_blksize = fs_info->fat.vol.bpc;                           
    buf->st_mtime = fat_fd->mtime;                                    
4001c060:	c8 07 20 40 	ld  [ %i4 + 0x40 ], %g4                        
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
4001c064:	d0 07 60 9c 	ld  [ %i5 + 0x9c ], %o0                        
    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 = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
4001c068:	c4 3e 40 00 	std  %g2, [ %i1 ]                              
    buf->st_ino = fat_fd->ino;                                        
    buf->st_mode  = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;            
4001c06c:	05 00 00 20 	sethi  %hi(0x8000), %g2                        
4001c070:	84 10 a1 ff 	or  %g2, 0x1ff, %g2	! 81ff <PROM_START+0x81ff> 
    buf->st_rdev = 0ll;                                               
    buf->st_size = fat_fd->fat_file_size;                             
    buf->st_blocks = ((fat_fd->fat_file_size + cl_mask) & ~cl_mask)   
4001c074:	ba 06 c0 01 	add  %i3, %g1, %i5                             
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
    buf->st_ino = fat_fd->ino;                                        
4001c078:	f0 26 60 08 	st  %i0, [ %i1 + 8 ]                           
    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 + cl_mask) & ~cl_mask)   
4001c07c:	b6 2f 40 1b 	andn  %i5, %i3, %i3                            
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
    buf->st_ino = fat_fd->ino;                                        
    buf->st_mode  = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;            
    buf->st_rdev = 0ll;                                               
4001c080:	c0 26 60 18 	clr  [ %i1 + 0x18 ]                            
    buf->st_size = fat_fd->fat_file_size;                             
    buf->st_blocks = ((fat_fd->fat_file_size + cl_mask) & ~cl_mask)   
      >> FAT_SECTOR512_BITS;                                          
4001c084:	b7 36 e0 09 	srl  %i3, 9, %i3                               
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
    buf->st_ino = fat_fd->ino;                                        
    buf->st_mode  = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;            
    buf->st_rdev = 0ll;                                               
4001c088:	c0 26 60 1c 	clr  [ %i1 + 0x1c ]                            
    buf->st_size = fat_fd->fat_file_size;                             
4001c08c:	c0 26 60 20 	clr  [ %i1 + 0x20 ]                            
    if (sc != RTEMS_SUCCESSFUL)                                       
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
    buf->st_ino = fat_fd->ino;                                        
    buf->st_mode  = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;            
4001c090:	c4 26 60 0c 	st  %g2, [ %i1 + 0xc ]                         
    buf->st_rdev = 0ll;                                               
    buf->st_size = fat_fd->fat_file_size;                             
4001c094:	c2 26 60 24 	st  %g1, [ %i1 + 0x24 ]                        
    buf->st_blocks = ((fat_fd->fat_file_size + cl_mask) & ~cl_mask)   
      >> FAT_SECTOR512_BITS;                                          
    buf->st_blksize = fs_info->fat.vol.bpc;                           
4001c098:	f4 3e 60 40 	std  %i2, [ %i1 + 0x40 ]                       
    buf->st_mtime = fat_fd->mtime;                                    
4001c09c:	c8 26 60 30 	st  %g4, [ %i1 + 0x30 ]                        
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
4001c0a0:	7f ff b5 25 	call  40009534 <rtems_semaphore_release>       
4001c0a4:	b0 10 20 00 	clr  %i0                                       
    return RC_OK;                                                     
}                                                                     
4001c0a8:	81 c7 e0 08 	ret                                            
4001c0ac:	81 e8 00 00 	restore                                        
    uint32_t           cl_mask = fs_info->fat.vol.bpc - 1;            
                                                                      
    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);                    
4001c0b0:	40 00 00 b8 	call  4001c390 <__errno>                       <== NOT EXECUTED
4001c0b4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4001c0b8:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
4001c0bc:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4001c0c0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001c0c4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4001c1c8 <msdos_file_sync>: * RETURNS: * RC_OK on success, or -1 if error occured (errno set appropriately) */ int msdos_file_sync(rtems_libio_t *iop) {
4001c1c8:	9d e3 bf a0 	save  %sp, -96, %sp                            
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
4001c1cc:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
4001c1d0:	92 10 20 00 	clr  %o1                                       
int                                                                   
msdos_file_sync(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;     
4001c1d4:	fa 00 60 08 	ld  [ %g1 + 8 ], %i5                           
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
4001c1d8:	94 10 20 00 	clr  %o2                                       
4001c1dc:	7f ff b4 87 	call  400093f8 <rtems_semaphore_obtain>        
4001c1e0:	d0 07 60 9c 	ld  [ %i5 + 0x9c ], %o0                        
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
4001c1e4:	80 a2 20 00 	cmp  %o0, 0                                    
4001c1e8:	12 80 00 0d 	bne  4001c21c <msdos_file_sync+0x54>           <== NEVER TAKEN
4001c1ec:	01 00 00 00 	nop                                            
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    rc = msdos_file_update(iop);                                      
4001c1f0:	7f ff ff 06 	call  4001be08 <msdos_file_update>             
4001c1f4:	90 10 00 18 	mov  %i0, %o0                                  
    if (rc != RC_OK)                                                  
4001c1f8:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001c1fc:	12 80 00 04 	bne  4001c20c <msdos_file_sync+0x44>           <== NEVER TAKEN
4001c200:	01 00 00 00 	nop                                            
    {                                                                 
        rtems_semaphore_release(fs_info->vol_sema);                   
        return rc;                                                    
    }                                                                 
                                                                      
    rc = fat_sync(&fs_info->fat);                                     
4001c204:	7f ff df c8 	call  40014124 <fat_sync>                      
4001c208:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
4001c20c:	7f ff b4 ca 	call  40009534 <rtems_semaphore_release>       
4001c210:	d0 07 60 9c 	ld  [ %i5 + 0x9c ], %o0                        
    return RC_OK;                                                     
}                                                                     
4001c214:	81 c7 e0 08 	ret                                            
4001c218:	81 e8 00 00 	restore                                        
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
                                                                      
    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);                    
4001c21c:	40 00 00 5d 	call  4001c390 <__errno>                       <== NOT EXECUTED
4001c220:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4001c224:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
4001c228:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4001c22c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001c230:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4001be08 <msdos_file_update>: #include "msdos.h" static int msdos_file_update(rtems_libio_t *iop) {
4001be08:	9d e3 bf a0 	save  %sp, -96, %sp                            
    int              rc = RC_OK;                                      
    fat_file_fd_t   *fat_fd = iop->pathinfo.node_access;              
4001be0c:	f2 06 20 1c 	ld  [ %i0 + 0x1c ], %i1                        
                                                                      
    /*                                                                
     * 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))                                 
4001be10:	c2 0e 60 30 	ldub  [ %i1 + 0x30 ], %g1                      
4001be14:	80 88 60 01 	btst  1, %g1                                   
4001be18:	02 80 00 04 	be  4001be28 <msdos_file_update+0x20>          <== ALWAYS TAKEN
4001be1c:	90 10 20 00 	clr  %o0                                       
            return rc;                                                
        }                                                             
    }                                                                 
                                                                      
    return rc;                                                        
}                                                                     
4001be20:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001be24:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== 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))                                 
    {                                                                 
        rc = msdos_set_first_cluster_num(iop->pathinfo.mt_entry, fat_fd);
4001be28:	d0 06 20 28 	ld  [ %i0 + 0x28 ], %o0                        
4001be2c:	7f ff f2 bf 	call  40018928 <msdos_set_first_cluster_num>   
4001be30:	92 10 00 19 	mov  %i1, %o1                                  
        if (rc != RC_OK)                                              
4001be34:	80 a2 20 00 	cmp  %o0, 0                                    
4001be38:	12 bf ff fa 	bne  4001be20 <msdos_file_update+0x18>         <== NEVER TAKEN
4001be3c:	01 00 00 00 	nop                                            
        {                                                             
            return rc;                                                
        }                                                             
                                                                      
        rc = msdos_set_file_size(iop->pathinfo.mt_entry, fat_fd);     
4001be40:	d0 06 20 28 	ld  [ %i0 + 0x28 ], %o0                        
4001be44:	7f ff f2 f4 	call  40018a14 <msdos_set_file_size>           
4001be48:	92 10 00 19 	mov  %i1, %o1                                  
        if (rc != RC_OK)                                              
4001be4c:	80 a2 20 00 	cmp  %o0, 0                                    
4001be50:	12 bf ff f4 	bne  4001be20 <msdos_file_update+0x18>         <== NEVER TAKEN
4001be54:	01 00 00 00 	nop                                            
        {                                                             
            return rc;                                                
        }                                                             
                                                                      
        rc = msdos_set_dir_wrt_time_and_date(iop->pathinfo.mt_entry, fat_fd);
4001be58:	f0 06 20 28 	ld  [ %i0 + 0x28 ], %i0                        
4001be5c:	7f ff f2 6e 	call  40018814 <msdos_set_dir_wrt_time_and_date>
4001be60:	81 e8 00 00 	restore                                        
                                                                      

4001bf40 <msdos_file_write>: * 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) {
4001bf40:	9d e3 bf a0 	save  %sp, -96, %sp                            
    ssize_t            ret = 0;                                       
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
4001bf44:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
    fat_file_fd_t     *fat_fd = iop->pathinfo.node_access;            
4001bf48:	e2 06 20 1c 	ld  [ %i0 + 0x1c ], %l1                        
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;     
4001bf4c:	e0 00 60 08 	ld  [ %g1 + 8 ], %l0                           
    fat_file_fd_t     *fat_fd = iop->pathinfo.node_access;            
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
4001bf50:	92 10 20 00 	clr  %o1                                       
4001bf54:	d0 04 20 9c 	ld  [ %l0 + 0x9c ], %o0                        
4001bf58:	7f ff b5 28 	call  400093f8 <rtems_semaphore_obtain>        
4001bf5c:	94 10 20 00 	clr  %o2                                       
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
4001bf60:	80 a2 20 00 	cmp  %o0, 0                                    
4001bf64:	12 80 00 24 	bne  4001bff4 <msdos_file_write+0xb4>          <== NEVER TAKEN
4001bf68:	01 00 00 00 	nop                                            
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    if ((iop->flags & LIBIO_FLAGS_APPEND) != 0)                       
4001bf6c:	c2 06 20 10 	ld  [ %i0 + 0x10 ], %g1                        
4001bf70:	80 88 62 00 	btst  0x200, %g1                               
4001bf74:	32 80 00 1b 	bne,a   4001bfe0 <msdos_file_write+0xa0>       
4001bf78:	d4 04 60 18 	ld  [ %l1 + 0x18 ], %o2                        
4001bf7c:	d4 06 20 0c 	ld  [ %i0 + 0xc ], %o2                         
        iop->offset = fat_fd->fat_file_size;                          
                                                                      
    ret = fat_file_write(&fs_info->fat, fat_fd, iop->offset, count,   
4001bf80:	98 10 00 19 	mov  %i1, %o4                                  
4001bf84:	90 10 00 10 	mov  %l0, %o0                                  
4001bf88:	92 10 00 11 	mov  %l1, %o1                                  
4001bf8c:	7f ff db b9 	call  40012e70 <fat_file_write>                
4001bf90:	96 10 00 1a 	mov  %i2, %o3                                  
                         buffer);                                     
    if (ret < 0)                                                      
4001bf94:	b2 92 20 00 	orcc  %o0, 0, %i1                              
4001bf98:	06 80 00 1c 	bl  4001c008 <msdos_file_write+0xc8>           <== NEVER TAKEN
4001bf9c:	b9 3e 60 1f 	sra  %i1, 0x1f, %i4                            
                                                                      
    /*                                                                
     * update file size in both fat-file descriptor and file control block if
     * file was extended                                              
     */                                                               
    iop->offset += ret;                                               
4001bfa0:	f4 1e 20 08 	ldd  [ %i0 + 8 ], %i2                          
4001bfa4:	86 86 40 1b 	addcc  %i1, %i3, %g3                           
4001bfa8:	84 47 00 1a 	addx  %i4, %i2, %g2                            
4001bfac:	c4 3e 20 08 	std  %g2, [ %i0 + 8 ]                          
    if (iop->offset > fat_fd->fat_file_size)                          
4001bfb0:	80 a0 a0 00 	cmp  %g2, 0                                    
4001bfb4:	14 80 00 0e 	bg  4001bfec <msdos_file_write+0xac>           <== NEVER TAKEN
4001bfb8:	c2 04 60 18 	ld  [ %l1 + 0x18 ], %g1                        
4001bfbc:	80 a0 a0 00 	cmp  %g2, 0                                    
4001bfc0:	12 80 00 04 	bne  4001bfd0 <msdos_file_write+0x90>          <== NEVER TAKEN
4001bfc4:	80 a0 c0 01 	cmp  %g3, %g1                                  
4001bfc8:	38 80 00 02 	bgu,a   4001bfd0 <msdos_file_write+0x90>       
4001bfcc:	c6 24 60 18 	st  %g3, [ %l1 + 0x18 ]                        
        fat_fd->fat_file_size = iop->offset;                          
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
4001bfd0:	7f ff b5 59 	call  40009534 <rtems_semaphore_release>       
4001bfd4:	d0 04 20 9c 	ld  [ %l0 + 0x9c ], %o0                        
    return ret;                                                       
}                                                                     
4001bfd8:	81 c7 e0 08 	ret                                            
4001bfdc:	91 e8 00 19 	restore  %g0, %i1, %o0                         
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    if ((iop->flags & LIBIO_FLAGS_APPEND) != 0)                       
        iop->offset = fat_fd->fat_file_size;                          
4001bfe0:	c0 26 20 08 	clr  [ %i0 + 8 ]                               
4001bfe4:	10 bf ff e7 	b  4001bf80 <msdos_file_write+0x40>            
4001bfe8:	d4 26 20 0c 	st  %o2, [ %i0 + 0xc ]                         
     * update file size in both fat-file descriptor and file control block if
     * file was extended                                              
     */                                                               
    iop->offset += ret;                                               
    if (iop->offset > fat_fd->fat_file_size)                          
        fat_fd->fat_file_size = iop->offset;                          
4001bfec:	10 bf ff f9 	b  4001bfd0 <msdos_file_write+0x90>            <== NOT EXECUTED
4001bff0:	c6 24 60 18 	st  %g3, [ %l1 + 0x18 ]                        <== NOT EXECUTED
    fat_file_fd_t     *fat_fd = iop->pathinfo.node_access;            
                                                                      
    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);                    
4001bff4:	40 00 00 e7 	call  4001c390 <__errno>                       <== NOT EXECUTED
4001bff8:	b2 10 3f ff 	mov  -1, %i1                                   <== NOT EXECUTED
4001bffc:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
4001c000:	10 bf ff f6 	b  4001bfd8 <msdos_file_write+0x98>            <== NOT EXECUTED
4001c004:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
                                                                      
    ret = fat_file_write(&fs_info->fat, fat_fd, iop->offset, count,   
                         buffer);                                     
    if (ret < 0)                                                      
    {                                                                 
        rtems_semaphore_release(fs_info->vol_sema);                   
4001c008:	d0 04 20 9c 	ld  [ %l0 + 0x9c ], %o0                        <== NOT EXECUTED
4001c00c:	7f ff b5 4a 	call  40009534 <rtems_semaphore_release>       <== NOT EXECUTED
4001c010:	b2 10 3f ff 	mov  -1, %i1                                   <== NOT EXECUTED
        return -1;                                                    
4001c014:	30 bf ff f1 	b,a   4001bfd8 <msdos_file_write+0x98>         <== NOT EXECUTED
                                                                      

4001b5f8 <msdos_filename_unix2dos>: /* * Fill the dos filename string with blanks. These are DOS's pad * characters. */ for (i = 0; i <= 10; i++)
4001b5f8:	82 10 20 00 	clr  %g1                                       
		dn[i] = ' ';                                                        
4001b5fc:	84 10 20 20 	mov  0x20, %g2                                 
4001b600:	c4 2a 80 01 	stb  %g2, [ %o2 + %g1 ]                        
                                                                      
	/*                                                                   
	 * Fill the dos filename string with blanks. These are DOS's pad     
	 * characters.                                                       
	 */                                                                  
	for (i = 0; i <= 10; i++)                                            
4001b604:	82 00 60 01 	inc  %g1                                       
4001b608:	80 a0 60 0b 	cmp  %g1, 0xb                                  
4001b60c:	32 bf ff fe 	bne,a   4001b604 <msdos_filename_unix2dos+0xc> 
4001b610:	c4 2a 80 01 	stb  %g2, [ %o2 + %g1 ]                        
                                                                      
	/*                                                                   
	 * The filenames "." and ".." are handled specially, since they      
	 * don't follow dos filename rules.                                  
	 */                                                                  
	if (un[0] == '.' && unlen == 1) {                                    
4001b614:	c2 4a 00 00 	ldsb  [ %o0 ], %g1                             
4001b618:	80 a0 60 2e 	cmp  %g1, 0x2e                                 
4001b61c:	02 80 00 5f 	be  4001b798 <msdos_filename_unix2dos+0x1a0>   <== NEVER TAKEN
4001b620:	c4 0a 00 00 	ldub  [ %o0 ], %g2                             
	}                                                                    
                                                                      
  /*                                                                  
   * Remove any dots from the start of a file name.                   
   */                                                                 
	while (unlen && (*un == '.')) {                                      
4001b624:	80 a2 60 00 	cmp  %o1, 0                                    
4001b628:	02 80 00 5a 	be  4001b790 <msdos_filename_unix2dos+0x198>   <== NEVER TAKEN
4001b62c:	01 00 00 00 	nop                                            
	 * 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++) {         
4001b630:	82 88 a0 ff 	andcc  %g2, 0xff, %g1                          
4001b634:	02 80 00 57 	be  4001b790 <msdos_filename_unix2dos+0x198>   <== NEVER TAKEN
4001b638:	09 10 00 b4 	sethi  %hi(0x4002d000), %g4                    
    if (msdos_map[c] == 0)                                            
4001b63c:	88 11 22 20 	or  %g4, 0x220, %g4	! 4002d220 <msdos_map>     
4001b640:	c4 09 00 01 	ldub  [ %g4 + %g1 ], %g2                       
4001b644:	80 88 a0 ff 	btst  0xff, %g2                                
4001b648:	02 80 00 22 	be  4001b6d0 <msdos_filename_unix2dos+0xd8>    
4001b64c:	86 10 00 08 	mov  %o0, %g3                                  
4001b650:	10 80 00 0f 	b  4001b68c <msdos_filename_unix2dos+0x94>     
4001b654:	82 10 20 00 	clr  %g1                                       
	 * 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++) {         
4001b658:	02 80 00 18 	be  4001b6b8 <msdos_filename_unix2dos+0xc0>    
4001b65c:	01 00 00 00 	nop                                            
4001b660:	c4 08 c0 00 	ldub  [ %g3 ], %g2                             
4001b664:	80 a0 a0 00 	cmp  %g2, 0                                    
4001b668:	02 80 00 16 	be  4001b6c0 <msdos_filename_unix2dos+0xc8>    <== NEVER TAKEN
4001b66c:	80 a0 a0 2e 	cmp  %g2, 0x2e                                 
4001b670:	22 80 00 15 	be,a   4001b6c4 <msdos_filename_unix2dos+0xcc> 
4001b674:	c2 0a 20 01 	ldub  [ %o0 + 1 ], %g1                         
    if (msdos_map[c] == 0)                                            
4001b678:	c4 09 00 02 	ldub  [ %g4 + %g2 ], %g2                       
4001b67c:	80 88 a0 ff 	btst  0xff, %g2                                
4001b680:	22 80 00 11 	be,a   4001b6c4 <msdos_filename_unix2dos+0xcc> 
4001b684:	c2 0a 20 01 	ldub  [ %o0 + 1 ], %g1                         
      break;                                                          
		dn[i] = msdos_map[c];                                               
		un++;                                                               
4001b688:	90 10 00 03 	mov  %g3, %o0                                  
	 * upper case.                                                       
	 */                                                                  
	for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {         
    if (msdos_map[c] == 0)                                            
      break;                                                          
		dn[i] = msdos_map[c];                                               
4001b68c:	c4 2a 80 01 	stb  %g2, [ %o2 + %g1 ]                        
		un++;                                                               
4001b690:	86 02 20 01 	add  %o0, 1, %g3                               
	 * 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++) {         
4001b694:	82 00 60 01 	inc  %g1                                       
4001b698:	84 10 20 01 	mov  1, %g2                                    
4001b69c:	80 a0 60 07 	cmp  %g1, 7                                    
4001b6a0:	04 80 00 03 	ble  4001b6ac <msdos_filename_unix2dos+0xb4>   
4001b6a4:	92 02 7f ff 	add  %o1, -1, %o1                              
4001b6a8:	84 10 20 00 	clr  %g2                                       
4001b6ac:	80 88 a0 ff 	btst  0xff, %g2                                
4001b6b0:	12 bf ff ea 	bne  4001b658 <msdos_filename_unix2dos+0x60>   
4001b6b4:	80 a2 60 00 	cmp  %o1, 0                                    
                                                                      
	/*                                                                   
	 * Strip any further characters up to a '.' or the end of the        
	 * string.                                                           
	 */                                                                  
	while (unlen && (c = *un)) {                                         
4001b6b8:	02 80 00 36 	be  4001b790 <msdos_filename_unix2dos+0x198>   
4001b6bc:	01 00 00 00 	nop                                            
4001b6c0:	c2 0a 20 01 	ldub  [ %o0 + 1 ], %g1                         
4001b6c4:	80 a0 60 00 	cmp  %g1, 0                                    
4001b6c8:	02 80 00 32 	be  4001b790 <msdos_filename_unix2dos+0x198>   <== NEVER TAKEN
4001b6cc:	01 00 00 00 	nop                                            
		un++;                                                               
4001b6d0:	86 00 e0 01 	inc  %g3                                       
		unlen--;                                                            
		/* Make sure we've skipped over the dot before stopping. */         
		if (c == '.')                                                       
4001b6d4:	80 a0 60 2e 	cmp  %g1, 0x2e                                 
4001b6d8:	02 80 00 0c 	be  4001b708 <msdos_filename_unix2dos+0x110>   
4001b6dc:	92 02 7f ff 	add  %o1, -1, %o1                              
                                                                      
	/*                                                                   
	 * Strip any further characters up to a '.' or the end of the        
	 * string.                                                           
	 */                                                                  
	while (unlen && (c = *un)) {                                         
4001b6e0:	80 a2 60 00 	cmp  %o1, 0                                    
4001b6e4:	02 80 00 2b 	be  4001b790 <msdos_filename_unix2dos+0x198>   
4001b6e8:	01 00 00 00 	nop                                            
4001b6ec:	c2 08 c0 00 	ldub  [ %g3 ], %g1                             
4001b6f0:	80 a0 60 00 	cmp  %g1, 0                                    
4001b6f4:	02 80 00 27 	be  4001b790 <msdos_filename_unix2dos+0x198>   <== NEVER TAKEN
4001b6f8:	92 02 7f ff 	add  %o1, -1, %o1                              
		un++;                                                               
		unlen--;                                                            
		/* Make sure we've skipped over the dot before stopping. */         
		if (c == '.')                                                       
4001b6fc:	80 a0 60 2e 	cmp  %g1, 0x2e                                 
4001b700:	12 bf ff f8 	bne  4001b6e0 <msdos_filename_unix2dos+0xe8>   <== ALWAYS TAKEN
4001b704:	86 00 e0 01 	inc  %g3                                       
	/*                                                                   
	 * 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++) {                    
4001b708:	80 a2 60 00 	cmp  %o1, 0                                    
4001b70c:	02 80 00 21 	be  4001b790 <msdos_filename_unix2dos+0x198>   <== NEVER TAKEN
4001b710:	01 00 00 00 	nop                                            
4001b714:	c2 08 c0 00 	ldub  [ %g3 ], %g1                             
4001b718:	80 a0 60 00 	cmp  %g1, 0                                    
4001b71c:	02 80 00 1d 	be  4001b790 <msdos_filename_unix2dos+0x198>   <== NEVER TAKEN
4001b720:	01 00 00 00 	nop                                            
    if (msdos_map[c] == 0)                                            
4001b724:	c4 09 00 01 	ldub  [ %g4 + %g1 ], %g2                       
4001b728:	80 88 a0 ff 	btst  0xff, %g2                                
4001b72c:	02 80 00 19 	be  4001b790 <msdos_filename_unix2dos+0x198>   
4001b730:	82 10 20 08 	mov  8, %g1                                    
      break;                                                          
    dn[i] = msdos_map[c];                                             
4001b734:	10 80 00 0d 	b  4001b768 <msdos_filename_unix2dos+0x170>    
4001b738:	c4 2a 80 01 	stb  %g2, [ %o2 + %g1 ]                        
	/*                                                                   
	 * 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++) {                    
4001b73c:	02 80 00 15 	be  4001b790 <msdos_filename_unix2dos+0x198>   <== NEVER TAKEN
4001b740:	01 00 00 00 	nop                                            
4001b744:	c4 0b 7f f8 	ldub  [ %o5 + -8 ], %g2                        
4001b748:	80 a0 a0 00 	cmp  %g2, 0                                    
4001b74c:	02 80 00 11 	be  4001b790 <msdos_filename_unix2dos+0x198>   <== NEVER TAKEN
4001b750:	01 00 00 00 	nop                                            
    if (msdos_map[c] == 0)                                            
4001b754:	c4 09 00 02 	ldub  [ %g4 + %g2 ], %g2                       
4001b758:	80 88 a0 ff 	btst  0xff, %g2                                
4001b75c:	02 80 00 0d 	be  4001b790 <msdos_filename_unix2dos+0x198>   <== NEVER TAKEN
4001b760:	01 00 00 00 	nop                                            
      break;                                                          
    dn[i] = msdos_map[c];                                             
4001b764:	c4 2a 80 01 	stb  %g2, [ %o2 + %g1 ]                        
		un++;                                                               
		unlen--;                                                            
4001b768:	92 02 7f ff 	add  %o1, -1, %o1                              
	/*                                                                   
	 * 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++) {                    
4001b76c:	82 00 60 01 	inc  %g1                                       
4001b770:	84 10 20 01 	mov  1, %g2                                    
4001b774:	80 a0 60 0a 	cmp  %g1, 0xa                                  
4001b778:	04 80 00 03 	ble  4001b784 <msdos_filename_unix2dos+0x18c>  
4001b77c:	9a 00 c0 01 	add  %g3, %g1, %o5                             
4001b780:	84 10 20 00 	clr  %g2                                       
4001b784:	80 88 a0 ff 	btst  0xff, %g2                                
4001b788:	12 bf ff ed 	bne  4001b73c <msdos_filename_unix2dos+0x144>  
4001b78c:	80 a2 60 00 	cmp  %o1, 0                                    
    dn[i] = msdos_map[c];                                             
		un++;                                                               
		unlen--;                                                            
	}                                                                    
	return 0;                                                            
}                                                                     
4001b790:	81 c3 e0 08 	retl                                           
4001b794:	90 10 20 00 	clr  %o0                                       
                                                                      
	/*                                                                   
	 * The filenames "." and ".." are handled specially, since they      
	 * don't follow dos filename rules.                                  
	 */                                                                  
	if (un[0] == '.' && unlen == 1) {                                    
4001b798:	80 a2 60 01 	cmp  %o1, 1                                    <== NOT EXECUTED
4001b79c:	22 bf ff fd 	be,a   4001b790 <msdos_filename_unix2dos+0x198><== NOT EXECUTED
4001b7a0:	c2 2a 80 00 	stb  %g1, [ %o2 ]                              <== NOT EXECUTED
		dn[0] = '.';                                                        
		return 0;                                                           
	}                                                                    
	if (un[0] == '.' && un[1] == '.' && unlen == 2) {                    
4001b7a4:	c2 4a 20 01 	ldsb  [ %o0 + 1 ], %g1                         <== NOT EXECUTED
4001b7a8:	80 a0 60 2e 	cmp  %g1, 0x2e                                 <== NOT EXECUTED
4001b7ac:	12 80 00 05 	bne  4001b7c0 <msdos_filename_unix2dos+0x1c8>  <== NOT EXECUTED
4001b7b0:	80 a2 60 00 	cmp  %o1, 0                                    <== NOT EXECUTED
4001b7b4:	80 a2 60 02 	cmp  %o1, 2                                    <== NOT EXECUTED
4001b7b8:	02 80 00 0e 	be  4001b7f0 <msdos_filename_unix2dos+0x1f8>   <== NOT EXECUTED
4001b7bc:	80 a2 60 00 	cmp  %o1, 0                                    <== NOT EXECUTED
	}                                                                    
                                                                      
  /*                                                                  
   * Remove any dots from the start of a file name.                   
   */                                                                 
	while (unlen && (*un == '.')) {                                      
4001b7c0:	32 80 00 08 	bne,a   4001b7e0 <msdos_filename_unix2dos+0x1e8><== NOT EXECUTED
4001b7c4:	92 82 7f ff 	addcc  %o1, -1, %o1                            <== NOT EXECUTED
4001b7c8:	30 bf ff f2 	b,a   4001b790 <msdos_filename_unix2dos+0x198> <== NOT EXECUTED
4001b7cc:	c2 4a 00 00 	ldsb  [ %o0 ], %g1                             <== NOT EXECUTED
4001b7d0:	80 a0 60 2e 	cmp  %g1, 0x2e                                 <== NOT EXECUTED
4001b7d4:	12 bf ff 97 	bne  4001b630 <msdos_filename_unix2dos+0x38>   <== NOT EXECUTED
4001b7d8:	c4 0a 00 00 	ldub  [ %o0 ], %g2                             <== NOT EXECUTED
4001b7dc:	92 82 7f ff 	addcc  %o1, -1, %o1                            <== NOT EXECUTED
4001b7e0:	12 bf ff fb 	bne  4001b7cc <msdos_filename_unix2dos+0x1d4>  <== NOT EXECUTED
4001b7e4:	90 02 20 01 	inc  %o0                                       <== NOT EXECUTED
    dn[i] = msdos_map[c];                                             
		un++;                                                               
		unlen--;                                                            
	}                                                                    
	return 0;                                                            
}                                                                     
4001b7e8:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
4001b7ec:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
	if (un[0] == '.' && unlen == 1) {                                    
		dn[0] = '.';                                                        
		return 0;                                                           
	}                                                                    
	if (un[0] == '.' && un[1] == '.' && unlen == 2) {                    
		dn[0] = '.';                                                        
4001b7f0:	c2 2a 80 00 	stb  %g1, [ %o2 ]                              <== NOT EXECUTED
		dn[1] = '.';                                                        
		return 0;                                                           
4001b7f4:	10 bf ff e7 	b  4001b790 <msdos_filename_unix2dos+0x198>    <== NOT EXECUTED
4001b7f8:	c2 2a a0 01 	stb  %g1, [ %o2 + 1 ]                          <== NOT EXECUTED
                                                                      

40019d8c <msdos_find_name>: msdos_find_name( rtems_filesystem_location_info_t *parent_loc, const char *name, int name_len ) {
40019d8c:	9d e3 bf 60 	save  %sp, -160, %sp                           
    int                rc = RC_OK;                                    
    msdos_fs_info_t   *fs_info = parent_loc->mt_entry->fs_info;       
40019d90:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
    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);         
40019d94:	ba 07 bf e0 	add  %fp, -32, %i5                             
    const char                       *name,                           
    int                               name_len                        
    )                                                                 
{                                                                     
    int                rc = RC_OK;                                    
    msdos_fs_info_t   *fs_info = parent_loc->mt_entry->fs_info;       
40019d98:	f6 00 60 08 	ld  [ %g1 + 8 ], %i3                           
    unsigned short     date = 0;                                      
    char               node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE]; 
                                                                      
    memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);         
                                                                      
    name_type = msdos_long_to_short (name,                            
40019d9c:	94 10 00 1d 	mov  %i5, %o2                                  
40019da0:	92 10 00 1a 	mov  %i2, %o1                                  
40019da4:	96 10 20 0b 	mov  0xb, %o3                                  
    int                               name_len                        
    )                                                                 
{                                                                     
    int                rc = RC_OK;                                    
    msdos_fs_info_t   *fs_info = parent_loc->mt_entry->fs_info;       
    fat_file_fd_t     *fat_fd = NULL;                                 
40019da8:	c0 27 bf cc 	clr  [ %fp + -52 ]                             
    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);         
40019dac:	c0 27 bf e0 	clr  [ %fp + -32 ]                             
40019db0:	c0 27 bf e4 	clr  [ %fp + -28 ]                             
40019db4:	c0 27 bf e8 	clr  [ %fp + -24 ]                             
40019db8:	c0 27 bf ec 	clr  [ %fp + -20 ]                             
40019dbc:	c0 27 bf f0 	clr  [ %fp + -16 ]                             
40019dc0:	c0 27 bf f4 	clr  [ %fp + -12 ]                             
40019dc4:	c0 27 bf f8 	clr  [ %fp + -8 ]                              
40019dc8:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
                                                                      
    name_type = msdos_long_to_short (name,                            
40019dcc:	7f ff fa 04 	call  400185dc <msdos_long_to_short>           
40019dd0:	90 10 00 19 	mov  %i1, %o0                                  
msdos_find_name(                                                      
    rtems_filesystem_location_info_t *parent_loc,                     
    const char                       *name,                           
    int                               name_len                        
    )                                                                 
{                                                                     
40019dd4:	b8 10 00 18 	mov  %i0, %i4                                  
    unsigned short     date = 0;                                      
    char               node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE]; 
                                                                      
    memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);         
                                                                      
    name_type = msdos_long_to_short (name,                            
40019dd8:	98 10 00 08 	mov  %o0, %o4                                  
                                                                      
    /*                                                                
     * 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,
40019ddc:	fa 23 a0 5c 	st  %i5, [ %sp + 0x5c ]                        
40019de0:	90 10 00 18 	mov  %i0, %o0                                  
40019de4:	92 10 20 00 	clr  %o1                                       
40019de8:	94 10 00 19 	mov  %i1, %o2                                  
40019dec:	96 10 00 1a 	mov  %i2, %o3                                  
40019df0:	7f ff ff a6 	call  40019c88 <msdos_get_name_node>           
40019df4:	9a 07 bf d0 	add  %fp, -48, %o5                             
                             &dir_pos, node_entry);                   
    if (rc != RC_OK)                                                  
40019df8:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40019dfc:	12 80 00 23 	bne  40019e88 <msdos_find_name+0xfc>           
40019e00:	c2 0f bf eb 	ldub  [ %fp + -21 ], %g1                       
        return rc;                                                    
                                                                      
    if (((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_VOLUME_ID) ||     
        ((*MSDOS_DIR_ATTR(node_entry) & MSDOS_ATTR_LFN_MASK) == MSDOS_ATTR_LFN))
        return MSDOS_NAME_NOT_FOUND_ERR;                              
40019e04:	31 00 00 1f 	sethi  %hi(0x7c00), %i0                        
    rc = msdos_get_name_node(parent_loc, false, name, name_len, name_type,
                             &dir_pos, node_entry);                   
    if (rc != RC_OK)                                                  
        return rc;                                                    
                                                                      
    if (((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_VOLUME_ID) ||     
40019e08:	84 08 60 08 	and  %g1, 8, %g2                               
40019e0c:	80 88 a0 ff 	btst  0xff, %g2                                
40019e10:	12 80 00 1e 	bne  40019e88 <msdos_find_name+0xfc>           <== NEVER TAKEN
40019e14:	b0 16 21 01 	or  %i0, 0x101, %i0                            
40019e18:	82 08 60 3f 	and  %g1, 0x3f, %g1                            
40019e1c:	80 a0 60 0f 	cmp  %g1, 0xf                                  
40019e20:	02 80 00 1a 	be  40019e88 <msdos_find_name+0xfc>            <== NEVER TAKEN
40019e24:	90 10 00 1b 	mov  %i3, %o0                                  
        ((*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(&fs_info->fat, &dir_pos, &fat_fd);             
40019e28:	92 07 bf d0 	add  %fp, -48, %o1                             
40019e2c:	7f ff e1 9f 	call  400124a8 <fat_file_open>                 
40019e30:	94 07 bf cc 	add  %fp, -52, %o2                             
    if (rc != RC_OK)                                                  
40019e34:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40019e38:	12 80 00 14 	bne  40019e88 <msdos_find_name+0xfc>           <== NEVER TAKEN
40019e3c:	fa 07 bf cc 	ld  [ %fp + -52 ], %i5                         
        return rc;                                                    
                                                                      
    fat_fd->dir_pos = dir_pos;                                        
40019e40:	c4 07 bf d0 	ld  [ %fp + -48 ], %g2                         
     * 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)                                       
40019e44:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
    /* open fat-file corresponded to the found node */                
    rc = fat_file_open(&fs_info->fat, &dir_pos, &fat_fd);             
    if (rc != RC_OK)                                                  
        return rc;                                                    
                                                                      
    fat_fd->dir_pos = dir_pos;                                        
40019e48:	c4 27 60 20 	st  %g2, [ %i5 + 0x20 ]                        
40019e4c:	c4 07 bf d4 	ld  [ %fp + -44 ], %g2                         
     * 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)                                       
40019e50:	80 a0 60 01 	cmp  %g1, 1                                    
    /* open fat-file corresponded to the found node */                
    rc = fat_file_open(&fs_info->fat, &dir_pos, &fat_fd);             
    if (rc != RC_OK)                                                  
        return rc;                                                    
                                                                      
    fat_fd->dir_pos = dir_pos;                                        
40019e54:	c4 27 60 24 	st  %g2, [ %i5 + 0x24 ]                        
40019e58:	c4 07 bf d8 	ld  [ %fp + -40 ], %g2                         
40019e5c:	c4 27 60 28 	st  %g2, [ %i5 + 0x28 ]                        
40019e60:	c4 07 bf dc 	ld  [ %fp + -36 ], %g2                         
     * 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)                                       
40019e64:	02 80 00 0b 	be  40019e90 <msdos_find_name+0x104>           
40019e68:	c4 27 60 2c 	st  %g2, [ %i5 + 0x2c ]                        
            fat_fd->map.last_cln = FAT_UNDEFINED_VALUE;               
        }                                                             
    }                                                                 
                                                                      
    /* close fat-file corresponded to the node we searched in */      
    rc = fat_file_close(&fs_info->fat, parent_loc->node_access);      
40019e6c:	d2 07 20 08 	ld  [ %i4 + 8 ], %o1                           
40019e70:	7f ff e3 08 	call  40012a90 <fat_file_close>                
40019e74:	90 10 00 1b 	mov  %i3, %o0                                  
    if (rc != RC_OK)                                                  
40019e78:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40019e7c:	12 80 00 45 	bne  40019f90 <msdos_find_name+0x204>          <== NEVER TAKEN
40019e80:	c2 07 bf cc 	ld  [ %fp + -52 ], %g1                         
        fat_file_close(&fs_info->fat, fat_fd);                        
        return rc;                                                    
    }                                                                 
                                                                      
    /* update node_info_ptr field */                                  
    parent_loc->node_access = fat_fd;                                 
40019e84:	c2 27 20 08 	st  %g1, [ %i4 + 8 ]                           
                                                                      
    return rc;                                                        
}                                                                     
40019e88:	81 c7 e0 08 	ret                                            
40019e8c:	81 e8 00 00 	restore                                        
        fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);          
                                                                      
        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));
40019e90:	c2 17 bf f6 	lduh  [ %fp + -10 ], %g1                       
     * 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)                                       
    {                                                                 
        fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);          
40019e94:	c8 17 bf f4 	lduh  [ %fp + -12 ], %g4                       
40019e98:	c6 17 bf fa 	lduh  [ %fp + -6 ], %g3                        
                                                                      
        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));
40019e9c:	c4 17 bf f8 	lduh  [ %fp + -8 ], %g2                        
40019ea0:	83 28 60 10 	sll  %g1, 0x10, %g1                            
     * 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)                                       
    {                                                                 
        fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);          
40019ea4:	89 29 20 10 	sll  %g4, 0x10, %g4                            
40019ea8:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
                                                                      
        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));
40019eac:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
     * 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)                                       
    {                                                                 
        fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);          
40019eb0:	b1 31 20 18 	srl  %g4, 0x18, %i0                            
40019eb4:	b3 30 e0 18 	srl  %g3, 0x18, %i1                            
                                                                      
        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));
40019eb8:	91 30 a0 18 	srl  %g2, 0x18, %o0                            
40019ebc:	93 30 60 18 	srl  %g1, 0x18, %o1                            
40019ec0:	b5 30 60 08 	srl  %g1, 8, %i2                               
     * 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)                                       
    {                                                                 
        fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);          
40019ec4:	89 31 20 08 	srl  %g4, 8, %g4                               
40019ec8:	87 30 e0 08 	srl  %g3, 8, %g3                               
                                                                      
        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));
40019ecc:	85 30 a0 08 	srl  %g2, 8, %g2                               
     * 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)                                       
    {                                                                 
        fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);          
40019ed0:	03 00 00 3f 	sethi  %hi(0xfc00), %g1                        
40019ed4:	82 10 63 ff 	or  %g1, 0x3ff, %g1	! ffff <PROM_START+0xffff> 
                                                                      
        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));
40019ed8:	84 08 80 01 	and  %g2, %g1, %g2                             
     * 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)                                       
    {                                                                 
        fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);          
40019edc:	88 09 00 01 	and  %g4, %g1, %g4                             
40019ee0:	86 08 c0 01 	and  %g3, %g1, %g3                             
40019ee4:	88 16 00 04 	or  %i0, %g4, %g4                              
                                                                      
        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));
40019ee8:	82 0e 80 01 	and  %i2, %g1, %g1                             
     * 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)                                       
    {                                                                 
        fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);          
40019eec:	89 29 20 10 	sll  %g4, 0x10, %g4                            
40019ef0:	86 16 40 03 	or  %i1, %g3, %g3                              
40019ef4:	86 11 00 03 	or  %g4, %g3, %g3                              
                                                                      
        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));
40019ef8:	92 12 40 01 	or  %o1, %g1, %o1                              
     * 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)                                       
    {                                                                 
        fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);          
40019efc:	c6 27 60 1c 	st  %g3, [ %i5 + 0x1c ]                        
                                                                      
        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));
40019f00:	40 00 05 70 	call  4001b4c0 <msdos_date_dos2unix>           
40019f04:	90 12 00 02 	or  %o0, %g2, %o0                              
                                                                      
        if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)     
40019f08:	c2 0f bf eb 	ldub  [ %fp + -21 ], %g1                       
40019f0c:	82 08 60 10 	and  %g1, 0x10, %g1                            
40019f10:	80 88 60 ff 	btst  0xff, %g1                                
40019f14:	12 80 00 27 	bne  40019fb0 <msdos_find_name+0x224>          
40019f18:	d0 27 60 40 	st  %o0, [ %i5 + 0x40 ]                        
                return rc;                                            
            }                                                         
        }                                                             
        else                                                          
        {                                                             
            fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
40019f1c:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
40019f20:	c2 07 bf cc 	ld  [ %fp + -52 ], %g1                         
40019f24:	bb 28 a0 18 	sll  %g2, 0x18, %i5                            
  uint32_t value                                                      
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
40019f28:	89 30 a0 18 	srl  %g2, 0x18, %g4                            
  byte3 = (value >> 16) & 0xff;                                       
  byte2 = (value >> 8)  & 0xff;                                       
40019f2c:	87 30 a0 08 	srl  %g2, 8, %g3                               
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
40019f30:	88 17 40 04 	or  %i5, %g4, %g4                              
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
  byte3 = (value >> 16) & 0xff;                                       
  byte2 = (value >> 8)  & 0xff;                                       
40019f34:	86 08 e0 ff 	and  %g3, 0xff, %g3                            
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
40019f38:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
40019f3c:	86 11 00 03 	or  %g4, %g3, %g3                              
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
  byte3 = (value >> 16) & 0xff;                                       
40019f40:	85 30 a0 10 	srl  %g2, 0x10, %g2                            
40019f44:	84 08 a0 ff 	and  %g2, 0xff, %g2                            
  byte2 = (value >> 8)  & 0xff;                                       
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
40019f48:	85 28 a0 08 	sll  %g2, 8, %g2                               
40019f4c:	84 10 c0 02 	or  %g3, %g2, %g2                              
            fat_fd->fat_file_type = FAT_FILE;                         
40019f50:	86 10 20 04 	mov  4, %g3                                    
                return rc;                                            
            }                                                         
        }                                                             
        else                                                          
        {                                                             
            fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
40019f54:	c4 20 60 18 	st  %g2, [ %g1 + 0x18 ]                        
            fat_fd->fat_file_type = FAT_FILE;                         
40019f58:	c6 20 60 10 	st  %g3, [ %g1 + 0x10 ]                        
            fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;                 
40019f5c:	86 10 3f ff 	mov  -1, %g3                                   
40019f60:	c6 20 60 14 	st  %g3, [ %g1 + 0x14 ]                        
        }                                                             
                                                                      
        /* these data is not actual for zero-length fat-file */       
        fat_fd->map.file_cln = 0;                                     
        fat_fd->map.disk_cln = fat_fd->cln;                           
40019f64:	c6 00 60 1c 	ld  [ %g1 + 0x1c ], %g3                        
            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;                                     
40019f68:	c0 20 60 34 	clr  [ %g1 + 0x34 ]                            
        fat_fd->map.disk_cln = fat_fd->cln;                           
                                                                      
        if ((fat_fd->fat_file_size != 0) &&                           
40019f6c:	80 a0 a0 00 	cmp  %g2, 0                                    
40019f70:	02 80 00 0d 	be  40019fa4 <msdos_find_name+0x218>           
40019f74:	c6 20 60 38 	st  %g3, [ %g1 + 0x38 ]                        
            (fat_fd->fat_file_size <= fs_info->fat.vol.bpc))          
40019f78:	c8 16 e0 06 	lduh  [ %i3 + 6 ], %g4                         
                                                                      
        /* these data is not actual for zero-length fat-file */       
        fat_fd->map.file_cln = 0;                                     
        fat_fd->map.disk_cln = fat_fd->cln;                           
                                                                      
        if ((fat_fd->fat_file_size != 0) &&                           
40019f7c:	80 a1 00 02 	cmp  %g4, %g2                                  
40019f80:	0a 80 00 0a 	bcs  40019fa8 <msdos_find_name+0x21c>          
40019f84:	84 10 3f ff 	mov  -1, %g2                                   
            (fat_fd->fat_file_size <= fs_info->fat.vol.bpc))          
        {                                                             
            fat_fd->map.last_cln = fat_fd->cln;                       
40019f88:	10 bf ff b9 	b  40019e6c <msdos_find_name+0xe0>             
40019f8c:	c6 20 60 3c 	st  %g3, [ %g1 + 0x3c ]                        
                                                                      
    /* close fat-file corresponded to the node we searched in */      
    rc = fat_file_close(&fs_info->fat, parent_loc->node_access);      
    if (rc != RC_OK)                                                  
    {                                                                 
        fat_file_close(&fs_info->fat, fat_fd);                        
40019f90:	d2 07 bf cc 	ld  [ %fp + -52 ], %o1                         <== NOT EXECUTED
40019f94:	7f ff e2 bf 	call  40012a90 <fat_file_close>                <== NOT EXECUTED
40019f98:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
40019f9c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40019fa0:	81 e8 00 00 	restore                                        <== NOT EXECUTED
        {                                                             
            fat_fd->map.last_cln = fat_fd->cln;                       
        }                                                             
        else                                                          
        {                                                             
            fat_fd->map.last_cln = FAT_UNDEFINED_VALUE;               
40019fa4:	84 10 3f ff 	mov  -1, %g2                                   
40019fa8:	10 bf ff b1 	b  40019e6c <msdos_find_name+0xe0>             
40019fac:	c4 20 60 3c 	st  %g2, [ %g1 + 0x3c ]                        
                                                                      
        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;                    
40019fb0:	d2 07 bf cc 	ld  [ %fp + -52 ], %o1                         
            fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                
40019fb4:	03 00 08 00 	sethi  %hi(0x200000), %g1                      
                                                                      
        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;                    
40019fb8:	c0 22 60 10 	clr  [ %o1 + 0x10 ]                            
            fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                
40019fbc:	c2 22 60 14 	st  %g1, [ %o1 + 0x14 ]                        
                                                                      
            rc = fat_file_size(&fs_info->fat, fat_fd);                
40019fc0:	7f ff e4 70 	call  40013180 <fat_file_size>                 
40019fc4:	90 10 00 1b 	mov  %i3, %o0                                  
            if (rc != RC_OK)                                          
40019fc8:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40019fcc:	12 bf ff f1 	bne  40019f90 <msdos_find_name+0x204>          <== NEVER TAKEN
40019fd0:	c2 07 bf cc 	ld  [ %fp + -52 ], %g1                         
40019fd4:	10 bf ff e4 	b  40019f64 <msdos_find_name+0x1d8>            
40019fd8:	c4 00 60 18 	ld  [ %g1 + 0x18 ], %g2                        
                                                                      

40018dbc <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 ) {
40018dbc:	9d e3 bf 80 	save  %sp, -128, %sp                           
40018dc0:	f8 27 a0 54 	st  %i4, [ %fp + 0x54 ]                        
40018dc4:	f2 27 a0 48 	st  %i1, [ %fp + 0x48 ]                        
40018dc8:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]                        
40018dcc:	fa 27 a0 58 	st  %i5, [ %fp + 0x58 ]                        
    uint32_t         empty_space_count = 0;                           
    bool             empty_space_found = false;                       
    uint32_t         entries_per_block;                               
    bool             read_cluster = false;                            
                                                                      
    assert(name_len > 0);                                             
40018dd0:	80 a7 20 00 	cmp  %i4, 0                                    
40018dd4:	04 80 02 80 	ble  400197d4 <msdos_find_name_in_fat_file+0xa18><== NEVER TAKEN
40018dd8:	ea 06 20 08 	ld  [ %i0 + 8 ], %l5                           
     * 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))               
40018ddc:	c4 07 a0 58 	ld  [ %fp + 0x58 ], %g2                        
40018de0:	82 18 a0 01 	xor  %g2, 1, %g1                               
static inline void                                                    
fat_dir_pos_init(                                                     
    fat_dir_pos_t *dir_pos                                            
    )                                                                 
{                                                                     
  dir_pos->sname.cln = 0;                                             
40018de4:	c4 07 a0 5c 	ld  [ %fp + 0x5c ], %g2                        
40018de8:	80 a0 00 01 	cmp  %g0, %g1                                  
40018dec:	c0 20 80 00 	clr  [ %g2 ]                                   
  dir_pos->sname.ofs = 0;                                             
  dir_pos->lname.cln = FAT_FILE_SHORT_NAME;                           
40018df0:	82 10 3f ff 	mov  -1, %g1                                   
fat_dir_pos_init(                                                     
    fat_dir_pos_t *dir_pos                                            
    )                                                                 
{                                                                     
  dir_pos->sname.cln = 0;                                             
  dir_pos->sname.ofs = 0;                                             
40018df4:	c0 20 a0 04 	clr  [ %g2 + 4 ]                               
  dir_pos->lname.cln = FAT_FILE_SHORT_NAME;                           
40018df8:	c2 20 a0 08 	st  %g1, [ %g2 + 8 ]                           
  dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;                           
40018dfc:	c2 20 a0 0c 	st  %g1, [ %g2 + 0xc ]                         
                                                                      
    assert(name_len > 0);                                             
                                                                      
    fat_dir_pos_init(dir_pos);                                        
                                                                      
    lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;              
40018e00:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
     * 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))               
40018e04:	b2 60 3f ff 	subx  %g0, -1, %i1                             
40018e08:	80 a6 60 00 	cmp  %i1, 0                                    
40018e0c:	02 80 00 82 	be  40019014 <msdos_find_name_in_fat_file+0x258>
40018e10:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]                          
40018e14:	80 a6 a0 00 	cmp  %i2, 0                                    
40018e18:	02 80 00 7f 	be  40019014 <msdos_find_name_in_fat_file+0x258>
40018e1c:	c0 27 bf e4 	clr  [ %fp + -28 ]                             
      lfn_entries = 0;                                                
    else                                                              
      lfn_entries =                                                   
        ((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
                                                                      
    if (FAT_FD_OF_ROOT_DIR(fat_fd) &&                                 
40018e20:	c4 07 a0 48 	ld  [ %fp + 0x48 ], %g2                        
40018e24:	c2 00 a0 20 	ld  [ %g2 + 0x20 ], %g1                        
40018e28:	80 a0 60 01 	cmp  %g1, 1                                    
40018e2c:	22 80 01 85 	be,a   40019440 <msdos_find_name_in_fat_file+0x684>
40018e30:	c2 00 a0 24 	ld  [ %g2 + 0x24 ], %g1                        
        (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))            
        bts2rd = fat_fd->fat_file_size;                               
    else                                                              
        bts2rd = fs_info->fat.vol.bpc;                                
40018e34:	e2 15 60 06 	lduh  [ %l5 + 6 ], %l1                         
                  /*                                                  
                   * Remainder is not empty so is this entry empty ?  
                   */                                                 
                  empty_space_count++;                                
                                                                      
                  if (empty_space_count == (lfn_entries + 1))         
40018e38:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
    uint32_t         bts2rd = 0;                                      
    fat_pos_t        lfn_start;                                       
    bool             lfn_matched = false;                             
    uint8_t          lfn_checksum = 0;                                
    int              lfn_entries;                                     
    int              lfn_entry = 0;                                   
40018e3c:	ac 10 20 00 	clr  %l6                                       
    uint32_t         dir_offset = 0;                                  
    uint32_t         dir_entry = 0;                                   
    uint32_t         bts2rd = 0;                                      
    fat_pos_t        lfn_start;                                       
    bool             lfn_matched = false;                             
    uint8_t          lfn_checksum = 0;                                
40018e40:	b8 10 20 00 	clr  %i4                                       
                  /*                                                  
                   * Remainder is not empty so is this entry empty ?  
                   */                                                 
                  empty_space_count++;                                
                                                                      
                  if (empty_space_count == (lfn_entries + 1))         
40018e44:	82 00 60 01 	inc  %g1                                       
40018e48:	d8 05 60 a0 	ld  [ %l5 + 0xa0 ], %o4                        
40018e4c:	c2 27 bf ec 	st  %g1, [ %fp + -20 ]                         
    /*                                                                
     * 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(&fs_info->fat, fat_fd, (dir_offset * bts2rd),
40018e50:	c0 27 bf e8 	clr  [ %fp + -24 ]                             
40018e54:	82 10 00 19 	mov  %i1, %g1                                  
    int              lfn_entries;                                     
    int              lfn_entry = 0;                                   
    uint32_t         empty_space_offset = 0;                          
    uint32_t         empty_space_entry = 0;                           
    uint32_t         empty_space_count = 0;                           
    bool             empty_space_found = false;                       
40018e58:	a6 10 20 00 	clr  %l3                                       
40018e5c:	b2 10 00 16 	mov  %l6, %i1                                  
    uint8_t          lfn_checksum = 0;                                
    int              lfn_entries;                                     
    int              lfn_entry = 0;                                   
    uint32_t         empty_space_offset = 0;                          
    uint32_t         empty_space_entry = 0;                           
    uint32_t         empty_space_count = 0;                           
40018e60:	a0 10 20 00 	clr  %l0                                       
40018e64:	ac 10 00 1c 	mov  %i4, %l6                                  
    bool             lfn_matched = false;                             
    uint8_t          lfn_checksum = 0;                                
    int              lfn_entries;                                     
    int              lfn_entry = 0;                                   
    uint32_t         empty_space_offset = 0;                          
    uint32_t         empty_space_entry = 0;                           
40018e68:	a4 10 20 00 	clr  %l2                                       
40018e6c:	b8 10 00 15 	mov  %l5, %i4                                  
    fat_pos_t        lfn_start;                                       
    bool             lfn_matched = false;                             
    uint8_t          lfn_checksum = 0;                                
    int              lfn_entries;                                     
    int              lfn_entry = 0;                                   
    uint32_t         empty_space_offset = 0;                          
40018e70:	ae 10 20 00 	clr  %l7                                       
    msdos_fs_info_t *fs_info = mt_entry->fs_info;                     
    uint32_t         dir_offset = 0;                                  
    uint32_t         dir_entry = 0;                                   
    uint32_t         bts2rd = 0;                                      
    fat_pos_t        lfn_start;                                       
    bool             lfn_matched = false;                             
40018e74:	b0 10 20 00 	clr  %i0                                       
    char                                 *name_dir_entry              
                                )                                     
{                                                                     
    ssize_t          ret = 0;                                         
    msdos_fs_info_t *fs_info = mt_entry->fs_info;                     
    uint32_t         dir_offset = 0;                                  
40018e78:	a8 10 20 00 	clr  %l4                                       
40018e7c:	aa 10 00 01 	mov  %g1, %l5                                  
    /*                                                                
     * 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(&fs_info->fat, fat_fd, (dir_offset * bts2rd),
40018e80:	d2 07 a0 48 	ld  [ %fp + 0x48 ], %o1                        
40018e84:	d4 07 bf e8 	ld  [ %fp + -24 ], %o2                         
40018e88:	90 10 00 1c 	mov  %i4, %o0                                  
40018e8c:	7f ff e6 3b 	call  40012778 <fat_file_read>                 
40018e90:	96 10 00 11 	mov  %l1, %o3                                  
40018e94:	80 a2 20 00 	cmp  %o0, 0                                    
40018e98:	02 80 00 e4 	be  40019228 <msdos_find_name_in_fat_file+0x46c>
40018e9c:	80 a2 20 1f 	cmp  %o0, 0x1f                                 
        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)                  
40018ea0:	04 80 01 85 	ble  400194b4 <msdos_find_name_in_fat_file+0x6f8><== NEVER TAKEN
40018ea4:	80 a2 00 11 	cmp  %o0, %l1                                  
            rtems_set_errno_and_return_minus_one(EIO);                
                                                                      
        assert(ret == bts2rd);                                        
40018ea8:	12 80 02 53 	bne  400197f4 <msdos_find_name_in_fat_file+0xa38><== NEVER TAKEN
40018eac:	84 10 00 18 	mov  %i0, %g2                                  
40018eb0:	d8 07 20 a0 	ld  [ %i4 + 0xa0 ], %o4                        
40018eb4:	b6 10 20 00 	clr  %i3                                       
40018eb8:	b0 10 00 19 	mov  %i1, %i0                                  
40018ebc:	ba 10 00 0c 	mov  %o4, %i5                                  
40018ec0:	b2 10 00 0c 	mov  %o4, %i1                                  
             * 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)                               
40018ec4:	80 a4 20 00 	cmp  %l0, 0                                    
40018ec8:	12 80 00 04 	bne  40018ed8 <msdos_find_name_in_fat_file+0x11c>
40018ecc:	c6 0f 40 00 	ldub  [ %i5 ], %g3                             
40018ed0:	a4 10 00 1b 	mov  %i3, %l2                                  
40018ed4:	ae 10 00 14 	mov  %l4, %l7                                  
            {                                                         
                empty_space_entry = dir_entry;                        
                empty_space_offset = dir_offset;                      
            }                                                         
                                                                      
            if (remainder_empty)                                      
40018ed8:	82 88 e0 ff 	andcc  %g3, 0xff, %g1                          
40018edc:	02 80 00 e2 	be  40019264 <msdos_find_name_in_fat_file+0x4a8>
40018ee0:	80 a0 60 e5 	cmp  %g1, 0xe5                                 
                  printf ("MSFS:[3.2] esf:%i esc%i\n", empty_space_found, empty_space_count);
#endif                                                                
                }                                                     
                break;                                                
            }                                                         
            else if (entry_empty)                                     
40018ee4:	02 80 00 69 	be  40019088 <msdos_find_name_in_fat_file+0x2cc>
40018ee8:	82 1c e0 01 	xor  %l3, 1, %g1                               
                 * 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)                
40018eec:	80 88 60 ff 	btst  0xff, %g1                                
40018ef0:	02 80 00 07 	be  40018f0c <msdos_find_name_in_fat_file+0x150><== NEVER TAKEN
40018ef4:	c2 0f 60 0b 	ldub  [ %i5 + 0xb ], %g1                       
40018ef8:	80 a6 a0 00 	cmp  %i2, 0                                    
40018efc:	02 80 00 04 	be  40018f0c <msdos_find_name_in_fat_file+0x150>
40018f00:	01 00 00 00 	nop                                            
                {                                                     
                    empty_space_entry = 0;                            
                    empty_space_count = 0;                            
40018f04:	a0 10 20 00 	clr  %l0	! 0 <PROM_START>                      
                 * If empty space has not been found we need to start the
                 * count again.                                       
                 */                                                   
                if (create_node && !empty_space_found)                
                {                                                     
                    empty_space_entry = 0;                            
40018f08:	a4 10 20 00 	clr  %l2                                       
                                                                      
                /*                                                    
                 * Check the attribute to see if the entry is for a long
                 * file name.                                         
                 */                                                   
                if ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) == 
40018f0c:	82 08 60 3f 	and  %g1, 0x3f, %g1                            
40018f10:	80 a0 60 0f 	cmp  %g1, 0xf                                  
40018f14:	02 80 00 67 	be  400190b0 <msdos_find_name_in_fat_file+0x2f4>
40018f18:	80 88 a0 ff 	btst  0xff, %g2                                
                     * 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)                                  
40018f1c:	02 80 00 4a 	be  40019044 <msdos_find_name_in_fat_file+0x288>
40018f20:	80 a5 60 00 	cmp  %l5, 0                                    
 *     RC_OK on success, or error code if error occured (errno set    
 *     appropriately)                                                 
 *                                                                    
 */                                                                   
#define MSDOS_FIND_PRINT 0                                            
int msdos_find_name_in_fat_file(                                      
40018f24:	9e 07 60 0a 	add  %i5, 0xa, %o7                             
40018f28:	84 10 00 1d 	mov  %i5, %g2                                  
40018f2c:	88 10 20 00 	clr  %g4                                       
                        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;
40018f30:	10 80 00 09 	b  40018f54 <msdos_find_name_in_fat_file+0x198>
40018f34:	82 10 20 00 	clr  %g1                                       
40018f38:	82 08 60 01 	and  %g1, 1, %g1                               
40018f3c:	c6 08 a0 01 	ldub  [ %g2 + 1 ], %g3                         
40018f40:	80 a0 00 01 	cmp  %g0, %g1                                  
40018f44:	84 00 a0 01 	inc  %g2                                       
40018f48:	82 40 3f ff 	addx  %g0, -1, %g1                             
40018f4c:	82 08 60 80 	and  %g1, 0x80, %g1                            
40018f50:	82 00 7f 80 	add  %g1, -128, %g1                            
40018f54:	88 09 20 ff 	and  %g4, 0xff, %g4                            
40018f58:	89 31 20 01 	srl  %g4, 1, %g4                               
40018f5c:	82 00 40 03 	add  %g1, %g3, %g1                             
                    {                                                 
                        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++)
40018f60:	80 a0 80 0f 	cmp  %g2, %o7                                  
                            cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
40018f64:	82 00 40 04 	add  %g1, %g4, %g1                             
                    {                                                 
                        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++)
40018f68:	12 bf ff f4 	bne  40018f38 <msdos_find_name_in_fat_file+0x17c>
40018f6c:	88 10 00 01 	mov  %g1, %g4                                  
                            cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
                                                                      
                        if (lfn_entry || (lfn_checksum != cs))        
40018f70:	88 1d 80 04 	xor  %l6, %g4, %g4                             
40018f74:	80 89 20 ff 	btst  0xff, %g4                                
40018f78:	12 80 00 33 	bne  40019044 <msdos_find_name_in_fat_file+0x288><== NEVER TAKEN
40018f7c:	80 a5 60 00 	cmp  %l5, 0                                    
40018f80:	80 a6 20 00 	cmp  %i0, 0                                    
40018f84:	12 80 00 30 	bne  40019044 <msdos_find_name_in_fat_file+0x288><== NEVER TAKEN
40018f88:	80 a5 60 00 	cmp  %l5, 0                                    
#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(&fs_info->fat, fat_fd, F_CLU_NUM,
40018f8c:	d2 07 a0 48 	ld  [ %fp + 0x48 ], %o1                        
40018f90:	d6 07 bf e8 	ld  [ %fp + -24 ], %o3                         
40018f94:	d8 07 a0 5c 	ld  [ %fp + 0x5c ], %o4                        
40018f98:	90 10 00 1c 	mov  %i4, %o0                                  
40018f9c:	7f ff e6 eb 	call  40012b48 <fat_file_ioctl>                
40018fa0:	94 10 20 01 	mov  1, %o2                                    
                                                dir_offset * bts2rd,  
                                                &dir_pos->sname.cln); 
                        if (rc != RC_OK)                              
40018fa4:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40018fa8:	12 80 00 19 	bne  4001900c <msdos_find_name_in_fat_file+0x250><== NEVER TAKEN
40018fac:	c2 07 a0 5c 	ld  [ %fp + 0x5c ], %g1                        
                            return rc;                                
                                                                      
                        dir_pos->sname.ofs = dir_entry;               
                                                                      
                        if (lfn_start.cln != FAT_FILE_SHORT_NAME)     
40018fb0:	d2 07 bf f8 	ld  [ %fp + -8 ], %o1                          
40018fb4:	80 a2 7f ff 	cmp  %o1, -1                                   
40018fb8:	02 80 01 34 	be  40019488 <msdos_find_name_in_fat_file+0x6cc>
40018fbc:	f6 20 60 04 	st  %i3, [ %g1 + 4 ]                           
                        {                                             
                          rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
40018fc0:	7f ff a5 73 	call  4000258c <.umul>                         
40018fc4:	90 10 00 11 	mov  %l1, %o0                                  
40018fc8:	d2 07 a0 48 	ld  [ %fp + 0x48 ], %o1                        
40018fcc:	96 10 00 08 	mov  %o0, %o3                                  
40018fd0:	94 10 20 01 	mov  1, %o2                                    
40018fd4:	90 10 00 1c 	mov  %i4, %o0                                  
40018fd8:	7f ff e6 dc 	call  40012b48 <fat_file_ioctl>                
40018fdc:	98 07 bf f8 	add  %fp, -8, %o4                              
                                              lfn_start.cln * bts2rd, 
                                              &lfn_start.cln);        
                          if (rc != RC_OK)                            
40018fe0:	80 a2 20 00 	cmp  %o0, 0                                    
40018fe4:	12 80 01 27 	bne  40019480 <msdos_find_name_in_fat_file+0x6c4><== NEVER TAKEN
40018fe8:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
                            return rc;                                
                        }                                             
                                                                      
                        dir_pos->lname.cln = lfn_start.cln;           
40018fec:	c4 07 a0 5c 	ld  [ %fp + 0x5c ], %g2                        
                        dir_pos->lname.ofs = lfn_start.ofs;           
                                                                      
                        memcpy(name_dir_entry, entry,                 
40018ff0:	d0 07 a0 60 	ld  [ %fp + 0x60 ], %o0                        
                                              &lfn_start.cln);        
                          if (rc != RC_OK)                            
                            return rc;                                
                        }                                             
                                                                      
                        dir_pos->lname.cln = lfn_start.cln;           
40018ff4:	c2 20 a0 08 	st  %g1, [ %g2 + 8 ]                           
                        dir_pos->lname.ofs = lfn_start.ofs;           
40018ff8:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
                                                                      
                        memcpy(name_dir_entry, entry,                 
40018ffc:	92 10 00 1d 	mov  %i5, %o1                                  
                          if (rc != RC_OK)                            
                            return rc;                                
                        }                                             
                                                                      
                        dir_pos->lname.cln = lfn_start.cln;           
                        dir_pos->lname.ofs = lfn_start.ofs;           
40019000:	c2 20 a0 0c 	st  %g1, [ %g2 + 0xc ]                         
                                                                      
                        memcpy(name_dir_entry, entry,                 
40019004:	40 00 0f 88 	call  4001ce24 <memcpy>                        
40019008:	94 10 20 20 	mov  0x20, %o2                                 
4001900c:	81 c7 e0 08 	ret                                            
40019010:	81 e8 00 00 	restore                                        
     * test this make this test always fail, ie add "0 &&".           
     */                                                               
    if (create_node && (name_type == MSDOS_NAME_SHORT))               
      lfn_entries = 0;                                                
    else                                                              
      lfn_entries =                                                   
40019014:	c4 07 a0 54 	ld  [ %fp + 0x54 ], %g2                        
40019018:	92 10 20 0d 	mov  0xd, %o1                                  
4001901c:	7f ff a5 98 	call  4000267c <.div>                          
40019020:	90 00 a0 0c 	add  %g2, 0xc, %o0                             
        ((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
                                                                      
    if (FAT_FD_OF_ROOT_DIR(fat_fd) &&                                 
40019024:	c4 07 a0 48 	ld  [ %fp + 0x48 ], %g2                        
     * test this make this test always fail, ie add "0 &&".           
     */                                                               
    if (create_node && (name_type == MSDOS_NAME_SHORT))               
      lfn_entries = 0;                                                
    else                                                              
      lfn_entries =                                                   
40019028:	d0 27 bf e4 	st  %o0, [ %fp + -28 ]                         
        ((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
                                                                      
    if (FAT_FD_OF_ROOT_DIR(fat_fd) &&                                 
4001902c:	c2 00 a0 20 	ld  [ %g2 + 0x20 ], %g1                        
40019030:	80 a0 60 01 	cmp  %g1, 1                                    
40019034:	32 bf ff 81 	bne,a   40018e38 <msdos_find_name_in_fat_file+0x7c>
40019038:	e2 15 60 06 	lduh  [ %l5 + 6 ], %l1                         
4001903c:	10 80 01 01 	b  40019440 <msdos_find_name_in_fat_file+0x684>
40019040:	c2 00 a0 24 	ld  [ %g2 + 0x24 ], %g1                        
                     * 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 ||                                
40019044:	12 80 00 5f 	bne  400191c0 <msdos_find_name_in_fat_file+0x404>
40019048:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
                        memcpy(name_dir_entry, entry,                 
                               MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);    
                        return RC_OK;                                 
                    }                                                 
                                                                      
                    lfn_start.cln = FAT_FILE_SHORT_NAME;              
4001904c:	82 10 3f ff 	mov  -1, %g1                                   
                    lfn_matched = false;                              
40019050:	84 10 20 00 	clr  %g2                                       
                        memcpy(name_dir_entry, entry,                 
                               MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);    
                        return RC_OK;                                 
                    }                                                 
                                                                      
                    lfn_start.cln = FAT_FILE_SHORT_NAME;              
40019054:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]                          
40019058:	b6 06 e0 20 	add  %i3, 0x20, %i3                            
            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;                                           
4001905c:	80 a4 40 1b 	cmp  %l1, %i3                                  
40019060:	18 bf ff 99 	bgu  40018ec4 <msdos_find_name_in_fat_file+0x108>
40019064:	ba 07 60 20 	add  %i5, 0x20, %i5                            
40019068:	98 10 00 19 	mov  %i1, %o4                                  
4001906c:	b2 10 00 18 	mov  %i0, %i1                                  
40019070:	b0 10 00 02 	mov  %g2, %i0                                  
40019074:	c4 07 bf e8 	ld  [ %fp + -24 ], %g2                         
        }                                                             
                                                                      
        if (remainder_empty)                                          
            break;                                                    
                                                                      
        dir_offset++;                                                 
40019078:	a8 05 20 01 	inc  %l4                                       
4001907c:	84 00 80 11 	add  %g2, %l1, %g2                             
40019080:	10 bf ff 80 	b  40018e80 <msdos_find_name_in_fat_file+0xc4> 
40019084:	c4 27 bf e8 	st  %g2, [ %fp + -24 ]                         
                }                                                     
                break;                                                
            }                                                         
            else if (entry_empty)                                     
            {                                                         
                if (create_node)                                      
40019088:	80 a6 a0 00 	cmp  %i2, 0                                    
4001908c:	22 bf ff f4 	be,a   4001905c <msdos_find_name_in_fat_file+0x2a0>
40019090:	b6 06 e0 20 	add  %i3, 0x20, %i3                            
                  /*                                                  
                   * Remainder is not empty so is this entry empty ?  
                   */                                                 
                  empty_space_count++;                                
                                                                      
                  if (empty_space_count == (lfn_entries + 1))         
40019094:	c2 07 bf ec 	ld  [ %fp + -20 ], %g1                         
                if (create_node)                                      
                {                                                     
                  /*                                                  
                   * Remainder is not empty so is this entry empty ?  
                   */                                                 
                  empty_space_count++;                                
40019098:	a0 04 20 01 	inc  %l0                                       
                                                                      
                  if (empty_space_count == (lfn_entries + 1))         
4001909c:	80 a0 40 10 	cmp  %g1, %l0                                  
400190a0:	22 bf ff ee 	be,a   40019058 <msdos_find_name_in_fat_file+0x29c>
400190a4:	a6 10 20 01 	mov  1, %l3                                    
400190a8:	10 bf ff ed 	b  4001905c <msdos_find_name_in_fat_file+0x2a0>
400190ac:	b6 06 e0 20 	add  %i3, 0x20, %i3                            
#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)         
400190b0:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
400190b4:	80 a0 7f ff 	cmp  %g1, -1                                   
400190b8:	02 80 00 4e 	be  400191f0 <msdos_find_name_in_fat_file+0x434>
400190bc:	82 08 e0 40 	and  %g3, 0x40, %g1                            
                     * 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) & 
400190c0:	86 08 e0 3f 	and  %g3, 0x3f, %g3                            
400190c4:	80 a0 c0 18 	cmp  %g3, %i0                                  
400190c8:	22 80 00 05 	be,a   400190dc <msdos_find_name_in_fat_file+0x320><== ALWAYS TAKEN
400190cc:	d4 0f 60 0d 	ldub  [ %i5 + 0xd ], %o2                       
                        (lfn_checksum != *MSDOS_DIR_LFN_CHECKSUM(entry)))
                    {                                                 
#if MSDOS_FIND_PRINT                                                  
                        printf ("MSFS:[4.4] no match\n");             
#endif                                                                
                        lfn_start.cln = FAT_FILE_SHORT_NAME;          
400190d0:	82 10 3f ff 	mov  -1, %g1                                   <== NOT EXECUTED
                        continue;                                     
400190d4:	10 bf ff e1 	b  40019058 <msdos_find_name_in_fat_file+0x29c><== NOT EXECUTED
400190d8:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]                          <== NOT EXECUTED
                     * 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) & 
                                       MSDOS_LAST_LONG_ENTRY_MASK)) ||
400190dc:	82 0d a0 ff 	and  %l6, 0xff, %g1                            
400190e0:	88 0a a0 ff 	and  %o2, 0xff, %g4                            
400190e4:	80 a1 00 01 	cmp  %g4, %g1                                  
400190e8:	12 bf ff fb 	bne  400190d4 <msdos_find_name_in_fat_file+0x318><== NEVER TAKEN
400190ec:	82 10 3f ff 	mov  -1, %g1                                   
 *     RC_OK on success, or error code if error occured (errno set    
 *     appropriately)                                                 
 *                                                                    
 */                                                                   
#define MSDOS_FIND_PRINT 0                                            
int msdos_find_name_in_fat_file(                                      
400190f0:	88 07 60 01 	add  %i5, 1, %g4                               
                    {                                                 
#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')                               
400190f4:	c4 49 00 00 	ldsb  [ %g4 ], %g2                             
#endif                                                                
                        lfn_start.cln = FAT_FILE_SHORT_NAME;          
                        continue;                                     
                    }                                                 
                                                                      
                    lfn_entry--;                                      
400190f8:	b0 06 3f ff 	add  %i0, -1, %i0                              
                    o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;          
400190fc:	83 2e 20 02 	sll  %i0, 2, %g1                               
40019100:	9b 2e 20 04 	sll  %i0, 4, %o5                               
 *     RC_OK on success, or error code if error occured (errno set    
 *     appropriately)                                                 
 *                                                                    
 */                                                                   
#define MSDOS_FIND_PRINT 0                                            
int msdos_find_name_in_fat_file(                                      
40019104:	9e 10 20 01 	mov  1, %o7                                    
                        lfn_start.cln = FAT_FILE_SHORT_NAME;          
                        continue;                                     
                    }                                                 
                                                                      
                    lfn_entry--;                                      
                    o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;          
40019108:	9a 23 40 01 	sub  %o5, %g1, %o5                             
4001910c:	d2 07 a0 50 	ld  [ %fp + 0x50 ], %o1                        
 *     RC_OK on success, or error code if error occured (errno set    
 *     appropriately)                                                 
 *                                                                    
 */                                                                   
#define MSDOS_FIND_PRINT 0                                            
int msdos_find_name_in_fat_file(                                      
40019110:	82 10 20 00 	clr  %g1                                       
                        lfn_start.cln = FAT_FILE_SHORT_NAME;          
                        continue;                                     
                    }                                                 
                                                                      
                    lfn_entry--;                                      
                    o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;          
40019114:	9a 03 40 18 	add  %o5, %i0, %o5                             
                    {                                                 
#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')                               
40019118:	80 a0 a0 00 	cmp  %g2, 0                                    
4001911c:	02 80 00 16 	be  40019174 <msdos_find_name_in_fat_file+0x3b8><== NEVER TAKEN
40019120:	d6 07 a0 54 	ld  [ %fp + 0x54 ], %o3                        
 *     RC_OK on success, or error code if error occured (errno set    
 *     appropriately)                                                 
 *                                                                    
 */                                                                   
#define MSDOS_FIND_PRINT 0                                            
int msdos_find_name_in_fat_file(                                      
40019124:	98 00 40 0d 	add  %g1, %o5, %o4                             
                                ((o + i) != name_len))                
                                lfn_start.cln = FAT_FILE_SHORT_NAME;  
                            break;                                    
                        }                                             
                                                                      
                        if (((o + i) >= name_len) || (*p != name[o + i]))
40019128:	80 a2 c0 0c 	cmp  %o3, %o4                                  
4001912c:	04 80 00 ce 	ble  40019464 <msdos_find_name_in_fat_file+0x6a8>
40019130:	98 02 40 0d 	add  %o1, %o5, %o4                             
40019134:	d8 4b 00 01 	ldsb  [ %o4 + %g1 ], %o4                       
40019138:	80 a0 80 0c 	cmp  %g2, %o4                                  
4001913c:	12 80 00 ca 	bne  40019464 <msdos_find_name_in_fat_file+0x6a8>
40019140:	80 a0 60 04 	cmp  %g1, 4                                    
                        {                                             
                            lfn_start.cln = FAT_FILE_SHORT_NAME;      
                            break;                                    
                        }                                             
                                                                      
                        switch (i)                                    
40019144:	02 80 00 44 	be  40019254 <msdos_find_name_in_fat_file+0x498>
40019148:	80 a0 60 0a 	cmp  %g1, 0xa                                  
4001914c:	02 80 00 3e 	be  40019244 <msdos_find_name_in_fat_file+0x488>
40019150:	80 a3 e0 0d 	cmp  %o7, 0xd                                  
                    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++)     
40019154:	02 80 00 12 	be  4001919c <msdos_find_name_in_fat_file+0x3e0>
40019158:	88 01 20 02 	add  %g4, 2, %g4                               
4001915c:	82 00 60 01 	inc  %g1                                       
40019160:	9e 03 e0 01 	inc  %o7                                       
                    {                                                 
#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')                               
40019164:	c4 49 00 00 	ldsb  [ %g4 ], %g2                             
40019168:	80 a0 a0 00 	cmp  %g2, 0                                    
4001916c:	12 bf ff ef 	bne  40019128 <msdos_find_name_in_fat_file+0x36c>
40019170:	98 00 40 0d 	add  %g1, %o5, %o4                             
                            /*                                        
                             * 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) &&   
40019174:	c4 07 bf e4 	ld  [ %fp + -28 ], %g2                         
40019178:	80 a0 80 03 	cmp  %g2, %g3                                  
4001917c:	12 80 00 09 	bne  400191a0 <msdos_find_name_in_fat_file+0x3e4><== NEVER TAKEN
40019180:	80 a6 20 00 	cmp  %i0, 0                                    
40019184:	c4 07 a0 54 	ld  [ %fp + 0x54 ], %g2                        
                                ((o + i) != name_len))                
40019188:	82 03 40 01 	add  %o5, %g1, %g1                             
                            /*                                        
                             * 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) &&   
4001918c:	80 a0 40 02 	cmp  %g1, %g2                                  
40019190:	02 80 00 03 	be  4001919c <msdos_find_name_in_fat_file+0x3e0><== ALWAYS TAKEN
40019194:	82 10 3f ff 	mov  -1, %g1                                   
                                ((o + i) != name_len))                
                                lfn_start.cln = FAT_FILE_SHORT_NAME;  
40019198:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]                          <== NOT EXECUTED
                                p += 2;                               
                                break;                                
                        }                                             
                    }                                                 
                                                                      
                    lfn_matched = ((lfn_entry == 0) &&                
4001919c:	80 a6 20 00 	cmp  %i0, 0                                    
400191a0:	12 80 00 06 	bne  400191b8 <msdos_find_name_in_fat_file+0x3fc>
400191a4:	84 10 20 00 	clr  %g2                                       
400191a8:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
400191ac:	82 38 00 01 	xnor  %g0, %g1, %g1                            
400191b0:	80 a0 00 01 	cmp  %g0, %g1                                  
400191b4:	84 40 20 00 	addx  %g0, 0, %g2                              
                     * 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)         
                    {                                                 
                        lfn_matched = false;                          
400191b8:	10 bf ff a8 	b  40019058 <msdos_find_name_in_fat_file+0x29c>
400191bc:	ac 10 00 0a 	mov  %o2, %l6                                  
                     * 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 ||                                
                        ((name_type == MSDOS_NAME_SHORT) &&           
400191c0:	80 a0 7f ff 	cmp  %g1, -1                                   
400191c4:	12 bf ff a3 	bne  40019050 <msdos_find_name_in_fat_file+0x294><== NEVER TAKEN
400191c8:	82 10 3f ff 	mov  -1, %g1                                   
                         (lfn_start.cln == FAT_FILE_SHORT_NAME) &&    
                         (memcmp(MSDOS_DIR_NAME(entry),               
400191cc:	d2 07 a0 60 	ld  [ %fp + 0x60 ], %o1                        
400191d0:	90 10 00 1d 	mov  %i5, %o0                                  
400191d4:	40 00 0e ea 	call  4001cd7c <memcmp>                        
400191d8:	94 10 20 0b 	mov  0xb, %o2                                  
                     * a long file name that generates a matching short file
                     * name is not a long file name.                  
                     */                                               
                    if (lfn_matched ||                                
                        ((name_type == MSDOS_NAME_SHORT) &&           
                         (lfn_start.cln == FAT_FILE_SHORT_NAME) &&    
400191dc:	80 a2 20 00 	cmp  %o0, 0                                    
400191e0:	12 bf ff 9c 	bne  40019050 <msdos_find_name_in_fat_file+0x294>
400191e4:	82 10 3f ff 	mov  -1, %g1                                   
#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(&fs_info->fat, fat_fd, F_CLU_NUM,
400191e8:	10 bf ff 6a 	b  40018f90 <msdos_find_name_in_fat_file+0x1d4>
400191ec:	d2 07 a0 48 	ld  [ %fp + 0x48 ], %o1                        
                                                                      
                        /*                                            
                         * The first entry must have the last long entry
                         * flag set.                                  
                         */                                           
                        if ((*MSDOS_DIR_ENTRY_TYPE(entry) &           
400191f0:	80 88 60 ff 	btst  0xff, %g1                                
400191f4:	02 bf ff 99 	be  40019058 <msdos_find_name_in_fat_file+0x29c>
400191f8:	84 10 20 00 	clr  %g2                                       
                         * 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) &
400191fc:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
40019200:	86 08 e0 3f 	and  %g3, 0x3f, %g3                            
40019204:	80 a0 c0 01 	cmp  %g3, %g1                                  
40019208:	32 bf ff 95 	bne,a   4001905c <msdos_find_name_in_fat_file+0x2a0>
4001920c:	b6 06 e0 20 	add  %i3, 0x20, %i3                            
                            continue;                                 
                                                                      
                        /*                                            
                         * Get the checksum of the short entry.       
                         */                                           
                        lfn_start.cln = dir_offset;                   
40019210:	e8 27 bf f8 	st  %l4, [ %fp + -8 ]                          
                        lfn_start.ofs = dir_entry;                    
40019214:	f6 27 bf fc 	st  %i3, [ %fp + -4 ]                          
                        lfn_entry = lfn_entries;                      
                        lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
40019218:	b0 10 00 01 	mov  %g1, %i0                                  
4001921c:	ec 0f 60 0d 	ldub  [ %i5 + 0xd ], %l6                       
40019220:	10 bf ff a8 	b  400190c0 <msdos_find_name_in_fat_file+0x304>
40019224:	c6 0f 40 00 	ldub  [ %i5 ], %g3                             
                                                                      
    /*                                                                
     * If we are not to create the entry return a not found error.    
     */                                                               
    if (!create_node)                                                 
      return MSDOS_NAME_NOT_FOUND_ERR;                                
40019228:	31 00 00 1f 	sethi  %hi(0x7c00), %i0                        
4001922c:	aa 10 00 1c 	mov  %i4, %l5                                  
    }                                                                 
                                                                      
    /*                                                                
     * If we are not to create the entry return a not found error.    
     */                                                               
    if (!create_node)                                                 
40019230:	80 a6 a0 00 	cmp  %i2, 0                                    
40019234:	12 80 00 16 	bne  4001928c <msdos_find_name_in_fat_file+0x4d0>
40019238:	b0 16 21 01 	or  %i0, 0x101, %i0                            
        empty_space_entry = 0;                                        
        read_cluster = true;                                          
    }                                                                 
                                                                      
    return 0;                                                         
}                                                                     
4001923c:	81 c7 e0 08 	ret                                            
40019240:	81 e8 00 00 	restore                                        
                        {                                             
                            case 4:                                   
                                p += 5;                               
                                break;                                
                            case 10:                                  
                                p += 4;                               
40019244:	88 01 20 04 	add  %g4, 4, %g4                               
40019248:	82 00 60 01 	inc  %g1                                       
4001924c:	10 bf ff c6 	b  40019164 <msdos_find_name_in_fat_file+0x3a8>
40019250:	9e 03 e0 01 	inc  %o7                                       
                        }                                             
                                                                      
                        switch (i)                                    
                        {                                             
                            case 4:                                   
                                p += 5;                               
40019254:	88 01 20 05 	add  %g4, 5, %g4                               
40019258:	82 00 60 01 	inc  %g1                                       
4001925c:	10 bf ff c2 	b  40019164 <msdos_find_name_in_fat_file+0x3a8>
40019260:	9e 03 e0 01 	inc  %o7                                       
#endif                                                                
                /*                                                    
                 * If just looking and there is no more entries in the
                 * directory - return name-not-found                  
                 */                                                   
                if (!create_node)                                     
40019264:	80 a6 a0 00 	cmp  %i2, 0                                    
40019268:	02 80 01 1e 	be  400196e0 <msdos_find_name_in_fat_file+0x924>
4001926c:	aa 10 00 1c 	mov  %i4, %l5                                  
                 * 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)                               
40019270:	80 8c e0 ff 	btst  0xff, %l3                                
40019274:	12 80 00 07 	bne  40019290 <msdos_find_name_in_fat_file+0x4d4>
40019278:	c2 07 a0 58 	ld  [ %fp + 0x58 ], %g1                        
        (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))            
        bts2rd = fat_fd->fat_file_size;                               
    else                                                              
        bts2rd = fs_info->fat.vol.bpc;                                
                                                                      
    entries_per_block = bts2rd / MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;   
4001927c:	85 34 60 05 	srl  %l1, 5, %g2                               
                 * are needed FAT_EOF is returned by the read and we extend the file.
                 */                                                   
                if (!empty_space_found)                               
                {                                                     
                  empty_space_count +=                                
                    entries_per_block - (dir_entry / MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
40019280:	b7 36 e0 05 	srl  %i3, 5, %i3                               
40019284:	a0 04 00 02 	add  %l0, %g2, %l0                             
                 * 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 +=                                
40019288:	a0 24 00 1b 	sub  %l0, %i3, %l0                             
     * 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)                                 
4001928c:	c2 07 a0 58 	ld  [ %fp + 0x58 ], %g1                        
40019290:	80 a0 60 02 	cmp  %g1, 2                                    
40019294:	02 80 01 1d 	be  40019708 <msdos_find_name_in_fat_file+0x94c>
40019298:	90 10 00 17 	mov  %l7, %o0                                  
        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)                                                  
4001929c:	c4 07 bf e4 	ld  [ %fp + -28 ], %g2                         
400192a0:	80 a0 a0 00 	cmp  %g2, 0                                    
400192a4:	02 80 00 15 	be  400192f8 <msdos_find_name_in_fat_file+0x53c>
400192a8:	b6 10 20 00 	clr  %i3                                       
 *     RC_OK on success, or error code if error occured (errno set    
 *     appropriately)                                                 
 *                                                                    
 */                                                                   
#define MSDOS_FIND_PRINT 0                                            
int msdos_find_name_in_fat_file(                                      
400192ac:	c2 07 a0 60 	ld  [ %fp + 0x60 ], %g1                        
    if (lfn_entries)                                                  
    {                                                                 
        uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);       
        int      i;                                                   
        for (i = 0; i < 11; i++, p++)                                 
            lfn_checksum =                                            
400192b0:	84 10 20 00 	clr  %g2                                       
 *     RC_OK on success, or error code if error occured (errno set    
 *     appropriately)                                                 
 *                                                                    
 */                                                                   
#define MSDOS_FIND_PRINT 0                                            
int msdos_find_name_in_fat_file(                                      
400192b4:	88 00 60 0b 	add  %g1, 0xb, %g4                             
400192b8:	10 80 00 07 	b  400192d4 <msdos_find_name_in_fat_file+0x518>
400192bc:	86 10 00 01 	mov  %g1, %g3                                  
    if (lfn_entries)                                                  
    {                                                                 
        uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);       
        int      i;                                                   
        for (i = 0; i < 11; i++, p++)                                 
            lfn_checksum =                                            
400192c0:	84 08 a0 01 	and  %g2, 1, %g2                               
400192c4:	80 a0 00 02 	cmp  %g0, %g2                                  
400192c8:	84 40 3f ff 	addx  %g0, -1, %g2                             
400192cc:	84 08 a0 80 	and  %g2, 0x80, %g2                            
400192d0:	84 00 bf 80 	add  %g2, -128, %g2                            
400192d4:	fa 08 c0 00 	ldub  [ %g3 ], %i5                             
400192d8:	82 0e e0 ff 	and  %i3, 0xff, %g1                            
                                                                      
    if (lfn_entries)                                                  
    {                                                                 
        uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);       
        int      i;                                                   
        for (i = 0; i < 11; i++, p++)                                 
400192dc:	86 00 e0 01 	inc  %g3                                       
            lfn_checksum =                                            
400192e0:	83 30 60 01 	srl  %g1, 1, %g1                               
                                                                      
    if (lfn_entries)                                                  
    {                                                                 
        uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);       
        int      i;                                                   
        for (i = 0; i < 11; i++, p++)                                 
400192e4:	80 a0 c0 04 	cmp  %g3, %g4                                  
            lfn_checksum =                                            
400192e8:	82 07 40 01 	add  %i5, %g1, %g1                             
400192ec:	84 00 40 02 	add  %g1, %g2, %g2                             
                                                                      
    if (lfn_entries)                                                  
    {                                                                 
        uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);       
        int      i;                                                   
        for (i = 0; i < 11; i++, p++)                                 
400192f0:	12 bf ff f4 	bne  400192c0 <msdos_find_name_in_fat_file+0x504>
400192f4:	b6 10 00 02 	mov  %g2, %i3                                  
     * 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)                                       
400192f8:	80 a4 20 00 	cmp  %l0, 0                                    
400192fc:	22 80 00 ba 	be,a   400195e4 <msdos_find_name_in_fat_file+0x828>
40019300:	ae 10 00 14 	mov  %l4, %l7                                  
    uint32_t         empty_space_offset = 0;                          
    uint32_t         empty_space_entry = 0;                           
    uint32_t         empty_space_count = 0;                           
    bool             empty_space_found = false;                       
    uint32_t         entries_per_block;                               
    bool             read_cluster = false;                            
40019304:	a8 1d 00 17 	xor  %l4, %l7, %l4                             
40019308:	80 a0 00 14 	cmp  %g0, %l4                                  
4001930c:	ba 40 20 00 	addx  %g0, 0, %i5                              
#endif                                                                
                                                                      
    /*                                                                
     * The one more is the short entry.                               
     */                                                               
    while (lfn_entry < (lfn_entries + 1))                             
40019310:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
        read_cluster = true;                                          
                                                                      
    /*                                                                
     * Handle the entry writes.                                       
     */                                                               
    lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;              
40019314:	84 10 3f ff 	mov  -1, %g2                                   
40019318:	c4 27 bf fc 	st  %g2, [ %fp + -4 ]                          
#endif                                                                
                                                                      
    /*                                                                
     * The one more is the short entry.                               
     */                                                               
    while (lfn_entry < (lfn_entries + 1))                             
4001931c:	80 a0 60 00 	cmp  %g1, 0                                    
40019320:	06 80 00 af 	bl  400195dc <msdos_find_name_in_fat_file+0x820><== NEVER TAKEN
40019324:	c4 27 bf f8 	st  %g2, [ %fp + -8 ]                          
                    length, lfn_entry);                               
#endif                                                                
            /*                                                        
             * Time to write the short file name entry.               
             */                                                       
            if (lfn_entry == (lfn_entries + 1))                       
40019328:	b8 00 60 01 	add  %g1, 1, %i4                               
4001932c:	90 10 00 17 	mov  %l7, %o0                                  
40019330:	7f ff a4 97 	call  4000258c <.umul>                         
40019334:	92 10 00 11 	mov  %l1, %o1                                  
                                                                      
                dir_pos->sname.ofs = dir_entry;                       
                                                                      
                if (lfn_start.cln != FAT_FILE_SHORT_NAME)             
                {                                                     
                  rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
40019338:	f2 07 a0 48 	ld  [ %fp + 0x48 ], %i1                        
4001933c:	b0 10 00 08 	mov  %o0, %i0                                  
                                                                      
    /*                                                                
     * Handle the entry writes.                                       
     */                                                               
    lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;              
    lfn_entry = 0;                                                    
40019340:	a0 10 20 00 	clr  %l0                                       
40019344:	b4 10 00 1c 	mov  %i4, %i2                                  
     */                                                               
    while (lfn_entry < (lfn_entries + 1))                             
    {                                                                 
        int length = 0;                                               
                                                                      
        if (read_cluster)                                             
40019348:	80 8f 60 ff 	btst  0xff, %i5                                
4001934c:	32 80 00 b9 	bne,a   40019630 <msdos_find_name_in_fat_file+0x874>
40019350:	d8 05 60 a0 	ld  [ %l5 + 0xa0 ], %o4                        
                                                                      
#if MSDOS_FIND_PRINT                                                  
        printf ("MSFS:[10] eso:%li\n", empty_space_offset);           
#endif                                                                
                                                                      
        for (dir_entry = empty_space_entry;                           
40019354:	80 a4 40 12 	cmp  %l1, %l2                                  
40019358:	08 80 00 e9 	bleu  400196fc <msdos_find_name_in_fat_file+0x940><== NEVER TAKEN
4001935c:	a8 04 20 01 	add  %l0, 1, %l4                               
             dir_entry < bts2rd;                                      
             dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)          
        {                                                             
            char*       entry = (char*) fs_info->cl_buf + dir_entry;  
40019360:	ec 05 60 a0 	ld  [ %l5 + 0xa0 ], %l6                        
                    length, lfn_entry);                               
#endif                                                                
            /*                                                        
             * Time to write the short file name entry.               
             */                                                       
            if (lfn_entry == (lfn_entries + 1))                       
40019364:	80 a7 00 14 	cmp  %i4, %l4                                  
40019368:	02 80 00 e2 	be  400196f0 <msdos_find_name_in_fat_file+0x934>
4001936c:	ac 05 80 12 	add  %l6, %l2, %l6                             
 *     RC_OK on success, or error code if error occured (errno set    
 *     appropriately)                                                 
 *                                                                    
 */                                                                   
#define MSDOS_FIND_PRINT 0                                            
int msdos_find_name_in_fat_file(                                      
40019370:	c4 07 bf e4 	ld  [ %fp + -28 ], %g2                         
40019374:	82 38 00 10 	xnor  %g0, %l0, %g1                            
40019378:	82 00 40 02 	add  %g1, %g2, %g1                             
4001937c:	85 28 60 02 	sll  %g1, 2, %g2                               
40019380:	87 28 60 04 	sll  %g1, 4, %g3                               
40019384:	84 20 c0 02 	sub  %g3, %g2, %g2                             
40019388:	82 00 80 01 	add  %g2, %g1, %g1                             
4001938c:	c4 07 a0 50 	ld  [ %fp + 0x50 ], %g2                        
40019390:	a0 10 00 12 	mov  %l2, %l0                                  
            char*       p;                                            
            const char* n;                                            
            int         i;                                            
            char        fill = 0;                                     
                                                                      
            length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;              
40019394:	ba 10 20 20 	mov  0x20, %i5                                 
 *     RC_OK on success, or error code if error occured (errno set    
 *     appropriately)                                                 
 *                                                                    
 */                                                                   
#define MSDOS_FIND_PRINT 0                                            
int msdos_find_name_in_fat_file(                                      
40019398:	a6 00 80 01 	add  %g2, %g1, %l3                             
             * 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)                 
4001939c:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
400193a0:	80 a0 7f ff 	cmp  %g1, -1                                   
400193a4:	22 80 00 96 	be,a   400195fc <msdos_find_name_in_fat_file+0x840>
400193a8:	ee 27 bf f8 	st  %l7, [ %fp + -8 ]                          
            }                                                         
                                                                      
            /*                                                        
             * Clear the entry before loading the data.               
             */                                                       
            memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);     
400193ac:	94 10 20 20 	mov  0x20, %o2                                 
400193b0:	90 10 00 16 	mov  %l6, %o0                                  
400193b4:	40 00 0e d9 	call  4001cf18 <memset>                        
400193b8:	92 10 20 00 	clr  %o1                                       
                                                                      
            *MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;            
                                                                      
            p = entry + 1;                                            
            n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
400193bc:	86 10 00 13 	mov  %l3, %g3                                  
            /*                                                        
             * Clear the entry before loading the data.               
             */                                                       
            memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);     
                                                                      
            *MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;            
400193c0:	f6 2d a0 0d 	stb  %i3, [ %l6 + 0xd ]                        
            p = entry + 1;                                            
            n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
                                                                      
            for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)             
            {                                                         
                if (*n != 0)                                          
400193c4:	de 48 c0 00 	ldsb  [ %g3 ], %o7                             
            memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);     
                                                                      
            *MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;            
                                                                      
            p = entry + 1;                                            
            n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
400193c8:	84 10 20 01 	mov  1, %g2                                    
             */                                                       
            memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);     
                                                                      
            *MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;            
                                                                      
            p = entry + 1;                                            
400193cc:	82 05 a0 01 	add  %l6, 1, %g1                               
        {                                                             
            char*       entry = (char*) fs_info->cl_buf + dir_entry;  
            char*       p;                                            
            const char* n;                                            
            int         i;                                            
            char        fill = 0;                                     
400193d0:	96 10 20 00 	clr  %o3                                       
 *     RC_OK on success, or error code if error occured (errno set    
 *     appropriately)                                                 
 *                                                                    
 */                                                                   
#define MSDOS_FIND_PRINT 0                                            
int msdos_find_name_in_fat_file(                                      
400193d4:	88 00 bf ff 	add  %g2, -1, %g4                              
            p = entry + 1;                                            
            n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
                                                                      
            for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)             
            {                                                         
                if (*n != 0)                                          
400193d8:	80 a3 e0 00 	cmp  %o7, 0                                    
400193dc:	02 80 00 11 	be  40019420 <msdos_find_name_in_fat_file+0x664><== NEVER TAKEN
400193e0:	d4 08 c0 00 	ldub  [ %g3 ], %o2                             
                {                                                     
                    *p = *n;                                          
400193e4:	d4 28 40 00 	stb  %o2, [ %g1 ]                              
                    p [0] = fill;                                     
                    p [1] = fill;                                     
                    fill = 0xff;                                      
                }                                                     
                                                                      
                switch (i)                                            
400193e8:	80 a1 20 04 	cmp  %g4, 4                                    
400193ec:	02 80 00 12 	be  40019434 <msdos_find_name_in_fat_file+0x678>
400193f0:	86 00 e0 01 	inc  %g3                                       
400193f4:	80 a1 20 0a 	cmp  %g4, 0xa                                  
400193f8:	02 80 00 7e 	be  400195f0 <msdos_find_name_in_fat_file+0x834>
400193fc:	80 a0 a0 0d 	cmp  %g2, 0xd                                  
            *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++)             
40019400:	02 80 00 33 	be  400194cc <msdos_find_name_in_fat_file+0x710>
40019404:	82 00 60 02 	add  %g1, 2, %g1                               
40019408:	84 00 a0 01 	inc  %g2                                       
            {                                                         
                if (*n != 0)                                          
4001940c:	de 48 c0 00 	ldsb  [ %g3 ], %o7                             
 *     RC_OK on success, or error code if error occured (errno set    
 *     appropriately)                                                 
 *                                                                    
 */                                                                   
#define MSDOS_FIND_PRINT 0                                            
int msdos_find_name_in_fat_file(                                      
40019410:	88 00 bf ff 	add  %g2, -1, %g4                              
            p = entry + 1;                                            
            n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
                                                                      
            for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)             
            {                                                         
                if (*n != 0)                                          
40019414:	80 a3 e0 00 	cmp  %o7, 0                                    
40019418:	12 bf ff f3 	bne  400193e4 <msdos_find_name_in_fat_file+0x628>
4001941c:	d4 08 c0 00 	ldub  [ %g3 ], %o2                             
                    *p = *n;                                          
                    n++;                                              
                }                                                     
                else                                                  
                {                                                     
                    p [0] = fill;                                     
40019420:	d6 28 40 00 	stb  %o3, [ %g1 ]                              
                    p [1] = fill;                                     
40019424:	d6 28 60 01 	stb  %o3, [ %g1 + 1 ]                          
                    fill = 0xff;                                      
                }                                                     
                                                                      
                switch (i)                                            
40019428:	80 a1 20 04 	cmp  %g4, 4                                    
4001942c:	12 bf ff f2 	bne  400193f4 <msdos_find_name_in_fat_file+0x638>
40019430:	96 10 3f ff 	mov  -1, %o3                                   
                {                                                     
                    case 4:                                           
                        p += 5;                                       
40019434:	82 00 60 05 	add  %g1, 5, %g1                               
40019438:	10 bf ff f5 	b  4001940c <msdos_find_name_in_fat_file+0x650>
4001943c:	84 00 a0 01 	inc  %g2                                       
      lfn_entries = 0;                                                
    else                                                              
      lfn_entries =                                                   
        ((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
                                                                      
    if (FAT_FD_OF_ROOT_DIR(fat_fd) &&                                 
40019440:	80 a0 60 00 	cmp  %g1, 0                                    
40019444:	32 bf fe 7d 	bne,a   40018e38 <msdos_find_name_in_fat_file+0x7c><== NEVER TAKEN
40019448:	e2 15 60 06 	lduh  [ %l5 + 6 ], %l1                         <== NOT EXECUTED
        (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))            
4001944c:	c2 0d 60 0e 	ldub  [ %l5 + 0xe ], %g1                       
      lfn_entries = 0;                                                
    else                                                              
      lfn_entries =                                                   
        ((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
                                                                      
    if (FAT_FD_OF_ROOT_DIR(fat_fd) &&                                 
40019450:	80 88 60 03 	btst  3, %g1                                   
40019454:	22 bf fe 79 	be,a   40018e38 <msdos_find_name_in_fat_file+0x7c>
40019458:	e2 15 60 06 	lduh  [ %l5 + 6 ], %l1                         
        (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))            
        bts2rd = fat_fd->fat_file_size;                               
4001945c:	10 bf fe 77 	b  40018e38 <msdos_find_name_in_fat_file+0x7c> 
40019460:	e2 00 a0 18 	ld  [ %g2 + 0x18 ], %l1                        
                            break;                                    
                        }                                             
                                                                      
                        if (((o + i) >= name_len) || (*p != name[o + i]))
                        {                                             
                            lfn_start.cln = FAT_FILE_SHORT_NAME;      
40019464:	84 10 3f ff 	mov  -1, %g2                                   
40019468:	c4 27 bf f8 	st  %g2, [ %fp + -8 ]                          
                                p += 2;                               
                                break;                                
                        }                                             
                    }                                                 
                                                                      
                    lfn_matched = ((lfn_entry == 0) &&                
4001946c:	80 a6 20 00 	cmp  %i0, 0                                    
40019470:	12 bf ff 52 	bne  400191b8 <msdos_find_name_in_fat_file+0x3fc>
40019474:	84 10 20 00 	clr  %g2                                       
40019478:	10 bf ff 4d 	b  400191ac <msdos_find_name_in_fat_file+0x3f0>
4001947c:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
                if (lfn_start.cln != FAT_FILE_SHORT_NAME)             
                {                                                     
                  rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
                                      lfn_start.cln * bts2rd,         
                                      &lfn_start.cln);                
                  if (rc != RC_OK)                                    
40019480:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40019484:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
                                              &lfn_start.cln);        
                          if (rc != RC_OK)                            
                            return rc;                                
                        }                                             
                                                                      
                        dir_pos->lname.cln = lfn_start.cln;           
40019488:	c4 07 a0 5c 	ld  [ %fp + 0x5c ], %g2                        
                        if (rc != RC_OK)                              
                            return rc;                                
                                                                      
                        dir_pos->sname.ofs = dir_entry;               
                                                                      
                        if (lfn_start.cln != FAT_FILE_SHORT_NAME)     
4001948c:	82 10 3f ff 	mov  -1, %g1                                   
                        }                                             
                                                                      
                        dir_pos->lname.cln = lfn_start.cln;           
                        dir_pos->lname.ofs = lfn_start.ofs;           
                                                                      
                        memcpy(name_dir_entry, entry,                 
40019490:	d0 07 a0 60 	ld  [ %fp + 0x60 ], %o0                        
                                              &lfn_start.cln);        
                          if (rc != RC_OK)                            
                            return rc;                                
                        }                                             
                                                                      
                        dir_pos->lname.cln = lfn_start.cln;           
40019494:	c2 20 a0 08 	st  %g1, [ %g2 + 8 ]                           
                        dir_pos->lname.ofs = lfn_start.ofs;           
40019498:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
                                                                      
                        memcpy(name_dir_entry, entry,                 
4001949c:	92 10 00 1d 	mov  %i5, %o1                                  
                          if (rc != RC_OK)                            
                            return rc;                                
                        }                                             
                                                                      
                        dir_pos->lname.cln = lfn_start.cln;           
                        dir_pos->lname.ofs = lfn_start.ofs;           
400194a0:	c2 20 a0 0c 	st  %g1, [ %g2 + 0xc ]                         
                                                                      
                        memcpy(name_dir_entry, entry,                 
400194a4:	40 00 0e 60 	call  4001ce24 <memcpy>                        
400194a8:	94 10 20 20 	mov  0x20, %o2                                 
400194ac:	81 c7 e0 08 	ret                                            
400194b0:	81 e8 00 00 	restore                                        
                             (empty_space_offset * bts2rd) + empty_space_entry,
                             length, fs_info->cl_buf + empty_space_entry);
        if (ret == -1)                                                
            return ret;                                               
        else if (ret != length)                                       
            rtems_set_errno_and_return_minus_one(EIO);                
400194b4:	40 00 0b b7 	call  4001c390 <__errno>                       <== NOT EXECUTED
400194b8:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
400194bc:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
400194c0:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
400194c4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400194c8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
 *     RC_OK on success, or error code if error occured (errno set    
 *     appropriately)                                                 
 *                                                                    
 */                                                                   
#define MSDOS_FIND_PRINT 0                                            
int msdos_find_name_in_fat_file(                                      
400194cc:	82 26 80 14 	sub  %i2, %l4, %g1                             
                        break;                                        
                }                                                     
            }                                                         
                                                                      
            *MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
            if (lfn_entry == 1)                                       
400194d0:	80 a5 20 01 	cmp  %l4, 1                                    
400194d4:	02 80 00 4c 	be  40019604 <msdos_find_name_in_fat_file+0x848>
400194d8:	c2 2d 80 00 	stb  %g1, [ %l6 ]                              
                *MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
            *MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;                 
400194dc:	c2 0d a0 0b 	ldub  [ %l6 + 0xb ], %g1                       
        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)          
400194e0:	a0 04 20 20 	add  %l0, 0x20, %l0                            
            }                                                         
                                                                      
            *MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
            if (lfn_entry == 1)                                       
                *MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
            *MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;                 
400194e4:	82 10 60 0f 	or  %g1, 0xf, %g1                              
                                                                      
#if MSDOS_FIND_PRINT                                                  
        printf ("MSFS:[10] eso:%li\n", empty_space_offset);           
#endif                                                                
                                                                      
        for (dir_entry = empty_space_entry;                           
400194e8:	80 a4 40 10 	cmp  %l1, %l0                                  
400194ec:	08 80 00 4e 	bleu  40019624 <msdos_find_name_in_fat_file+0x868><== NEVER TAKEN
400194f0:	c2 2d a0 0b 	stb  %g1, [ %l6 + 0xb ]                        
             dir_entry < bts2rd;                                      
             dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)          
        {                                                             
            char*       entry = (char*) fs_info->cl_buf + dir_entry;  
400194f4:	ec 05 60 a0 	ld  [ %l5 + 0xa0 ], %l6                        
            const char* n;                                            
            int         i;                                            
            char        fill = 0;                                     
                                                                      
            length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;              
            lfn_entry++;                                              
400194f8:	a8 05 20 01 	inc  %l4                                       
                                                                      
        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;  
400194fc:	ac 05 80 10 	add  %l6, %l0, %l6                             
            char*       p;                                            
            const char* n;                                            
            int         i;                                            
            char        fill = 0;                                     
                                                                      
            length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;              
40019500:	ba 07 60 20 	add  %i5, 0x20, %i5                            
                    length, lfn_entry);                               
#endif                                                                
            /*                                                        
             * Time to write the short file name entry.               
             */                                                       
            if (lfn_entry == (lfn_entries + 1))                       
40019504:	80 a7 00 14 	cmp  %i4, %l4                                  
40019508:	12 bf ff a5 	bne  4001939c <msdos_find_name_in_fat_file+0x5e0>
4001950c:	a6 04 ff f3 	add  %l3, -13, %l3                             
            {                                                         
                /* get current cluster number */                      
                int rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
40019510:	d8 07 a0 5c 	ld  [ %fp + 0x5c ], %o4                        
40019514:	90 10 00 15 	mov  %l5, %o0                                  
40019518:	92 10 00 19 	mov  %i1, %o1                                  
4001951c:	94 10 20 01 	mov  1, %o2                                    
40019520:	7f ff e5 8a 	call  40012b48 <fat_file_ioctl>                
40019524:	96 10 00 18 	mov  %i0, %o3                                  
                                        empty_space_offset * bts2rd,  
                                        &dir_pos->sname.cln);         
                if (rc != RC_OK)                                      
40019528:	80 a2 20 00 	cmp  %o0, 0                                    
4001952c:	12 bf ff d5 	bne  40019480 <msdos_find_name_in_fat_file+0x6c4><== NEVER TAKEN
40019530:	c4 07 a0 5c 	ld  [ %fp + 0x5c ], %g2                        
                  return rc;                                          
                                                                      
                dir_pos->sname.ofs = dir_entry;                       
                                                                      
                if (lfn_start.cln != FAT_FILE_SHORT_NAME)             
40019534:	d2 07 bf f8 	ld  [ %fp + -8 ], %o1                          
40019538:	80 a2 7f ff 	cmp  %o1, -1                                   
4001953c:	02 80 00 67 	be  400196d8 <msdos_find_name_in_fat_file+0x91c>
40019540:	e0 20 a0 04 	st  %l0, [ %g2 + 4 ]                           
                {                                                     
                  rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
40019544:	7f ff a4 12 	call  4000258c <.umul>                         
40019548:	90 10 00 11 	mov  %l1, %o0                                  
4001954c:	92 10 00 19 	mov  %i1, %o1                                  
40019550:	96 10 00 08 	mov  %o0, %o3                                  
40019554:	94 10 20 01 	mov  1, %o2                                    
40019558:	90 10 00 15 	mov  %l5, %o0                                  
4001955c:	7f ff e5 7b 	call  40012b48 <fat_file_ioctl>                
40019560:	98 07 bf f8 	add  %fp, -8, %o4                              
                                      lfn_start.cln * bts2rd,         
                                      &lfn_start.cln);                
                  if (rc != RC_OK)                                    
40019564:	80 a2 20 00 	cmp  %o0, 0                                    
40019568:	12 bf ff c6 	bne  40019480 <msdos_find_name_in_fat_file+0x6c4><== NEVER TAKEN
4001956c:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
                    return rc;                                        
                }                                                     
                                                                      
                dir_pos->lname.cln = lfn_start.cln;                   
40019570:	c4 07 a0 5c 	ld  [ %fp + 0x5c ], %g2                        
                dir_pos->lname.ofs = lfn_start.ofs;                   
                                                                      
                /* write new node entry */                            
                memcpy (entry, (uint8_t *) name_dir_entry,            
40019574:	d2 07 a0 60 	ld  [ %fp + 0x60 ], %o1                        
                                      &lfn_start.cln);                
                  if (rc != RC_OK)                                    
                    return rc;                                        
                }                                                     
                                                                      
                dir_pos->lname.cln = lfn_start.cln;                   
40019578:	c2 20 a0 08 	st  %g1, [ %g2 + 8 ]                           
                dir_pos->lname.ofs = lfn_start.ofs;                   
4001957c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
                                                                      
                /* write new node entry */                            
                memcpy (entry, (uint8_t *) name_dir_entry,            
40019580:	90 10 00 16 	mov  %l6, %o0                                  
                  if (rc != RC_OK)                                    
                    return rc;                                        
                }                                                     
                                                                      
                dir_pos->lname.cln = lfn_start.cln;                   
                dir_pos->lname.ofs = lfn_start.ofs;                   
40019584:	c2 20 a0 0c 	st  %g1, [ %g2 + 0xc ]                         
                                                                      
                /* write new node entry */                            
                memcpy (entry, (uint8_t *) name_dir_entry,            
40019588:	40 00 0e 27 	call  4001ce24 <memcpy>                        
4001958c:	94 10 20 20 	mov  0x20, %o2                                 
            const char* n;                                            
            int         i;                                            
            char        fill = 0;                                     
                                                                      
            length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;              
            lfn_entry++;                                              
40019590:	a0 10 00 14 	mov  %l4, %l0                                  
40019594:	96 10 00 1d 	mov  %i5, %o3                                  
            if (lfn_entry == 1)                                       
                *MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
            *MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;                 
        }                                                             
                                                                      
        ret = fat_file_write(&fs_info->fat, fat_fd,                   
40019598:	d8 05 60 a0 	ld  [ %l5 + 0xa0 ], %o4                        
4001959c:	90 10 00 15 	mov  %l5, %o0                                  
400195a0:	92 10 00 19 	mov  %i1, %o1                                  
400195a4:	94 06 00 12 	add  %i0, %l2, %o2                             
400195a8:	7f ff e6 32 	call  40012e70 <fat_file_write>                
400195ac:	98 03 00 12 	add  %o4, %l2, %o4                             
                             (empty_space_offset * bts2rd) + empty_space_entry,
                             length, fs_info->cl_buf + empty_space_entry);
        if (ret == -1)                                                
400195b0:	80 a2 3f ff 	cmp  %o0, -1                                   
400195b4:	02 80 00 84 	be  400197c4 <msdos_find_name_in_fat_file+0xa08><== NEVER TAKEN
400195b8:	80 a2 00 1d 	cmp  %o0, %i5                                  
            return ret;                                               
        else if (ret != length)                                       
400195bc:	12 bf ff be 	bne  400194b4 <msdos_find_name_in_fat_file+0x6f8><== NEVER TAKEN
400195c0:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
            rtems_set_errno_and_return_minus_one(EIO);                
                                                                      
        empty_space_offset++;                                         
400195c4:	ae 05 e0 01 	inc  %l7                                       
400195c8:	b0 06 00 11 	add  %i0, %l1, %i0                             
        empty_space_entry = 0;                                        
400195cc:	a4 10 20 00 	clr  %l2                                       
#endif                                                                
                                                                      
    /*                                                                
     * The one more is the short entry.                               
     */                                                               
    while (lfn_entry < (lfn_entries + 1))                             
400195d0:	80 a0 40 10 	cmp  %g1, %l0                                  
400195d4:	16 bf ff 5d 	bge  40019348 <msdos_find_name_in_fat_file+0x58c><== NEVER TAKEN
400195d8:	ba 10 20 01 	mov  1, %i5                                    
        empty_space_offset++;                                         
        empty_space_entry = 0;                                        
        read_cluster = true;                                          
    }                                                                 
                                                                      
    return 0;                                                         
400195dc:	81 c7 e0 08 	ret                                            
400195e0:	91 e8 20 00 	restore  %g0, 0, %o0                           
     * be at the next cluster so we can just make empty_space_offset  
     * that value.                                                    
     */                                                               
    if (empty_space_count == 0)                                       
    {                                                                 
        read_cluster = true;                                          
400195e4:	ba 10 20 01 	mov  1, %i5                                    
        empty_space_offset = dir_offset;                              
        empty_space_entry = 0;                                        
400195e8:	10 bf ff 4a 	b  40019310 <msdos_find_name_in_fat_file+0x554>
400195ec:	a4 10 20 00 	clr  %l2                                       
                {                                                     
                    case 4:                                           
                        p += 5;                                       
                        break;                                        
                    case 10:                                          
                        p += 4;                                       
400195f0:	82 00 60 04 	add  %g1, 4, %g1                               
400195f4:	10 bf ff 86 	b  4001940c <msdos_find_name_in_fat_file+0x650>
400195f8:	84 00 a0 01 	inc  %g2                                       
             * 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;                              
400195fc:	10 bf ff 6c 	b  400193ac <msdos_find_name_in_fat_file+0x5f0>
40019600:	e0 27 bf fc 	st  %l0, [ %fp + -4 ]                          
                }                                                     
            }                                                         
                                                                      
            *MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
            if (lfn_entry == 1)                                       
                *MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
40019604:	82 10 60 40 	or  %g1, 0x40, %g1                             
40019608:	c2 2d 80 00 	stb  %g1, [ %l6 ]                              
            *MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;                 
4001960c:	c2 0d a0 0b 	ldub  [ %l6 + 0xb ], %g1                       
        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)          
40019610:	a0 04 20 20 	add  %l0, 0x20, %l0                            
            }                                                         
                                                                      
            *MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
            if (lfn_entry == 1)                                       
                *MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
            *MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;                 
40019614:	82 10 60 0f 	or  %g1, 0xf, %g1                              
                                                                      
#if MSDOS_FIND_PRINT                                                  
        printf ("MSFS:[10] eso:%li\n", empty_space_offset);           
#endif                                                                
                                                                      
        for (dir_entry = empty_space_entry;                           
40019618:	80 a4 40 10 	cmp  %l1, %l0                                  
4001961c:	18 bf ff b6 	bgu  400194f4 <msdos_find_name_in_fat_file+0x738><== ALWAYS TAKEN
40019620:	c2 2d a0 0b 	stb  %g1, [ %l6 + 0xb ]                        
40019624:	96 10 00 1d 	mov  %i5, %o3                                  <== NOT EXECUTED
40019628:	10 bf ff dc 	b  40019598 <msdos_find_name_in_fat_file+0x7dc><== NOT EXECUTED
4001962c:	a0 10 00 14 	mov  %l4, %l0                                  <== 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(&fs_info->fat, fat_fd,                  
40019630:	90 10 00 15 	mov  %l5, %o0                                  
40019634:	92 10 00 19 	mov  %i1, %o1                                  
40019638:	94 10 00 18 	mov  %i0, %o2                                  
4001963c:	7f ff e4 4f 	call  40012778 <fat_file_read>                 
40019640:	96 10 00 11 	mov  %l1, %o3                                  
                              (empty_space_offset * bts2rd), bts2rd,  
                              fs_info->cl_buf);                       
                                                                      
          if (ret != bts2rd)                                          
40019644:	80 a2 00 11 	cmp  %o0, %l1                                  
40019648:	02 bf ff 43 	be  40019354 <msdos_find_name_in_fat_file+0x598><== NEVER TAKEN
4001964c:	80 a2 20 00 	cmp  %o0, 0                                    
          {                                                           
            if (ret != FAT_EOF)                                       
40019650:	12 80 00 1b 	bne  400196bc <msdos_find_name_in_fat_file+0x900><== NEVER TAKEN
40019654:	90 10 00 15 	mov  %l5, %o0                                  
              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 (&fs_info->fat, fat_fd, false,      
40019658:	92 10 00 19 	mov  %i1, %o1                                  
4001965c:	94 10 20 00 	clr  %o2                                       
40019660:	96 10 00 18 	mov  %i0, %o3                                  
40019664:	7f ff e5 6e 	call  40012c1c <fat_file_extend>               
40019668:	98 07 bf f4 	add  %fp, -12, %o4                             
                                   empty_space_offset * bts2rd, &new_length);
                                                                      
            if (ret != RC_OK)                                         
4001966c:	80 a2 20 00 	cmp  %o0, 0                                    
40019670:	12 80 00 57 	bne  400197cc <msdos_find_name_in_fat_file+0xa10><== NEVER TAKEN
40019674:	c2 07 bf f4 	ld  [ %fp + -12 ], %g1                         
              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))          
40019678:	80 a0 40 18 	cmp  %g1, %i0                                  
4001967c:	12 80 00 10 	bne  400196bc <msdos_find_name_in_fat_file+0x900><== NEVER TAKEN
40019680:	92 10 20 00 	clr  %o1                                       
              rtems_set_errno_and_return_minus_one(EIO);              
                                                                      
            memset(fs_info->cl_buf, 0, bts2rd);                       
40019684:	d0 05 60 a0 	ld  [ %l5 + 0xa0 ], %o0                        
40019688:	40 00 0e 24 	call  4001cf18 <memset>                        
4001968c:	94 10 00 11 	mov  %l1, %o2                                  
                                                                      
            ret = fat_file_write(&fs_info->fat, fat_fd,               
40019690:	d8 05 60 a0 	ld  [ %l5 + 0xa0 ], %o4                        
40019694:	90 10 00 15 	mov  %l5, %o0                                  
40019698:	92 10 00 19 	mov  %i1, %o1                                  
4001969c:	94 10 00 18 	mov  %i0, %o2                                  
400196a0:	7f ff e5 f4 	call  40012e70 <fat_file_write>                
400196a4:	96 10 00 11 	mov  %l1, %o3                                  
                                 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)                                            
400196a8:	80 a2 3f ff 	cmp  %o0, -1                                   
400196ac:	02 80 00 48 	be  400197cc <msdos_find_name_in_fat_file+0xa10><== ALWAYS TAKEN
400196b0:	80 a2 00 11 	cmp  %o0, %l1                                  
              return ret;                                             
            else if (ret != bts2rd)                                   
400196b4:	02 bf ff 29 	be  40019358 <msdos_find_name_in_fat_file+0x59c><== NOT EXECUTED
400196b8:	80 a4 40 12 	cmp  %l1, %l2                                  <== NOT EXECUTED
              rtems_set_errno_and_return_minus_one(EIO);              
400196bc:	40 00 0b 35 	call  4001c390 <__errno>                       <== NOT EXECUTED
400196c0:	01 00 00 00 	nop                                            <== NOT EXECUTED
400196c4:	82 10 20 05 	mov  5, %g1	! 5 <PROM_START+0x5>               <== NOT EXECUTED
400196c8:	84 10 3f ff 	mov  -1, %g2                                   <== NOT EXECUTED
400196cc:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
400196d0:	81 c7 e0 08 	ret                                            
400196d4:	91 e8 00 02 	restore  %g0, %g2, %o0                         
                if (rc != RC_OK)                                      
                  return rc;                                          
                                                                      
                dir_pos->sname.ofs = dir_entry;                       
                                                                      
                if (lfn_start.cln != FAT_FILE_SHORT_NAME)             
400196d8:	10 bf ff a6 	b  40019570 <msdos_find_name_in_fat_file+0x7b4>
400196dc:	82 10 3f ff 	mov  -1, %g1                                   
                /*                                                    
                 * If just looking and there is no more entries in the
                 * directory - return name-not-found                  
                 */                                                   
                if (!create_node)                                     
                    return MSDOS_NAME_NOT_FOUND_ERR;                  
400196e0:	31 00 00 1f 	sethi  %hi(0x7c00), %i0                        
400196e4:	b0 16 21 01 	or  %i0, 0x101, %i0	! 7d01 <PROM_START+0x7d01> 
400196e8:	81 c7 e0 08 	ret                                            
400196ec:	81 e8 00 00 	restore                                        
                    length, lfn_entry);                               
#endif                                                                
            /*                                                        
             * Time to write the short file name entry.               
             */                                                       
            if (lfn_entry == (lfn_entries + 1))                       
400196f0:	a0 10 00 12 	mov  %l2, %l0                                  
            char*       p;                                            
            const char* n;                                            
            int         i;                                            
            char        fill = 0;                                     
                                                                      
            length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;              
400196f4:	10 bf ff 87 	b  40019510 <msdos_find_name_in_fat_file+0x754>
400196f8:	ba 10 20 20 	mov  0x20, %i5                                 
                                                                      
#if MSDOS_FIND_PRINT                                                  
        printf ("MSFS:[10] eso:%li\n", empty_space_offset);           
#endif                                                                
                                                                      
        for (dir_entry = empty_space_entry;                           
400196fc:	96 10 20 00 	clr  %o3                                       <== NOT EXECUTED
40019700:	10 bf ff a6 	b  40019598 <msdos_find_name_in_fat_file+0x7dc><== NOT EXECUTED
40019704:	ba 10 20 00 	clr  %i5                                       <== NOT EXECUTED
     * in this directory.                                             
     */                                                               
    lfn_checksum = 0;                                                 
    if (name_type == MSDOS_NAME_LONG)                                 
    {                                                                 
        int      slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
40019708:	7f ff a3 a1 	call  4000258c <.umul>                         
4001970c:	92 10 00 11 	mov  %l1, %o1                                  
{                                                                     
    static const char* hex = "0123456789ABCDEF";                      
    char* c = MSDOS_DIR_NAME(sfn);                                    
    int   i;                                                          
    for (i = 0; i < 2; i++, c++)                                      
      if ((*c == ' ') || (*c == '.'))                                 
40019710:	c2 07 a0 60 	ld  [ %fp + 0x60 ], %g1                        
     * in this directory.                                             
     */                                                               
    lfn_checksum = 0;                                                 
    if (name_type == MSDOS_NAME_LONG)                                 
    {                                                                 
        int      slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
40019714:	90 02 00 12 	add  %o0, %l2, %o0                             
{                                                                     
    static const char* hex = "0123456789ABCDEF";                      
    char* c = MSDOS_DIR_NAME(sfn);                                    
    int   i;                                                          
    for (i = 0; i < 2; i++, c++)                                      
      if ((*c == ' ') || (*c == '.'))                                 
40019718:	c4 48 40 00 	ldsb  [ %g1 ], %g2                             
     */                                                               
    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;
4001971c:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
     * in this directory.                                             
     */                                                               
    lfn_checksum = 0;                                                 
    if (name_type == MSDOS_NAME_LONG)                                 
    {                                                                 
        int      slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
40019720:	bb 32 20 05 	srl  %o0, 5, %i5                               
                         MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE) + lfn_entries + 1;
40019724:	86 00 60 01 	add  %g1, 1, %g3                               
{                                                                     
    static const char* hex = "0123456789ABCDEF";                      
    char* c = MSDOS_DIR_NAME(sfn);                                    
    int   i;                                                          
    for (i = 0; i < 2; i++, c++)                                      
      if ((*c == ' ') || (*c == '.'))                                 
40019728:	80 a0 a0 2e 	cmp  %g2, 0x2e                                 
4001972c:	02 80 00 05 	be  40019740 <msdos_find_name_in_fat_file+0x984><== NEVER TAKEN
40019730:	ba 00 c0 1d 	add  %g3, %i5, %i5                             
40019734:	80 a0 a0 20 	cmp  %g2, 0x20                                 
40019738:	12 80 00 06 	bne  40019750 <msdos_find_name_in_fat_file+0x994>
4001973c:	c2 07 a0 60 	ld  [ %fp + 0x60 ], %g1                        
        *c = '_';                                                     
40019740:	c2 07 a0 60 	ld  [ %fp + 0x60 ], %g1                        
40019744:	84 10 20 5f 	mov  0x5f, %g2                                 
40019748:	c4 28 40 00 	stb  %g2, [ %g1 ]                              
{                                                                     
    static const char* hex = "0123456789ABCDEF";                      
    char* c = MSDOS_DIR_NAME(sfn);                                    
    int   i;                                                          
    for (i = 0; i < 2; i++, c++)                                      
      if ((*c == ' ') || (*c == '.'))                                 
4001974c:	c2 07 a0 60 	ld  [ %fp + 0x60 ], %g1                        
40019750:	c4 48 60 01 	ldsb  [ %g1 + 1 ], %g2                         
40019754:	80 a0 a0 2e 	cmp  %g2, 0x2e                                 
40019758:	02 80 00 06 	be  40019770 <msdos_find_name_in_fat_file+0x9b4><== NEVER TAKEN
4001975c:	c2 07 a0 60 	ld  [ %fp + 0x60 ], %g1                        
40019760:	80 a0 a0 20 	cmp  %g2, 0x20                                 
40019764:	12 80 00 06 	bne  4001977c <msdos_find_name_in_fat_file+0x9c0>
40019768:	c4 07 a0 60 	ld  [ %fp + 0x60 ], %g2                        
        *c = '_';                                                     
4001976c:	c2 07 a0 60 	ld  [ %fp + 0x60 ], %g1                        
40019770:	84 10 20 5f 	mov  0x5f, %g2                                 
40019774:	c4 28 60 01 	stb  %g2, [ %g1 + 1 ]                          
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 < 2; i++, c++)                                      
40019778:	c4 07 a0 60 	ld  [ %fp + 0x60 ], %g2                        
4001977c:	09 10 00 b2 	sethi  %hi(0x4002c800), %g4                    
40019780:	86 00 a0 02 	add  %g2, 2, %g3                               
40019784:	88 11 20 d8 	or  %g4, 0xd8, %g4                             
40019788:	84 10 20 0c 	mov  0xc, %g2                                  
      if ((*c == ' ') || (*c == '.'))                                 
        *c = '_';                                                     
    for (i = 0; i < 4; i++, c++)                                      
      *c = hex[(num >> ((3 - i) * 4)) & 0xf];                         
4001978c:	83 3f 40 02 	sra  %i5, %g2, %g1                             
40019790:	82 08 60 0f 	and  %g1, 0xf, %g1                             
40019794:	c2 09 00 01 	ldub  [ %g4 + %g1 ], %g1                       
40019798:	84 00 bf fc 	add  %g2, -4, %g2                              
4001979c:	c2 28 c0 00 	stb  %g1, [ %g3 ]                              
    char* c = MSDOS_DIR_NAME(sfn);                                    
    int   i;                                                          
    for (i = 0; i < 2; i++, c++)                                      
      if ((*c == ' ') || (*c == '.'))                                 
        *c = '_';                                                     
    for (i = 0; i < 4; i++, c++)                                      
400197a0:	80 a0 bf fc 	cmp  %g2, -4                                   
400197a4:	12 bf ff fa 	bne  4001978c <msdos_find_name_in_fat_file+0x9d0>
400197a8:	86 00 e0 01 	inc  %g3                                       
      *c = hex[(num >> ((3 - i) * 4)) & 0xf];                         
    *c++ = '~';                                                       
400197ac:	c2 07 a0 60 	ld  [ %fp + 0x60 ], %g1                        
400197b0:	84 10 20 7e 	mov  0x7e, %g2                                 
400197b4:	c4 28 60 06 	stb  %g2, [ %g1 + 6 ]                          
    *c++ = '1';                                                       
400197b8:	84 10 20 31 	mov  0x31, %g2                                 
400197bc:	10 bf fe b8 	b  4001929c <msdos_find_name_in_fat_file+0x4e0>
400197c0:	c4 28 60 07 	stb  %g2, [ %g1 + 7 ]                          
        }                                                             
                                                                      
        ret = fat_file_write(&fs_info->fat, fat_fd,                   
                             (empty_space_offset * bts2rd) + empty_space_entry,
                             length, fs_info->cl_buf + empty_space_entry);
        if (ret == -1)                                                
400197c4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400197c8:	91 e8 3f ff 	restore  %g0, -1, %o0                          <== NOT EXECUTED
400197cc:	10 bf ff c1 	b  400196d0 <msdos_find_name_in_fat_file+0x914>
400197d0:	84 10 00 08 	mov  %o0, %g2                                  
    uint32_t         empty_space_count = 0;                           
    bool             empty_space_found = false;                       
    uint32_t         entries_per_block;                               
    bool             read_cluster = false;                            
                                                                      
    assert(name_len > 0);                                             
400197d4:	11 10 00 b4 	sethi  %hi(0x4002d000), %o0                    <== NOT EXECUTED
400197d8:	15 10 00 b4 	sethi  %hi(0x4002d000), %o2                    <== NOT EXECUTED
400197dc:	17 10 00 b4 	sethi  %hi(0x4002d000), %o3                    <== NOT EXECUTED
400197e0:	90 12 21 00 	or  %o0, 0x100, %o0                            <== NOT EXECUTED
400197e4:	92 10 23 c9 	mov  0x3c9, %o1                                <== NOT EXECUTED
400197e8:	94 12 a1 d0 	or  %o2, 0x1d0, %o2                            <== NOT EXECUTED
400197ec:	7f ff ac 8c 	call  40004a1c <__assert_func>                 <== NOT EXECUTED
400197f0:	96 12 e1 90 	or  %o3, 0x190, %o3                            <== NOT EXECUTED
#endif                                                                
                                                                      
        if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)                  
            rtems_set_errno_and_return_minus_one(EIO);                
                                                                      
        assert(ret == bts2rd);                                        
400197f4:	11 10 00 b4 	sethi  %hi(0x4002d000), %o0                    <== NOT EXECUTED
400197f8:	15 10 00 b4 	sethi  %hi(0x4002d000), %o2                    <== NOT EXECUTED
400197fc:	17 10 00 b4 	sethi  %hi(0x4002d000), %o3                    <== NOT EXECUTED
40019800:	90 12 21 00 	or  %o0, 0x100, %o0                            <== NOT EXECUTED
40019804:	92 10 23 f9 	mov  0x3f9, %o1                                <== NOT EXECUTED
40019808:	94 12 a1 d0 	or  %o2, 0x1d0, %o2                            <== NOT EXECUTED
4001980c:	7f ff ac 84 	call  40004a1c <__assert_func>                 <== NOT EXECUTED
40019810:	96 12 e1 a0 	or  %o3, 0x1a0, %o3                            <== NOT EXECUTED
                                                                      

40019818 <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 ) {
40019818:	9d e3 bf a0 	save  %sp, -96, %sp                            
    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) &&                                 
4001981c:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
40019820:	80 a0 60 01 	cmp  %g1, 1                                    
40019824:	02 80 00 36 	be  400198fc <msdos_find_node_by_cluster_num_in_fat_file+0xe4><== NEVER TAKEN
40019828:	e4 06 20 08 	ld  [ %i0 + 8 ], %l2                           
       (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))             
        bts2rd = fat_fd->fat_file_size;                               
    else                                                              
        bts2rd = fs_info->fat.vol.bpc;                                
4001982c:	e2 14 a0 06 	lduh  [ %l2 + 6 ], %l1                         
40019830:	d8 04 a0 a0 	ld  [ %l2 + 0xa0 ], %o4                        
            if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==                     
                MSDOS_THIS_DIR_ENTRY_EMPTY)                           
                continue;                                             
                                                                      
            /* if get a non-empty entry - compare clusters num */     
            if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)          
40019834:	31 00 00 3f 	sethi  %hi(0xfc00), %i0                        
                                  fs_info->cl_buf)) != FAT_EOF)       
    {                                                                 
        if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )                
            rtems_set_errno_and_return_minus_one( EIO );              
                                                                      
        assert(ret == bts2rd);                                        
40019838:	a6 10 20 00 	clr  %l3                                       
            if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==                     
                MSDOS_THIS_DIR_ENTRY_EMPTY)                           
                continue;                                             
                                                                      
            /* if get a non-empty entry - compare clusters num */     
            if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)          
4001983c:	b0 16 23 ff 	or  %i0, 0x3ff, %i0                            
       (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(&fs_info->fat, fat_fd, j * bts2rd, bts2rd,
40019840:	90 10 00 12 	mov  %l2, %o0                                  
40019844:	92 10 00 19 	mov  %i1, %o1                                  
40019848:	94 10 00 13 	mov  %l3, %o2                                  
4001984c:	7f ff e3 cb 	call  40012778 <fat_file_read>                 
40019850:	96 10 00 11 	mov  %l1, %o3                                  
40019854:	80 a2 20 00 	cmp  %o0, 0                                    
40019858:	02 80 00 25 	be  400198ec <msdos_find_node_by_cluster_num_in_fat_file+0xd4><== NEVER TAKEN
4001985c:	80 a2 20 1f 	cmp  %o0, 0x1f                                 
                                  fs_info->cl_buf)) != FAT_EOF)       
    {                                                                 
        if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )                
40019860:	04 80 00 42 	ble  40019968 <msdos_find_node_by_cluster_num_in_fat_file+0x150><== NEVER TAKEN
40019864:	80 a2 00 11 	cmp  %o0, %l1                                  
            rtems_set_errno_and_return_minus_one( EIO );              
                                                                      
        assert(ret == bts2rd);                                        
40019868:	12 80 00 46 	bne  40019980 <msdos_find_node_by_cluster_num_in_fat_file+0x168><== NEVER TAKEN
4001986c:	a0 10 20 00 	clr  %l0                                       
40019870:	d8 04 a0 a0 	ld  [ %l2 + 0xa0 ], %o4                        
40019874:	ba 10 00 0c 	mov  %o4, %i5                                  
        for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
        {                                                             
            char* entry = (char*) fs_info->cl_buf + i;                
                                                                      
            /* if this and all rest entries are empty - return not-found */
            if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==                     
40019878:	c2 0f 40 00 	ldub  [ %i5 ], %g1                             
4001987c:	80 a0 60 00 	cmp  %g1, 0                                    
40019880:	02 80 00 1b 	be  400198ec <msdos_find_node_by_cluster_num_in_fat_file+0xd4><== NEVER TAKEN
40019884:	80 a0 60 e5 	cmp  %g1, 0xe5                                 
                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)) ==                     
40019888:	22 80 00 14 	be,a   400198d8 <msdos_find_node_by_cluster_num_in_fat_file+0xc0><== NEVER TAKEN
4001988c:	a0 04 20 20 	add  %l0, 0x20, %l0                            <== NOT EXECUTED
                MSDOS_THIS_DIR_ENTRY_EMPTY)                           
                continue;                                             
                                                                      
            /* if get a non-empty entry - compare clusters num */     
            if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)          
40019890:	c2 17 60 1a 	lduh  [ %i5 + 0x1a ], %g1                      
40019894:	c4 17 60 14 	lduh  [ %i5 + 0x14 ], %g2                      
40019898:	83 28 60 10 	sll  %g1, 0x10, %g1                            
4001989c:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
400198a0:	89 30 60 18 	srl  %g1, 0x18, %g4                            
400198a4:	9f 30 a0 18 	srl  %g2, 0x18, %o7                            
400198a8:	87 30 60 08 	srl  %g1, 8, %g3                               
400198ac:	85 30 a0 08 	srl  %g2, 8, %g2                               
400198b0:	86 08 c0 18 	and  %g3, %i0, %g3                             
400198b4:	84 08 80 18 	and  %g2, %i0, %g2                             
400198b8:	86 11 00 03 	or  %g4, %g3, %g3                              
400198bc:	82 13 c0 02 	or  %o7, %g2, %g1                              
400198c0:	83 28 60 10 	sll  %g1, 0x10, %g1                            
400198c4:	82 10 40 03 	or  %g1, %g3, %g1                              
400198c8:	80 a0 40 1a 	cmp  %g1, %i2                                  
400198cc:	22 80 00 16 	be,a   40019924 <msdos_find_node_by_cluster_num_in_fat_file+0x10c>
400198d0:	90 10 00 12 	mov  %l2, %o0                                  
        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)
400198d4:	a0 04 20 20 	add  %l0, 0x20, %l0                            
400198d8:	80 a4 00 11 	cmp  %l0, %l1                                  
400198dc:	0a bf ff e7 	bcs  40019878 <msdos_find_node_by_cluster_num_in_fat_file+0x60><== ALWAYS TAKEN
400198e0:	ba 07 60 20 	add  %i5, 0x20, %i5                            
400198e4:	10 bf ff d7 	b  40019840 <msdos_find_node_by_cluster_num_in_fat_file+0x28><== NOT EXECUTED
400198e8:	a6 04 c0 11 	add  %l3, %l1, %l3                             <== NOT EXECUTED
            char* entry = (char*) fs_info->cl_buf + i;                
                                                                      
            /* if this and all rest entries are empty - return not-found */
            if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==                     
                MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)                  
                return MSDOS_NAME_NOT_FOUND_ERR;                      
400198ec:	31 00 00 1f 	sethi  %hi(0x7c00), %i0                        <== NOT EXECUTED
400198f0:	b0 16 21 01 	or  %i0, 0x101, %i0	! 7d01 <PROM_START+0x7d01> <== NOT EXECUTED
            }                                                         
        }                                                             
        j++;                                                          
    }                                                                 
    return MSDOS_NAME_NOT_FOUND_ERR;                                  
}                                                                     
400198f4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400198f8:	81 e8 00 00 	restore                                        <== 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) &&                                 
400198fc:	c2 06 60 24 	ld  [ %i1 + 0x24 ], %g1                        <== NOT EXECUTED
40019900:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40019904:	32 bf ff cb 	bne,a   40019830 <msdos_find_node_by_cluster_num_in_fat_file+0x18><== NOT EXECUTED
40019908:	e2 14 a0 06 	lduh  [ %l2 + 6 ], %l1                         <== NOT EXECUTED
       (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))             
4001990c:	c2 0c a0 0e 	ldub  [ %l2 + 0xe ], %g1                       <== 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) &&                                 
40019910:	80 88 60 03 	btst  3, %g1                                   <== NOT EXECUTED
40019914:	22 bf ff c7 	be,a   40019830 <msdos_find_node_by_cluster_num_in_fat_file+0x18><== NOT EXECUTED
40019918:	e2 14 a0 06 	lduh  [ %l2 + 6 ], %l1                         <== NOT EXECUTED
       (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))             
        bts2rd = fat_fd->fat_file_size;                               
4001991c:	10 bf ff c5 	b  40019830 <msdos_find_node_by_cluster_num_in_fat_file+0x18><== NOT EXECUTED
40019920:	e2 06 60 18 	ld  [ %i1 + 0x18 ], %l1                        <== NOT EXECUTED
                                                                      
            /* if get a non-empty entry - compare clusters num */     
            if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)          
            {                                                         
                /* on success fill aux structure and copy all 32 bytes */
                rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM, j * bts2rd,
40019924:	92 10 00 19 	mov  %i1, %o1                                  
40019928:	94 10 20 01 	mov  1, %o2                                    
4001992c:	96 10 00 13 	mov  %l3, %o3                                  
40019930:	7f ff e4 86 	call  40012b48 <fat_file_ioctl>                
40019934:	98 10 00 1b 	mov  %i3, %o4                                  
                                    &dir_pos->sname.cln);             
                if (rc != RC_OK)                                      
40019938:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001993c:	12 bf ff ee 	bne  400198f4 <msdos_find_node_by_cluster_num_in_fat_file+0xdc><== NEVER TAKEN
40019940:	82 10 3f ff 	mov  -1, %g1                                   
                    return rc;                                        
                                                                      
                dir_pos->sname.ofs = i;                               
40019944:	e0 26 e0 04 	st  %l0, [ %i3 + 4 ]                           
                dir_pos->lname.cln = FAT_FILE_SHORT_NAME;             
40019948:	c2 26 e0 08 	st  %g1, [ %i3 + 8 ]                           
                dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;             
4001994c:	c2 26 e0 0c 	st  %g1, [ %i3 + 0xc ]                         
                                                                      
                memcpy(dir_entry, entry,                              
40019950:	90 10 00 1c 	mov  %i4, %o0                                  
40019954:	92 10 00 1d 	mov  %i5, %o1                                  
40019958:	40 00 0d 33 	call  4001ce24 <memcpy>                        
4001995c:	94 10 20 20 	mov  0x20, %o2                                 
                       MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);            
                return RC_OK;                                         
40019960:	81 c7 e0 08 	ret                                            
40019964:	81 e8 00 00 	restore                                        
                                                                      
    while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * bts2rd, bts2rd,
                                  fs_info->cl_buf)) != FAT_EOF)       
    {                                                                 
        if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )                
            rtems_set_errno_and_return_minus_one( EIO );              
40019968:	40 00 0a 8a 	call  4001c390 <__errno>                       <== NOT EXECUTED
4001996c:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40019970:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
40019974:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
40019978:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001997c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
        assert(ret == bts2rd);                                        
40019980:	11 10 00 b4 	sethi  %hi(0x4002d000), %o0                    <== NOT EXECUTED
40019984:	15 10 00 b4 	sethi  %hi(0x4002d000), %o2                    <== NOT EXECUTED
40019988:	17 10 00 b4 	sethi  %hi(0x4002d000), %o3                    <== NOT EXECUTED
4001998c:	90 12 21 00 	or  %o0, 0x100, %o0                            <== NOT EXECUTED
40019990:	92 10 26 4e 	mov  0x64e, %o1                                <== NOT EXECUTED
40019994:	94 12 a1 f0 	or  %o2, 0x1f0, %o2                            <== NOT EXECUTED
40019998:	7f ff ac 21 	call  40004a1c <__assert_func>                 <== NOT EXECUTED
4001999c:	96 12 e1 a0 	or  %o3, 0x1a0, %o3                            <== NOT EXECUTED
                                                                      

4000d648 <msdos_format>: ) /*-------------------------------------------------------------------------*\ | Return Value: | | 0, if success, -1 and errno if failed | \*=========================================================================*/ {
4000d648:	9d e3 bc d0 	save  %sp, -816, %sp                           <== NOT EXECUTED
  msdos_format_param_t fmt_params;                                    
                                                                      
  /*                                                                  
   * open device for writing                                          
   */                                                                 
  msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
4000d64c:	92 10 20 02 	mov  2, %o1                                    <== NOT EXECUTED
4000d650:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
4000d654:	15 10 00 b2 	sethi  %hi(0x4002c800), %o2                    <== NOT EXECUTED
4000d658:	7f ff ff 41 	call  4000d35c <msdos_format_printf>           <== NOT EXECUTED
4000d65c:	94 12 a2 d8 	or  %o2, 0x2d8, %o2	! 4002cad8 <_CPU_Trap_slot_template+0x68><== NOT EXECUTED
  fd = open(devname, O_RDWR);                                         
4000d660:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4000d664:	7f ff e0 ba 	call  4000594c <open>                          <== NOT EXECUTED
4000d668:	92 10 20 02 	mov  2, %o1                                    <== NOT EXECUTED
  if (fd == -1) {                                                     
4000d66c:	80 a2 3f ff 	cmp  %o0, -1                                   <== NOT EXECUTED
4000d670:	02 80 01 88 	be  4000dc90 <msdos_format+0x648>              <== NOT EXECUTED
4000d674:	b6 10 00 08 	mov  %o0, %i3                                  <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * sanity check on device                                           
   */                                                                 
  msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,           
4000d678:	96 10 00 18 	mov  %i0, %o3                                  <== NOT EXECUTED
4000d67c:	92 10 20 02 	mov  2, %o1                                    <== NOT EXECUTED
4000d680:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
4000d684:	15 10 00 b2 	sethi  %hi(0x4002c800), %o2                    <== NOT EXECUTED
4000d688:	7f ff ff 35 	call  4000d35c <msdos_format_printf>           <== NOT EXECUTED
4000d68c:	94 12 a3 b0 	or  %o2, 0x3b0, %o2	! 4002cbb0 <_CPU_Trap_slot_template+0x140><== NOT EXECUTED
                       "stat check: %s\n", devname);                  
  if (ret_val == 0) {                                                 
    ret_val = fstat(fd, &stat_buf);                                   
4000d690:	92 07 bd 60 	add  %fp, -672, %o1                            <== NOT EXECUTED
4000d694:	7f ff dd 70 	call  40004c54 <fstat>                         <== NOT EXECUTED
4000d698:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
  }                                                                   
                                                                      
  msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,             
4000d69c:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
   * sanity check on device                                           
   */                                                                 
  msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,           
                       "stat check: %s\n", devname);                  
  if (ret_val == 0) {                                                 
    ret_val = fstat(fd, &stat_buf);                                   
4000d6a0:	ae 10 00 08 	mov  %o0, %l7                                  <== NOT EXECUTED
  }                                                                   
                                                                      
  msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,             
4000d6a4:	96 10 00 18 	mov  %i0, %o3                                  <== NOT EXECUTED
4000d6a8:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
4000d6ac:	15 10 00 b2 	sethi  %hi(0x4002c800), %o2                    <== NOT EXECUTED
4000d6b0:	7f ff ff 2b 	call  4000d35c <msdos_format_printf>           <== NOT EXECUTED
4000d6b4:	94 12 a3 c0 	or  %o2, 0x3c0, %o2	! 4002cbc0 <_CPU_Trap_slot_template+0x150><== NOT EXECUTED
                       "formating: %s\n", devname);                   
  /* rtems feature: no block devices, all are character devices */    
  if ((ret_val == 0) && (!S_ISBLK(stat_buf.st_mode))) {               
4000d6b8:	80 a5 e0 00 	cmp  %l7, 0                                    <== NOT EXECUTED
4000d6bc:	12 80 00 0c 	bne  4000d6ec <msdos_format+0xa4>              <== NOT EXECUTED
4000d6c0:	c4 07 bd 6c 	ld  [ %fp + -660 ], %g2                        <== NOT EXECUTED
4000d6c4:	03 00 00 3c 	sethi  %hi(0xf000), %g1                        <== NOT EXECUTED
4000d6c8:	84 08 80 01 	and  %g2, %g1, %g2                             <== NOT EXECUTED
4000d6cc:	03 00 00 18 	sethi  %hi(0x6000), %g1                        <== NOT EXECUTED
4000d6d0:	80 a0 80 01 	cmp  %g2, %g1                                  <== NOT EXECUTED
4000d6d4:	02 80 00 13 	be  4000d720 <msdos_format+0xd8>               <== NOT EXECUTED
4000d6d8:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
    errno = ENOTTY;                                                   
4000d6dc:	40 00 3b 2d 	call  4001c390 <__errno>                       <== NOT EXECUTED
4000d6e0:	ae 10 3f ff 	mov  -1, %l7                                   <== NOT EXECUTED
4000d6e4:	82 10 20 19 	mov  0x19, %g1                                 <== NOT EXECUTED
4000d6e8:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4000d6ec:	80 a0 00 19 	cmp  %g0, %i1                                  <== NOT EXECUTED
4000d6f0:	82 40 20 00 	addx  %g0, 0, %g1                              <== NOT EXECUTED
4000d6f4:	c2 2f bd 57 	stb  %g1, [ %fp + -681 ]                       <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * create master boot record                                        
   */                                                                 
  if (ret_val == 0) {                                                 
4000d6f8:	80 a5 e0 00 	cmp  %l7, 0                                    <== NOT EXECUTED
4000d6fc:	02 80 00 7d 	be  4000d8f0 <msdos_format+0x2a8>              <== NOT EXECUTED
4000d700:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
  /*                                                                  
   * cleanup:                                                         
   * sync and unlock disk                                             
   * free any data structures (not needed now)                        
   */                                                                 
  if (fd != -1) {                                                     
4000d704:	80 a6 ff ff 	cmp  %i3, -1                                   <== NOT EXECUTED
4000d708:	02 80 00 04 	be  4000d718 <msdos_format+0xd0>               <== NOT EXECUTED
4000d70c:	01 00 00 00 	nop                                            <== NOT EXECUTED
    close(fd);                                                        
4000d710:	7f ff dd 05 	call  40004b24 <close>                         <== NOT EXECUTED
4000d714:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
  }                                                                   
                                                                      
  return ret_val;                                                     
}                                                                     
4000d718:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000d71c:	91 e8 00 17 	restore  %g0, %l7, %o0                         <== NOT EXECUTED
  uint64_t total_size = 0;                                            
  uint32_t data_clusters_cnt;                                         
  uint8_t  iteration_cnt = 0;                                         
  uint8_t  fat_type = UINT8_MAX;                                      
                                                                      
  memset(fmt_params,0,sizeof(*fmt_params));                           
4000d720:	94 10 20 54 	mov  0x54, %o2                                 <== NOT EXECUTED
4000d724:	40 00 3d fd 	call  4001cf18 <memset>                        <== NOT EXECUTED
4000d728:	90 07 bd ac 	add  %fp, -596, %o0                            <== NOT EXECUTED
static inline int rtems_disk_fd_get_media_block_size(                 
  int fd,                                                             
  uint32_t *media_block_size                                          
)                                                                     
{                                                                     
  return ioctl(fd, RTEMS_BLKIO_GETMEDIABLKSIZE, media_block_size);    
4000d72c:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
4000d730:	3b 10 01 10 	sethi  %hi(0x40044000), %i5                    <== NOT EXECUTED
4000d734:	94 07 bd ac 	add  %fp, -596, %o2                            <== NOT EXECUTED
4000d738:	40 00 1e 51 	call  4001507c <ioctl>                         <== NOT EXECUTED
4000d73c:	92 17 62 02 	or  %i5, 0x202, %o1                            <== NOT EXECUTED
   * At least one thing we don't have to magically guess...           
   */                                                                 
  if (ret_val == 0) {                                                 
    ret_val = rtems_disk_fd_get_media_block_size(fd, &fmt_params->bytes_per_sector);
  }                                                                   
  if (ret_val == 0) {                                                 
4000d740:	84 92 20 00 	orcc  %o0, 0, %g2                              <== NOT EXECUTED
4000d744:	02 80 01 62 	be  4000dccc <msdos_format+0x684>              <== NOT EXECUTED
4000d748:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
4000d74c:	ea 07 bd b0 	ld  [ %fp + -592 ], %l5                        <== NOT EXECUTED
4000d750:	80 a0 00 19 	cmp  %g0, %i1                                  <== NOT EXECUTED
4000d754:	82 40 20 00 	addx  %g0, 0, %g1                              <== NOT EXECUTED
4000d758:	c2 2f bd 57 	stb  %g1, [ %fp + -681 ]                       <== NOT EXECUTED
      }                                                               
                                                                      
      ++iteration_cnt;                                                
    }                                                                 
  }                                                                   
  if ( fmt_params->totl_sector_cnt == 0 )                             
4000d75c:	80 a5 60 00 	cmp  %l5, 0                                    <== NOT EXECUTED
4000d760:	02 80 01 c7 	be  4000de7c <msdos_format+0x834>              <== NOT EXECUTED
4000d764:	01 00 00 00 	nop                                            <== NOT EXECUTED
4000d768:	ae 10 00 02 	mov  %g2, %l7                                  <== NOT EXECUTED
4000d76c:	fa 07 bd b4 	ld  [ %fp + -588 ], %i5                        <== NOT EXECUTED
		       sizeof(valid_media_codes))) {                                
	ret_val = -1;                                                        
	errno = EINVAL;                                                      
      }                                                               
      else {                                                          
	fmt_params->media_code = rqdata->media;                              
4000d770:	b8 10 20 00 	clr  %i4                                       <== NOT EXECUTED
  }                                                                   
  /*                                                                  
   * determine location and size of root directory                    
   * for formatting                                                   
   */                                                                 
  if (fmt_params->root_dir_sectors > 0) {                             
4000d774:	f4 07 bd c8 	ld  [ %fp + -568 ], %i2                        <== NOT EXECUTED
    fmt_params->root_dir_start_sec =                                  
      fmt_params->rsvd_sector_cnt                                     
      + (fmt_params-> fat_num*fmt_params->sectors_per_fat);           
4000d778:	d0 0f bd dc 	ldub  [ %fp + -548 ], %o0                      <== NOT EXECUTED
  }                                                                   
  /*                                                                  
   * determine location and size of root directory                    
   * for formatting                                                   
   */                                                                 
  if (fmt_params->root_dir_sectors > 0) {                             
4000d77c:	80 a6 a0 00 	cmp  %i2, 0                                    <== NOT EXECUTED
4000d780:	02 80 01 c4 	be  4000de90 <msdos_format+0x848>              <== NOT EXECUTED
4000d784:	d2 07 bd bc 	ld  [ %fp + -580 ], %o1                        <== NOT EXECUTED
    fmt_params->root_dir_start_sec =                                  
      fmt_params->rsvd_sector_cnt                                     
      + (fmt_params-> fat_num*fmt_params->sectors_per_fat);           
4000d788:	7f ff d3 81 	call  4000258c <.umul>                         <== NOT EXECUTED
4000d78c:	01 00 00 00 	nop                                            <== NOT EXECUTED
    fmt_params->root_dir_fmt_sec_cnt = fmt_params->root_dir_sectors;  
4000d790:	f4 27 bd d0 	st  %i2, [ %fp + -560 ]                        <== NOT EXECUTED
   * for formatting                                                   
   */                                                                 
  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);           
4000d794:	90 07 40 08 	add  %i5, %o0, %o0                             <== NOT EXECUTED
  /*                                                                  
   * determine location and size of root directory                    
   * for formatting                                                   
   */                                                                 
  if (fmt_params->root_dir_sectors > 0) {                             
    fmt_params->root_dir_start_sec =                                  
4000d798:	d0 27 bd cc 	st  %o0, [ %fp + -564 ]                        <== NOT EXECUTED
    fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
  }                                                                   
  /*                                                                  
   * determine usable OEMName                                         
   */                                                                 
  if (ret_val == 0) {                                                 
4000d79c:	80 a5 e0 00 	cmp  %l7, 0                                    <== NOT EXECUTED
4000d7a0:	12 80 00 46 	bne  4000d8b8 <msdos_format+0x270>             <== NOT EXECUTED
4000d7a4:	80 8f 20 ff 	btst  0xff, %i4                                <== NOT EXECUTED
      const char *from;                                               
      char        *to = fmt_params->OEMName;                          
      int          cnt;                                               
      from = "RTEMS"; /* default: make "from" point to OS Name */     
    if ((rqdata != NULL) &&                                           
4000d7a8:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
4000d7ac:	02 80 03 8d 	be  4000e5e0 <msdos_format+0xf98>              <== NOT EXECUTED
4000d7b0:	09 10 00 b2 	sethi  %hi(0x4002c800), %g4                    <== NOT EXECUTED
	(rqdata->OEMName != NULL)) {                                         
4000d7b4:	c8 06 40 00 	ld  [ %i1 ], %g4                               <== 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) &&                                           
4000d7b8:	80 a1 20 00 	cmp  %g4, 0                                    <== NOT EXECUTED
4000d7bc:	22 80 03 89 	be,a   4000e5e0 <msdos_format+0xf98>           <== NOT EXECUTED
4000d7c0:	09 10 00 b2 	sethi  %hi(0x4002c800), %g4                    <== NOT EXECUTED
4000d7c4:	03 10 00 b6 	sethi  %hi(0x4002d800), %g1                    <== NOT EXECUTED
      else {                                                          
	fmt_params->media_code = rqdata->media;                              
      }                                                               
    }                                                                 
    else {                                                            
      fmt_params->media_code = FAT_BR_MEDIA_FIXED;                    
4000d7c8:	84 10 20 08 	mov  8, %g2                                    <== NOT EXECUTED
4000d7cc:	f4 00 63 44 	ld  [ %g1 + 0x344 ], %i2                       <== NOT EXECUTED
	/*                                                                   
	 * non-printable character in given name, so keep stuck              
	 * at that character and replace all following characters            
	 * with a ' '                                                        
	 */                                                                  
	*to++=' ';                                                           
4000d7d0:	b0 10 20 20 	mov  0x20, %i0                                 <== NOT EXECUTED
  /*                                                                  
   * determine usable OEMName                                         
   */                                                                 
  if (ret_val == 0) {                                                 
      const char *from;                                               
      char        *to = fmt_params->OEMName;                          
4000d7d4:	10 80 00 07 	b  4000d7f0 <msdos_format+0x1a8>               <== NOT EXECUTED
4000d7d8:	82 07 bd df 	add  %fp, -545, %g1                            <== NOT EXECUTED
    }                                                                 
    for (cnt = 0;                                                     
	 cnt < (sizeof(fmt_params->OEMName)-1);                              
	 cnt++) {                                                            
      if (isprint((unsigned char)*from)) {                            
	*to++ = *from++;                                                     
4000d7dc:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
	 * at that character and replace all following characters            
	 * with a ' '                                                        
	 */                                                                  
	*to++=' ';                                                           
      }                                                               
      *to = '\0';                                                     
4000d7e0:	c0 28 40 00 	clrb  [ %g1 ]                                  <== NOT EXECUTED
      from = "RTEMS"; /* default: make "from" point to OS Name */     
    if ((rqdata != NULL) &&                                           
	(rqdata->OEMName != NULL)) {                                         
      from = rqdata->OEMName;                                         
    }                                                                 
    for (cnt = 0;                                                     
4000d7e4:	84 80 bf ff 	addcc  %g2, -1, %g2                            <== NOT EXECUTED
4000d7e8:	02 80 00 0e 	be  4000d820 <msdos_format+0x1d8>              <== NOT EXECUTED
4000d7ec:	88 01 20 01 	inc  %g4                                       <== NOT EXECUTED
	 cnt < (sizeof(fmt_params->OEMName)-1);                              
	 cnt++) {                                                            
      if (isprint((unsigned char)*from)) {                            
4000d7f0:	c6 09 00 00 	ldub  [ %g4 ], %g3                             <== NOT EXECUTED
4000d7f4:	ba 08 e0 ff 	and  %g3, 0xff, %i5                            <== NOT EXECUTED
4000d7f8:	ba 06 80 1d 	add  %i2, %i5, %i5                             <== NOT EXECUTED
4000d7fc:	fa 4f 60 01 	ldsb  [ %i5 + 1 ], %i5                         <== NOT EXECUTED
4000d800:	80 8f 60 97 	btst  0x97, %i5                                <== NOT EXECUTED
4000d804:	32 bf ff f6 	bne,a   4000d7dc <msdos_format+0x194>          <== NOT EXECUTED
4000d808:	c6 28 40 00 	stb  %g3, [ %g1 ]                              <== NOT EXECUTED
	/*                                                                   
	 * non-printable character in given name, so keep stuck              
	 * at that character and replace all following characters            
	 * with a ' '                                                        
	 */                                                                  
	*to++=' ';                                                           
4000d80c:	f0 28 40 00 	stb  %i0, [ %g1 ]                              <== NOT EXECUTED
4000d810:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
      from = "RTEMS"; /* default: make "from" point to OS Name */     
    if ((rqdata != NULL) &&                                           
	(rqdata->OEMName != NULL)) {                                         
      from = rqdata->OEMName;                                         
    }                                                                 
    for (cnt = 0;                                                     
4000d814:	84 80 bf ff 	addcc  %g2, -1, %g2                            <== NOT EXECUTED
4000d818:	12 bf ff f6 	bne  4000d7f0 <msdos_format+0x1a8>             <== NOT EXECUTED
4000d81c:	c0 28 40 00 	clrb  [ %g1 ]                                  <== 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) &&                                           
4000d820:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
4000d824:	02 80 03 71 	be  4000e5e8 <msdos_format+0xfa0>              <== NOT EXECUTED
4000d828:	09 10 00 b1 	sethi  %hi(0x4002c400), %g4                    <== NOT EXECUTED
	(rqdata->VolLabel != NULL)) {                                        
4000d82c:	c8 06 60 04 	ld  [ %i1 + 4 ], %g4                           <== 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) &&                                           
4000d830:	80 a1 20 00 	cmp  %g4, 0                                    <== NOT EXECUTED
4000d834:	22 80 03 6d 	be,a   4000e5e8 <msdos_format+0xfa0>           <== NOT EXECUTED
4000d838:	09 10 00 b1 	sethi  %hi(0x4002c400), %g4                    <== NOT EXECUTED
	(rqdata->VolLabel != NULL)) {                                        
      from = rqdata->VolLabel;                                        
      fmt_params->VolLabel_present = true;                            
4000d83c:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
4000d840:	c2 2f bd f4 	stb  %g1, [ %fp + -524 ]                       <== NOT EXECUTED
      else {                                                          
	fmt_params->media_code = rqdata->media;                              
      }                                                               
    }                                                                 
    else {                                                            
      fmt_params->media_code = FAT_BR_MEDIA_FIXED;                    
4000d844:	84 10 20 0b 	mov  0xb, %g2                                  <== NOT EXECUTED
  /*                                                                  
   * determine usable Volume Label                                    
   */                                                                 
  if (ret_val == 0) {                                                 
      const char *from;                                               
      char        *to = fmt_params->VolLabel;                         
4000d848:	82 07 bd e8 	add  %fp, -536, %g1                            <== NOT EXECUTED
	/*                                                                   
	 * non-printable character in given name, so keep stuck              
	 * at that character and replace all following characters            
	 * with a ' '                                                        
	 */                                                                  
	*to++=' ';                                                           
4000d84c:	10 80 00 07 	b  4000d868 <msdos_format+0x220>               <== NOT EXECUTED
4000d850:	b0 10 20 20 	mov  0x20, %i0                                 <== NOT EXECUTED
    }                                                                 
    for (cnt = 0;                                                     
	 cnt < (sizeof(fmt_params->VolLabel)-1);                             
	 cnt++) {                                                            
      if (isprint((unsigned char)*from)) {                            
	*to++ = *from++;                                                     
4000d854:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
	 * at that character and replace all following characters            
	 * with a ' '                                                        
	 */                                                                  
	*to++=' ';                                                           
      }                                                               
      *to = '\0';                                                     
4000d858:	c0 28 40 00 	clrb  [ %g1 ]                                  <== NOT EXECUTED
    if ((rqdata != NULL) &&                                           
	(rqdata->VolLabel != NULL)) {                                        
      from = rqdata->VolLabel;                                        
      fmt_params->VolLabel_present = true;                            
    }                                                                 
    for (cnt = 0;                                                     
4000d85c:	84 80 bf ff 	addcc  %g2, -1, %g2                            <== NOT EXECUTED
4000d860:	02 80 00 0e 	be  4000d898 <msdos_format+0x250>              <== NOT EXECUTED
4000d864:	88 01 20 01 	inc  %g4                                       <== NOT EXECUTED
	 cnt < (sizeof(fmt_params->VolLabel)-1);                             
	 cnt++) {                                                            
      if (isprint((unsigned char)*from)) {                            
4000d868:	c6 09 00 00 	ldub  [ %g4 ], %g3                             <== NOT EXECUTED
4000d86c:	ba 08 e0 ff 	and  %g3, 0xff, %i5                            <== NOT EXECUTED
4000d870:	ba 06 80 1d 	add  %i2, %i5, %i5                             <== NOT EXECUTED
4000d874:	fa 4f 60 01 	ldsb  [ %i5 + 1 ], %i5                         <== NOT EXECUTED
4000d878:	80 8f 60 97 	btst  0x97, %i5                                <== NOT EXECUTED
4000d87c:	32 bf ff f6 	bne,a   4000d854 <msdos_format+0x20c>          <== NOT EXECUTED
4000d880:	c6 28 40 00 	stb  %g3, [ %g1 ]                              <== NOT EXECUTED
	/*                                                                   
	 * non-printable character in given name, so keep stuck              
	 * at that character and replace all following characters            
	 * with a ' '                                                        
	 */                                                                  
	*to++=' ';                                                           
4000d884:	f0 28 40 00 	stb  %i0, [ %g1 ]                              <== NOT EXECUTED
4000d888:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
    if ((rqdata != NULL) &&                                           
	(rqdata->VolLabel != NULL)) {                                        
      from = rqdata->VolLabel;                                        
      fmt_params->VolLabel_present = true;                            
    }                                                                 
    for (cnt = 0;                                                     
4000d88c:	84 80 bf ff 	addcc  %g2, -1, %g2                            <== NOT EXECUTED
4000d890:	12 bf ff f6 	bne  4000d868 <msdos_format+0x220>             <== NOT EXECUTED
4000d894:	c0 28 40 00 	clrb  [ %g1 ]                                  <== NOT EXECUTED
{                                                                     
  int ret_val = 0;                                                    
  int rc;                                                             
  struct timeval time_value;                                          
                                                                      
  rc = rtems_clock_get_tod_timeval(&time_value);                      
4000d898:	40 00 22 51 	call  400161dc <rtems_clock_get_tod_timeval>   <== NOT EXECUTED
4000d89c:	90 07 be 00 	add  %fp, -512, %o0                            <== NOT EXECUTED
  if (rc == RTEMS_SUCCESSFUL) {                                       
4000d8a0:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4000d8a4:	12 80 03 3d 	bne  4000e598 <msdos_format+0xf50>             <== NOT EXECUTED
4000d8a8:	c2 07 be 00 	ld  [ %fp + -512 ], %g1                        <== NOT EXECUTED
    *volid_ptr = time_value.tv_sec + time_value.tv_sec;               
4000d8ac:	83 28 60 01 	sll  %g1, 1, %g1                               <== NOT EXECUTED
4000d8b0:	c2 27 bd f8 	st  %g1, [ %fp + -520 ]                        <== NOT EXECUTED
    ret_val = msdos_format_determine_fmt_params(fd,rqdata,&fmt_params);
  }                                                                   
  /*                                                                  
   * if requested, write whole disk/partition with 0xe5               
   */                                                                 
  if ((ret_val == 0) &&                                               
4000d8b4:	80 8f 20 ff 	btst  0xff, %i4                                <== NOT EXECUTED
4000d8b8:	02 bf ff 91 	be  4000d6fc <msdos_format+0xb4>               <== NOT EXECUTED
4000d8bc:	80 a5 e0 00 	cmp  %l7, 0                                    <== NOT EXECUTED
      (rqdata != NULL) &&                                             
4000d8c0:	c2 0e 60 15 	ldub  [ %i1 + 0x15 ], %g1                      <== NOT EXECUTED
4000d8c4:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4000d8c8:	12 80 00 0a 	bne  4000d8f0 <msdos_format+0x2a8>             <== NOT EXECUTED
4000d8cc:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
      !(rqdata->quick_format)) {                                      
    ret_val = msdos_format_fill_sectors                               
4000d8d0:	d6 07 bd b0 	ld  [ %fp + -592 ], %o3                        <== NOT EXECUTED
4000d8d4:	d8 07 bd ac 	ld  [ %fp + -596 ], %o4                        <== NOT EXECUTED
4000d8d8:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
4000d8dc:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
4000d8e0:	7f ff fe cc 	call  4000d410 <msdos_format_fill_sectors>     <== NOT EXECUTED
4000d8e4:	9a 10 3f e5 	mov  -27, %o5                                  <== NOT EXECUTED
4000d8e8:	10 bf ff 84 	b  4000d6f8 <msdos_format+0xb0>                <== NOT EXECUTED
4000d8ec:	ae 10 00 08 	mov  %o0, %l7                                  <== NOT EXECUTED
   */                                                                 
  if (ret_val == 0) {                                                 
    /*                                                                
     * Read the current MBR to obtain the partition table.            
     */                                                               
    msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,         
4000d8f0:	92 10 20 02 	mov  2, %o1                                    <== NOT EXECUTED
4000d8f4:	15 10 00 b2 	sethi  %hi(0x4002c800), %o2                    <== NOT EXECUTED
4000d8f8:	7f ff fe 99 	call  4000d35c <msdos_format_printf>           <== NOT EXECUTED
4000d8fc:	94 12 a3 60 	or  %o2, 0x360, %o2	! 4002cb60 <_CPU_Trap_slot_template+0xf0><== 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)) {     
4000d900:	90 10 00 1b 	mov  %i3, %o0                                  <== 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,                               
4000d904:	fa 07 bd ac 	ld  [ %fp + -596 ], %i5                        <== 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)) {     
4000d908:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4000d90c:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
4000d910:	40 00 1d fc 	call  40015100 <lseek>                         <== NOT EXECUTED
4000d914:	96 10 20 00 	clr  %o3                                       <== NOT EXECUTED
4000d918:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4000d91c:	06 80 01 16 	bl  4000dd74 <msdos_format+0x72c>              <== NOT EXECUTED
4000d920:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
    ret_val = -1;                                                     
  }                                                                   
  if (ret_val == 0) {                                                 
    if (0 > read(fd,buffer,sector_size)) {                            
4000d924:	92 07 be 00 	add  %fp, -512, %o1                            <== NOT EXECUTED
4000d928:	40 00 1e cc 	call  40015458 <read>                          <== NOT EXECUTED
4000d92c:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
4000d930:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4000d934:	06 80 01 10 	bl  4000dd74 <msdos_format+0x72c>              <== NOT EXECUTED
4000d938:	90 10 00 19 	mov  %i1, %o0                                  <== 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,       
4000d93c:	92 10 20 02 	mov  2, %o1                                    <== NOT EXECUTED
4000d940:	15 10 00 b2 	sethi  %hi(0x4002c800), %o2                    <== NOT EXECUTED
4000d944:	7f ff fe 86 	call  4000d35c <msdos_format_printf>           <== NOT EXECUTED
4000d948:	94 12 a3 d0 	or  %o2, 0x3d0, %o2	! 4002cbd0 <_CPU_Trap_slot_template+0x160><== 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) {                        
4000d94c:	c2 07 bd b0 	ld  [ %fp + -592 ], %g1                        <== NOT EXECUTED
4000d950:	05 00 00 3f 	sethi  %hi(0xfc00), %g2                        <== NOT EXECUTED
4000d954:	84 10 a3 ff 	or  %g2, 0x3ff, %g2	! ffff <PROM_START+0xffff> <== NOT EXECUTED
4000d958:	80 a0 40 02 	cmp  %g1, %g2                                  <== NOT EXECUTED
4000d95c:	08 80 02 f9 	bleu  4000e540 <msdos_format+0xef8>            <== NOT EXECUTED
4000d960:	b0 10 00 01 	mov  %g1, %i0                                  <== NOT EXECUTED
4000d964:	84 08 40 02 	and  %g1, %g2, %g2                             <== NOT EXECUTED
4000d968:	a8 10 00 01 	mov  %g1, %l4                                  <== NOT EXECUTED
4000d96c:	a7 30 a0 08 	srl  %g2, 8, %l3                               <== NOT EXECUTED
4000d970:	a5 30 60 10 	srl  %g1, 0x10, %l2                            <== NOT EXECUTED
4000d974:	a3 30 60 18 	srl  %g1, 0x18, %l1                            <== NOT EXECUTED
4000d978:	a0 10 20 00 	clr  %l0                                       <== NOT EXECUTED
4000d97c:	b0 10 20 00 	clr  %i0                                       <== 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);                     
4000d980:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4000d984:	94 10 21 be 	mov  0x1be, %o2                                <== NOT EXECUTED
4000d988:	40 00 3d 64 	call  4001cf18 <memset>                        <== NOT EXECUTED
4000d98c:	90 07 be 00 	add  %fp, -512, %o0                            <== NOT EXECUTED
   * with 0xEB,....                                                   
   */                                                                 
  /*                                                                  
   * fill OEMName                                                     
   */                                                                 
  memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),                                
4000d990:	90 07 be 03 	add  %fp, -509, %o0                            <== 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,
4000d994:	c0 37 bf fe 	clrh  [ %fp + -2 ]                             <== NOT EXECUTED
   * with 0xEB,....                                                   
   */                                                                 
  /*                                                                  
   * fill OEMName                                                     
   */                                                                 
  memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),                                
4000d998:	92 07 bd df 	add  %fp, -545, %o1                            <== NOT EXECUTED
4000d99c:	40 00 3d 22 	call  4001ce24 <memcpy>                        <== NOT EXECUTED
4000d9a0:	94 10 20 08 	mov  8, %o2                                    <== 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);
4000d9a4:	c4 07 bd c4 	ld  [ %fp + -572 ], %g2                        <== 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); 
4000d9a8:	c8 07 bd ac 	ld  [ %fp + -596 ], %g4                        <== 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);
4000d9ac:	83 30 a0 08 	srl  %g2, 8, %g1                               <== NOT EXECUTED
4000d9b0:	c2 2f be 12 	stb  %g1, [ %fp + -494 ]                       <== NOT EXECUTED
  FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);          
  FAT_SET_BR_MEDIA(mbr               , fmt_params->media_code);       
4000d9b4:	c2 0f bd dd 	ldub  [ %fp + -547 ], %g1                      <== 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);  
4000d9b8:	c6 07 bd b4 	ld  [ %fp + -588 ], %g3                        <== 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); 
4000d9bc:	9b 31 20 08 	srl  %g4, 8, %o5                               <== NOT EXECUTED
4000d9c0:	c8 2f be 0b 	stb  %g4, [ %fp + -501 ]                       <== NOT EXECUTED
  FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
4000d9c4:	c8 07 bd b8 	ld  [ %fp + -584 ], %g4                        <== 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) {                             
4000d9c8:	fa 0f bd de 	ldub  [ %fp + -546 ], %i5                      <== 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);       
4000d9cc:	c2 2f be 15 	stb  %g1, [ %fp + -491 ]                       <== NOT EXECUTED
                                                                      
  FAT_SET_BR_SECTORS_PER_TRACK(mbr   , 255); /* only needed for INT13... */
4000d9d0:	82 10 3f ff 	mov  -1, %g1                                   <== 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);  
4000d9d4:	9f 30 e0 08 	srl  %g3, 8, %o7                               <== NOT EXECUTED
                                                                      
  /* number of FATs on medium */                                      
  FAT_SET_BR_FAT_NUM(mbr             , 2); /* standard/recommended value */
4000d9d8:	b4 10 20 02 	mov  2, %i2                                    <== 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... */
4000d9dc:	b8 10 20 01 	mov  1, %i4                                    <== 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... */
4000d9e0:	c2 2f be 18 	stb  %g1, [ %fp + -488 ]                       <== 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); 
4000d9e4:	da 2f be 0c 	stb  %o5, [ %fp + -500 ]                       <== 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... */
4000d9e8:	82 10 20 06 	mov  6, %g1                                    <== 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);
4000d9ec:	c8 2f be 0d 	stb  %g4, [ %fp + -499 ]                       <== NOT EXECUTED
  FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);  
4000d9f0:	c6 2f be 0e 	stb  %g3, [ %fp + -498 ]                       <== NOT EXECUTED
4000d9f4:	de 2f be 0f 	stb  %o7, [ %fp + -497 ]                       <== NOT EXECUTED
                                                                      
  /* number of FATs on medium */                                      
  FAT_SET_BR_FAT_NUM(mbr             , 2); /* standard/recommended value */
4000d9f8:	f4 2f be 10 	stb  %i2, [ %fp + -496 ]                       <== NOT EXECUTED
  FAT_SET_BR_FILES_PER_ROOT_DIR(mbr  , fmt_params->files_per_root_dir);
4000d9fc:	c4 2f be 11 	stb  %g2, [ %fp + -495 ]                       <== NOT EXECUTED
  FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);          
4000da00:	f0 2f be 13 	stb  %i0, [ %fp + -493 ]                       <== NOT EXECUTED
4000da04:	e0 2f be 14 	stb  %l0, [ %fp + -492 ]                       <== 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... */
4000da08:	c2 2f be 1a 	stb  %g1, [ %fp + -486 ]                       <== NOT EXECUTED
  FAT_SET_BR_HIDDEN_SECTORS(mbr      , 1);   /* only needed for INT13... */
4000da0c:	f8 2f be 1c 	stb  %i4, [ %fp + -484 ]                       <== NOT EXECUTED
                                                                      
  FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);          
4000da10:	e8 2f be 20 	stb  %l4, [ %fp + -480 ]                       <== NOT EXECUTED
4000da14:	e6 2f be 21 	stb  %l3, [ %fp + -479 ]                       <== NOT EXECUTED
4000da18:	e4 2f be 22 	stb  %l2, [ %fp + -478 ]                       <== NOT EXECUTED
  if (fmt_params->fattype != FAT_FAT32) {                             
4000da1c:	80 a7 60 04 	cmp  %i5, 4                                    <== NOT EXECUTED
4000da20:	02 80 02 f7 	be  4000e5fc <msdos_format+0xfb4>              <== NOT EXECUTED
4000da24:	e2 2f be 23 	stb  %l1, [ %fp + -477 ]                       <== 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 */
4000da28:	c2 07 bd f8 	ld  [ %fp + -520 ], %g1                        <== 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);   
4000da2c:	c4 07 bd bc 	ld  [ %fp + -580 ], %g2                        <== 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 */
4000da30:	89 30 60 10 	srl  %g1, 0x10, %g4                            <== NOT EXECUTED
4000da34:	87 30 60 18 	srl  %g1, 0x18, %g3                            <== NOT EXECUTED
4000da38:	b9 30 60 08 	srl  %g1, 8, %i4                               <== NOT EXECUTED
4000da3c:	c2 2f be 27 	stb  %g1, [ %fp + -473 ]                       <== 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);           
4000da40:	82 10 20 29 	mov  0x29, %g1                                 <== 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);   
4000da44:	b5 30 a0 08 	srl  %g2, 8, %i2                               <== 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);           
4000da48:	c2 2f be 26 	stb  %g1, [ %fp + -474 ]                       <== 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);   
4000da4c:	c4 2f be 16 	stb  %g2, [ %fp + -490 ]                       <== NOT EXECUTED
4000da50:	f4 2f be 17 	stb  %i2, [ %fp + -489 ]                       <== 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 */
4000da54:	f8 2f be 28 	stb  %i4, [ %fp + -472 ]                       <== NOT EXECUTED
4000da58:	c8 2f be 29 	stb  %g4, [ %fp + -471 ]                       <== NOT EXECUTED
4000da5c:	c6 2f be 2a 	stb  %g3, [ %fp + -470 ]                       <== NOT EXECUTED
  memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),                                 
4000da60:	90 07 be 2b 	add  %fp, -469, %o0                            <== NOT EXECUTED
4000da64:	92 07 bd e8 	add  %fp, -536, %o1                            <== NOT EXECUTED
4000da68:	40 00 3c ef 	call  4001ce24 <memcpy>                        <== NOT EXECUTED
4000da6c:	94 10 20 0b 	mov  0xb, %o2                                  <== NOT EXECUTED
	 fmt_params->VolLabel,                                               
	 FAT_BR_VOLLAB_SIZE);                                                
    memcpy(FAT_GET_ADDR_BR_FILSYSTYPE(mbr),                           
4000da70:	03 10 00 b2 	sethi  %hi(0x4002c800), %g1                    <== NOT EXECUTED
4000da74:	80 a7 60 01 	cmp  %i5, 1                                    <== NOT EXECUTED
4000da78:	02 80 02 c2 	be  4000e580 <msdos_format+0xf38>              <== NOT EXECUTED
4000da7c:	82 10 62 c0 	or  %g1, 0x2c0, %g1                            <== NOT EXECUTED
4000da80:	c4 10 40 00 	lduh  [ %g1 ], %g2                             <== NOT EXECUTED
4000da84:	c4 37 be 36 	sth  %g2, [ %fp + -458 ]                       <== NOT EXECUTED
4000da88:	c4 10 60 02 	lduh  [ %g1 + 2 ], %g2                         <== NOT EXECUTED
4000da8c:	c4 37 be 38 	sth  %g2, [ %fp + -456 ]                       <== NOT EXECUTED
4000da90:	c4 10 60 04 	lduh  [ %g1 + 4 ], %g2                         <== NOT EXECUTED
4000da94:	c4 37 be 3a 	sth  %g2, [ %fp + -454 ]                       <== NOT EXECUTED
4000da98:	c2 10 60 06 	lduh  [ %g1 + 6 ], %g1                         <== NOT EXECUTED
4000da9c:	c2 37 be 3c 	sth  %g1, [ %fp + -452 ]                       <== NOT EXECUTED
	   FAT_BR_FILSYSTYPE_SIZE);                                          
  }                                                                   
  /*                                                                  
   * add boot record signature                                        
   */                                                                 
  FAT_SET_BR_SIGNATURE(mbr,      FAT_BR_SIGNATURE_VAL);               
4000daa0:	82 10 20 55 	mov  0x55, %g1                                 <== NOT EXECUTED
4000daa4:	c2 2f bf fe 	stb  %g1, [ %fp + -2 ]                         <== NOT EXECUTED
4000daa8:	82 10 3f aa 	mov  -86, %g1                                  <== NOT EXECUTED
4000daac:	c2 2f bf ff 	stb  %g1, [ %fp + -1 ]                         <== NOT EXECUTED
                                                                      
  /*                                                                  
   * add jump to boot loader at start of sector                       
   */                                                                 
  FAT_SET_VAL8(mbr,0,0xeb);                                           
4000dab0:	82 10 3f eb 	mov  -21, %g1                                  <== NOT EXECUTED
4000dab4:	c2 2f be 00 	stb  %g1, [ %fp + -512 ]                       <== NOT EXECUTED
  FAT_SET_VAL8(mbr,1,0x3c);                                           
4000dab8:	82 10 20 3c 	mov  0x3c, %g1                                 <== NOT EXECUTED
4000dabc:	c2 2f be 01 	stb  %g1, [ %fp + -511 ]                       <== NOT EXECUTED
  FAT_SET_VAL8(mbr,2,0x90);                                           
4000dac0:	82 10 3f 90 	mov  -112, %g1                                 <== 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,       
4000dac4:	92 10 20 02 	mov  2, %o1                                    <== NOT EXECUTED
4000dac8:	90 10 00 19 	mov  %i1, %o0                                  <== 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);                                           
4000dacc:	c2 2f be 02 	stb  %g1, [ %fp + -510 ]                       <== 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,       
4000dad0:	15 10 00 b2 	sethi  %hi(0x4002c800), %o2                    <== NOT EXECUTED
4000dad4:	7f ff fe 22 	call  4000d35c <msdos_format_printf>           <== NOT EXECUTED
4000dad8:	94 12 a3 78 	or  %o2, 0x378, %o2	! 4002cb78 <_CPU_Trap_slot_template+0x108><== NOT EXECUTED
                           "write MRB sector\n");                     
      ret_val = msdos_format_write_sec(fd,                            
4000dadc:	d4 07 bd ac 	ld  [ %fp + -596 ], %o2                        <== NOT EXECUTED
4000dae0:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
4000dae4:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4000dae8:	7f ff fe 32 	call  4000d3b0 <msdos_format_write_sec>        <== NOT EXECUTED
4000daec:	96 07 be 00 	add  %fp, -512, %o3                            <== NOT EXECUTED
                                       0,                             
                                       fmt_params.bytes_per_sector,   
                                       tmp_sec);                      
    }                                                                 
    if ((ret_val == 0) &&                                             
4000daf0:	ae 92 20 00 	orcc  %o0, 0, %l7                              <== NOT EXECUTED
4000daf4:	12 bf ff 04 	bne  4000d704 <msdos_format+0xbc>              <== NOT EXECUTED
4000daf8:	c2 07 bd d4 	ld  [ %fp + -556 ], %g1                        <== NOT EXECUTED
4000dafc:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4000db00:	12 80 02 aa 	bne  4000e5a8 <msdos_format+0xf60>             <== NOT EXECUTED
4000db04:	92 10 20 02 	mov  2, %o1                                    <== NOT EXECUTED
  }                                                                   
  /*                                                                  
   * for FAT32: initialize info sector on disk                        
   */                                                                 
  if ((ret_val == 0) &&                                               
      (fmt_params.fsinfo_sec != 0)) {                                 
4000db08:	fa 07 bd d8 	ld  [ %fp + -552 ], %i5                        <== NOT EXECUTED
    }                                                                 
  }                                                                   
  /*                                                                  
   * for FAT32: initialize info sector on disk                        
   */                                                                 
  if ((ret_val == 0) &&                                               
4000db0c:	80 a7 60 00 	cmp  %i5, 0                                    <== NOT EXECUTED
4000db10:	12 80 00 9b 	bne  4000dd7c <msdos_format+0x734>             <== NOT EXECUTED
4000db14:	d2 07 bd bc 	ld  [ %fp + -580 ], %o1                        <== NOT EXECUTED
   * write FAT as all empty                                           
   * -> write all FAT sectors as zero                                 
   */                                                                 
  if (ret_val == 0) {                                                 
    ret_val = msdos_format_fill_sectors                               
      (rqdata,                                                        
4000db18:	d0 0f bd dc 	ldub  [ %fp + -548 ], %o0                      <== NOT EXECUTED
4000db1c:	7f ff d2 9c 	call  4000258c <.umul>                         <== NOT EXECUTED
4000db20:	fa 07 bd b4 	ld  [ %fp + -588 ], %i5                        <== NOT EXECUTED
  /*                                                                  
   * write FAT as all empty                                           
   * -> write all FAT sectors as zero                                 
   */                                                                 
  if (ret_val == 0) {                                                 
    ret_val = msdos_format_fill_sectors                               
4000db24:	d8 07 bd ac 	ld  [ %fp + -596 ], %o4                        <== NOT EXECUTED
      (rqdata,                                                        
4000db28:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
  /*                                                                  
   * write FAT as all empty                                           
   * -> write all FAT sectors as zero                                 
   */                                                                 
  if (ret_val == 0) {                                                 
    ret_val = msdos_format_fill_sectors                               
4000db2c:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
4000db30:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
4000db34:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
4000db38:	7f ff fe 36 	call  4000d410 <msdos_format_fill_sectors>     <== NOT EXECUTED
4000db3c:	9a 10 20 00 	clr  %o5                                       <== NOT EXECUTED
  }                                                                   
  /*                                                                  
   * clear/init root directory                                        
   * -> write all directory sectors as 0x00                           
   */                                                                 
  if (ret_val == 0) {                                                 
4000db40:	ae 92 20 00 	orcc  %o0, 0, %l7                              <== NOT EXECUTED
4000db44:	12 bf fe f0 	bne  4000d704 <msdos_format+0xbc>              <== NOT EXECUTED
4000db48:	d4 07 bd cc 	ld  [ %fp + -564 ], %o2                        <== NOT EXECUTED
    ret_val = msdos_format_fill_sectors                               
4000db4c:	d6 07 bd d0 	ld  [ %fp + -560 ], %o3                        <== NOT EXECUTED
4000db50:	d8 07 bd ac 	ld  [ %fp + -596 ], %o4                        <== NOT EXECUTED
4000db54:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
4000db58:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
4000db5c:	7f ff fe 2d 	call  4000d410 <msdos_format_fill_sectors>     <== NOT EXECUTED
4000db60:	9a 10 20 00 	clr  %o5                                       <== NOT EXECUTED
       0x00);                                                         
  }                                                                   
  /*                                                                  
   * write volume label to first entry of directory                   
   */                                                                 
  if ((ret_val == 0) && fmt_params.VolLabel_present) {                
4000db64:	ae 92 20 00 	orcc  %o0, 0, %l7                              <== NOT EXECUTED
4000db68:	12 bf fe e7 	bne  4000d704 <msdos_format+0xbc>              <== NOT EXECUTED
4000db6c:	c2 0f bd f4 	ldub  [ %fp + -524 ], %g1                      <== NOT EXECUTED
4000db70:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4000db74:	12 80 00 a9 	bne  4000de18 <msdos_format+0x7d0>             <== NOT EXECUTED
4000db78:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
    uint32_t start_sector;                                            
                                                                      
    /*                                                                
     * empty sector: all clusters are free/do not link further on     
     */                                                               
    memset(tmp_sec,0,sizeof(tmp_sec));                                
4000db7c:	90 07 be 00 	add  %fp, -512, %o0                            <== NOT EXECUTED
4000db80:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4000db84:	40 00 3c e5 	call  4001cf18 <memset>                        <== NOT EXECUTED
4000db88:	94 10 22 00 	mov  0x200, %o2                                <== NOT EXECUTED
                                                                      
    switch(fmt_params.fattype) {                                      
4000db8c:	c2 0f bd de 	ldub  [ %fp + -546 ], %g1                      <== NOT EXECUTED
4000db90:	80 a0 60 02 	cmp  %g1, 2                                    <== NOT EXECUTED
4000db94:	02 80 00 e2 	be  4000df1c <msdos_format+0x8d4>              <== NOT EXECUTED
4000db98:	80 a0 60 04 	cmp  %g1, 4                                    <== NOT EXECUTED
4000db9c:	02 80 00 c4 	be  4000deac <msdos_format+0x864>              <== NOT EXECUTED
4000dba0:	80 a0 60 01 	cmp  %g1, 1                                    <== NOT EXECUTED
4000dba4:	02 80 00 d7 	be  4000df00 <msdos_format+0x8b8>              <== NOT EXECUTED
4000dba8:	c2 0f bd dd 	ldub  [ %fp + -547 ], %g1                      <== NOT EXECUTED
      FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);                         
      break;                                                          
                                                                      
    default:                                                          
      ret_val = -1;                                                   
      errno = EINVAL;                                                 
4000dbac:	40 00 39 f9 	call  4001c390 <__errno>                       <== NOT EXECUTED
4000dbb0:	01 00 00 00 	nop                                            <== NOT EXECUTED
4000dbb4:	82 10 20 16 	mov  0x16, %g1	! 16 <PROM_START+0x16>          <== NOT EXECUTED
4000dbb8:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
    }                                                                 
    if (fmt_params.fattype == FAT_FAT32) {                            
4000dbbc:	c2 0f bd de 	ldub  [ %fp + -546 ], %g1                      <== NOT EXECUTED
4000dbc0:	80 a0 60 04 	cmp  %g1, 4                                    <== NOT EXECUTED
4000dbc4:	02 80 00 c7 	be  4000dee0 <msdos_format+0x898>              <== NOT EXECUTED
4000dbc8:	90 10 3f ff 	mov  -1, %o0                                   <== NOT EXECUTED
static uint32_t                                                       
 loc_align_object (const uint32_t sectors,                            
                   const uint32_t clustersize,                        
                   const bool     skip_alignment)                     
{                                                                     
  if (! skip_alignment)                                               
4000dbcc:	c2 0f bd fc 	ldub  [ %fp + -516 ], %g1                      <== NOT EXECUTED
       * mark this in every copy of the FAT                           
       */                                                             
      FAT_SET_VAL32(tmp_sec,8,FAT_FAT32_EOC);                         
    }                                                                 
                                                                      
    start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,      
4000dbd0:	f8 07 bd b4 	ld  [ %fp + -588 ], %i4                        <== NOT EXECUTED
static uint32_t                                                       
 loc_align_object (const uint32_t sectors,                            
                   const uint32_t clustersize,                        
                   const bool     skip_alignment)                     
{                                                                     
  if (! skip_alignment)                                               
4000dbd4:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4000dbd8:	12 80 00 06 	bne  4000dbf0 <msdos_format+0x5a8>             <== NOT EXECUTED
4000dbdc:	c4 07 bd b8 	ld  [ %fp + -584 ], %g2                        <== NOT EXECUTED
    return (sectors + clustersize - 1) & ~(clustersize - 1);          
4000dbe0:	b8 07 00 02 	add  %i4, %g2, %i4                             <== NOT EXECUTED
4000dbe4:	84 20 00 02 	neg  %g2                                       <== NOT EXECUTED
4000dbe8:	b8 07 3f ff 	add  %i4, -1, %i4                              <== NOT EXECUTED
4000dbec:	b8 0f 00 02 	and  %i4, %g2, %i4                             <== NOT EXECUTED
    }                                                                 
                                                                      
    start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,      
                                     fmt_params.sectors_per_cluster,  
                                     fmt_params.skip_alignment);      
    for (i = 0;                                                       
4000dbf0:	c2 0f bd dc 	ldub  [ %fp + -548 ], %g1                      <== NOT EXECUTED
4000dbf4:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4000dbf8:	02 80 02 b0 	be  4000e6b8 <msdos_format+0x1070>             <== NOT EXECUTED
4000dbfc:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
	 (i < fmt_params.fat_num) && (ret_val == 0);                         
4000dc00:	12 80 00 5a 	bne  4000dd68 <msdos_format+0x720>             <== NOT EXECUTED
4000dc04:	d0 07 bd bc 	ld  [ %fp + -580 ], %o0                        <== NOT EXECUTED
    }                                                                 
                                                                      
    start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,      
                                     fmt_params.sectors_per_cluster,  
                                     fmt_params.skip_alignment);      
    for (i = 0;                                                       
4000dc08:	10 80 00 05 	b  4000dc1c <msdos_format+0x5d4>               <== NOT EXECUTED
4000dc0c:	ba 10 20 00 	clr  %i5                                       <== NOT EXECUTED
	 (i < fmt_params.fat_num) && (ret_val == 0);                         
4000dc10:	32 bf fe bd 	bne,a   4000d704 <msdos_format+0xbc>           <== NOT EXECUTED
4000dc14:	ae 10 00 08 	mov  %o0, %l7                                  <== NOT EXECUTED
4000dc18:	d0 07 bd bc 	ld  [ %fp + -580 ], %o0                        <== NOT EXECUTED
	 i++) {                                                              
      ret_val = msdos_format_write_sec                                
        (fd,                                                          
         start_sector                                                 
         + (i * fmt_params.sectors_per_fat),                          
4000dc1c:	7f ff d2 5c 	call  4000258c <.umul>                         <== NOT EXECUTED
4000dc20:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
                                     fmt_params.sectors_per_cluster,  
                                     fmt_params.skip_alignment);      
    for (i = 0;                                                       
	 (i < fmt_params.fat_num) && (ret_val == 0);                         
	 i++) {                                                              
      ret_val = msdos_format_write_sec                                
4000dc24:	d4 07 bd ac 	ld  [ %fp + -596 ], %o2                        <== NOT EXECUTED
        (fd,                                                          
4000dc28:	92 02 00 1c 	add  %o0, %i4, %o1                             <== NOT EXECUTED
                                     fmt_params.sectors_per_cluster,  
                                     fmt_params.skip_alignment);      
    for (i = 0;                                                       
	 (i < fmt_params.fat_num) && (ret_val == 0);                         
	 i++) {                                                              
      ret_val = msdos_format_write_sec                                
4000dc2c:	96 07 be 00 	add  %fp, -512, %o3                            <== NOT EXECUTED
4000dc30:	7f ff fd e0 	call  4000d3b0 <msdos_format_write_sec>        <== NOT EXECUTED
4000dc34:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
                                                                      
    start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,      
                                     fmt_params.sectors_per_cluster,  
                                     fmt_params.skip_alignment);      
    for (i = 0;                                                       
	 (i < fmt_params.fat_num) && (ret_val == 0);                         
4000dc38:	c2 0f bd dc 	ldub  [ %fp + -548 ], %g1                      <== NOT EXECUTED
	 i++) {                                                              
4000dc3c:	ba 07 60 01 	inc  %i5                                       <== NOT EXECUTED
    }                                                                 
                                                                      
    start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,      
                                     fmt_params.sectors_per_cluster,  
                                     fmt_params.skip_alignment);      
    for (i = 0;                                                       
4000dc40:	80 a0 40 1d 	cmp  %g1, %i5                                  <== NOT EXECUTED
4000dc44:	14 bf ff f3 	bg  4000dc10 <msdos_format+0x5c8>              <== NOT EXECUTED
4000dc48:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4000dc4c:	c4 0f bd 57 	ldub  [ %fp + -681 ], %g2                      <== NOT EXECUTED
4000dc50:	80 a0 00 08 	cmp  %g0, %o0                                  <== NOT EXECUTED
4000dc54:	82 60 3f ff 	subx  %g0, -1, %g1                             <== NOT EXECUTED
4000dc58:	82 08 40 02 	and  %g1, %g2, %g1                             <== NOT EXECUTED
         fmt_params.bytes_per_sector,                                 
         tmp_sec);                                                    
    }                                                                 
  }                                                                   
                                                                      
  if (ret_val == 0 && rqdata != NULL && rqdata->sync_device) {        
4000dc5c:	80 88 60 ff 	btst  0xff, %g1                                <== NOT EXECUTED
4000dc60:	22 bf fe a9 	be,a   4000d704 <msdos_format+0xbc>            <== NOT EXECUTED
4000dc64:	ae 10 00 08 	mov  %o0, %l7                                  <== NOT EXECUTED
4000dc68:	c2 0e 60 17 	ldub  [ %i1 + 0x17 ], %g1                      <== NOT EXECUTED
4000dc6c:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4000dc70:	02 bf fe a6 	be  4000d708 <msdos_format+0xc0>               <== NOT EXECUTED
4000dc74:	80 a6 ff ff 	cmp  %i3, -1                                   <== NOT EXECUTED
  return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);                   
}                                                                     
                                                                      
static inline int rtems_disk_fd_sync(int fd)                          
{                                                                     
  return ioctl(fd, RTEMS_BLKIO_SYNCDEV);                              
4000dc78:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
4000dc7c:	13 08 00 10 	sethi  %hi(0x20004000), %o1                    <== NOT EXECUTED
4000dc80:	40 00 1c ff 	call  4001507c <ioctl>                         <== NOT EXECUTED
4000dc84:	92 12 62 06 	or  %o1, 0x206, %o1	! 20004206 <RAM_SIZE+0x1fc04206><== NOT EXECUTED
4000dc88:	10 bf fe 9f 	b  4000d704 <msdos_format+0xbc>                <== NOT EXECUTED
4000dc8c:	ae 10 00 08 	mov  %o0, %l7                                  <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * sanity check on device                                           
   */                                                                 
  msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,           
4000dc90:	96 10 00 18 	mov  %i0, %o3                                  <== NOT EXECUTED
4000dc94:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
4000dc98:	92 10 20 02 	mov  2, %o1                                    <== NOT EXECUTED
4000dc9c:	15 10 00 b2 	sethi  %hi(0x4002c800), %o2                    <== NOT EXECUTED
4000dca0:	7f ff fd af 	call  4000d35c <msdos_format_printf>           <== NOT EXECUTED
4000dca4:	94 12 a3 b0 	or  %o2, 0x3b0, %o2	! 4002cbb0 <_CPU_Trap_slot_template+0x140><== NOT EXECUTED
                       "stat check: %s\n", devname);                  
  if (ret_val == 0) {                                                 
    ret_val = fstat(fd, &stat_buf);                                   
  }                                                                   
                                                                      
  msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,             
4000dca8:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
4000dcac:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
4000dcb0:	96 10 00 18 	mov  %i0, %o3                                  <== NOT EXECUTED
4000dcb4:	15 10 00 b2 	sethi  %hi(0x4002c800), %o2                    <== NOT EXECUTED
4000dcb8:	ae 10 3f ff 	mov  -1, %l7                                   <== NOT EXECUTED
4000dcbc:	7f ff fd a8 	call  4000d35c <msdos_format_printf>           <== NOT EXECUTED
4000dcc0:	94 12 a3 c0 	or  %o2, 0x3c0, %o2                            <== NOT EXECUTED
4000dcc4:	10 bf fe 8b 	b  4000d6f0 <msdos_format+0xa8>                <== NOT EXECUTED
4000dcc8:	80 a0 00 19 	cmp  %g0, %i1                                  <== NOT EXECUTED
static inline int rtems_disk_fd_get_block_count(                      
  int fd,                                                             
  rtems_blkdev_bnum *block_count                                      
)                                                                     
{                                                                     
  return ioctl(fd, RTEMS_BLKIO_GETSIZE, block_count);                 
4000dccc:	92 17 62 05 	or  %i5, 0x205, %o1                            <== NOT EXECUTED
4000dcd0:	40 00 1c eb 	call  4001507c <ioctl>                         <== NOT EXECUTED
4000dcd4:	94 07 bd b0 	add  %fp, -592, %o2                            <== NOT EXECUTED
    ret_val = rtems_disk_fd_get_media_block_size(fd, &fmt_params->bytes_per_sector);
  }                                                                   
  if (ret_val == 0) {                                                 
    ret_val = rtems_disk_fd_get_block_count(fd, &fmt_params->totl_sector_cnt);
  }                                                                   
  if (ret_val == 0) {                                                 
4000dcd8:	84 92 20 00 	orcc  %o0, 0, %g2                              <== NOT EXECUTED
4000dcdc:	12 bf fe 9c 	bne  4000d74c <msdos_format+0x104>             <== NOT EXECUTED
4000dce0:	f0 07 bd ac 	ld  [ %fp + -596 ], %i0                        <== NOT EXECUTED
    total_size = fmt_params->bytes_per_sector * fmt_params->totl_sector_cnt;
4000dce4:	f4 07 bd b0 	ld  [ %fp + -592 ], %i2                        <== NOT EXECUTED
4000dce8:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
4000dcec:	7f ff d2 28 	call  4000258c <.umul>                         <== NOT EXECUTED
4000dcf0:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
    msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,         
4000dcf4:	9a 10 20 00 	clr  %o5                                       <== NOT EXECUTED
  }                                                                   
  if (ret_val == 0) {                                                 
    ret_val = rtems_disk_fd_get_block_count(fd, &fmt_params->totl_sector_cnt);
  }                                                                   
  if (ret_val == 0) {                                                 
    total_size = fmt_params->bytes_per_sector * fmt_params->totl_sector_cnt;
4000dcf8:	ba 10 00 08 	mov  %o0, %i5                                  <== NOT EXECUTED
    msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,         
4000dcfc:	d0 23 a0 5c 	st  %o0, [ %sp + 0x5c ]                        <== NOT EXECUTED
  }                                                                   
  if (ret_val == 0) {                                                 
    ret_val = rtems_disk_fd_get_block_count(fd, &fmt_params->totl_sector_cnt);
  }                                                                   
  if (ret_val == 0) {                                                 
    total_size = fmt_params->bytes_per_sector * fmt_params->totl_sector_cnt;
4000dd00:	b8 10 20 00 	clr  %i4                                       <== NOT EXECUTED
    msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,         
4000dd04:	92 10 20 02 	mov  2, %o1                                    <== NOT EXECUTED
4000dd08:	f8 3f bd 58 	std  %i4, [ %fp + -680 ]                       <== NOT EXECUTED
4000dd0c:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
4000dd10:	96 10 00 18 	mov  %i0, %o3                                  <== NOT EXECUTED
4000dd14:	15 10 00 b2 	sethi  %hi(0x4002c800), %o2                    <== NOT EXECUTED
4000dd18:	98 10 00 1a 	mov  %i2, %o4                                  <== NOT EXECUTED
4000dd1c:	7f ff fd 90 	call  4000d35c <msdos_format_printf>           <== NOT EXECUTED
4000dd20:	94 12 a2 e8 	or  %o2, 0x2e8, %o2                            <== NOT EXECUTED
                                                                      
  /*                                                                  
   * determine number of FATs                                         
   */                                                                 
  if (ret_val == 0) {                                                 
    if ((rqdata == NULL) ||                                           
4000dd24:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
4000dd28:	02 80 02 69 	be  4000e6cc <msdos_format+0x1084>             <== NOT EXECUTED
4000dd2c:	82 10 20 02 	mov  2, %g1                                    <== NOT EXECUTED
	(rqdata->fat_num == 0)) {                                            
4000dd30:	d6 06 60 0c 	ld  [ %i1 + 0xc ], %o3                         <== NOT EXECUTED
                                                                      
  /*                                                                  
   * determine number of FATs                                         
   */                                                                 
  if (ret_val == 0) {                                                 
    if ((rqdata == NULL) ||                                           
4000dd34:	80 a2 e0 00 	cmp  %o3, 0                                    <== NOT EXECUTED
4000dd38:	22 80 00 82 	be,a   4000df40 <msdos_format+0x8f8>           <== NOT EXECUTED
4000dd3c:	15 10 00 b2 	sethi  %hi(0x4002c800), %o2                    <== NOT EXECUTED
	(rqdata->fat_num == 0)) {                                            
      fmt_params->fat_num = 2;                                        
    }                                                                 
    else if (rqdata->fat_num <= 6) {                                  
4000dd40:	80 a2 e0 06 	cmp  %o3, 6                                    <== NOT EXECUTED
4000dd44:	18 80 02 09 	bgu  4000e568 <msdos_format+0xf20>             <== NOT EXECUTED
4000dd48:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
      fmt_params->fat_num = rqdata->fat_num;                          
4000dd4c:	d6 2f bd dc 	stb  %o3, [ %fp + -548 ]                       <== NOT EXECUTED
      ret_val = -1;                                                   
    }                                                                 
  }                                                                   
                                                                      
  if (ret_val == 0)                                                   
    msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,         
4000dd50:	92 10 20 02 	mov  2, %o1                                    <== NOT EXECUTED
4000dd54:	15 10 00 b2 	sethi  %hi(0x4002c800), %o2                    <== NOT EXECUTED
4000dd58:	7f ff fd 81 	call  4000d35c <msdos_format_printf>           <== NOT EXECUTED
4000dd5c:	94 12 a3 28 	or  %o2, 0x328, %o2	! 4002cb28 <_CPU_Trap_slot_template+0xb8><== NOT EXECUTED
     * are a compromise concerning capacity and efficency             
     */                                                               
    uint32_t fat12_sect_per_clust = 8;                                
    uint32_t fat16_sect_per_clust = 32;                               
                                                                      
    if (rqdata != NULL && rqdata->sectors_per_cluster != 0) {         
4000dd60:	10 80 00 7f 	b  4000df5c <msdos_format+0x914>               <== NOT EXECUTED
4000dd64:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           <== NOT EXECUTED
                                                                      
    start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,      
                                     fmt_params.sectors_per_cluster,  
                                     fmt_params.skip_alignment);      
    for (i = 0;                                                       
	 (i < fmt_params.fat_num) && (ret_val == 0);                         
4000dd68:	90 10 3f ff 	mov  -1, %o0                                   <== NOT EXECUTED
         fmt_params.bytes_per_sector,                                 
         tmp_sec);                                                    
    }                                                                 
  }                                                                   
                                                                      
  if (ret_val == 0 && rqdata != NULL && rqdata->sync_device) {        
4000dd6c:	10 bf fe 66 	b  4000d704 <msdos_format+0xbc>                <== NOT EXECUTED
4000dd70:	ae 10 00 08 	mov  %o0, %l7                                  <== NOT EXECUTED
      }                                                               
                                                                      
      ++iteration_cnt;                                                
    }                                                                 
  }                                                                   
  if ( fmt_params->totl_sector_cnt == 0 )                             
4000dd74:	10 bf fe 64 	b  4000d704 <msdos_format+0xbc>                <== NOT EXECUTED
4000dd78:	ae 10 3f ff 	mov  -1, %l7                                   <== NOT EXECUTED
\*=========================================================================*/
{                                                                     
  /*                                                                  
   * clear fsinfo sector data                                         
   */                                                                 
  memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);                             
4000dd7c:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4000dd80:	94 10 22 00 	mov  0x200, %o2                                <== NOT EXECUTED
4000dd84:	40 00 3c 65 	call  4001cf18 <memset>                        <== NOT EXECUTED
4000dd88:	90 07 be 00 	add  %fp, -512, %o0                            <== NOT EXECUTED
  /*                                                                  
   * write LEADSIG, STRUCTSIG, TRAILSIG                               
   */                                                                 
  FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
4000dd8c:	84 10 20 61 	mov  0x61, %g2                                 <== NOT EXECUTED
  /*                                                                  
   * write fsinfo sector                                              
   */                                                                 
  if ((ret_val == 0) &&                                               
      (fmt_params.fsinfo_sec != 0)) {                                 
    ret_val = msdos_format_write_sec(fd,                              
4000dd90:	d4 07 bd ac 	ld  [ %fp + -596 ], %o2                        <== NOT EXECUTED
   */                                                                 
  memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);                             
  /*                                                                  
   * write LEADSIG, STRUCTSIG, TRAILSIG                               
   */                                                                 
  FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
4000dd94:	c4 2f be 02 	stb  %g2, [ %fp + -510 ]                       <== NOT EXECUTED
  FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
4000dd98:	c4 2f bf e7 	stb  %g2, [ %fp + -25 ]                        <== NOT EXECUTED
  FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
4000dd9c:	84 10 20 55 	mov  0x55, %g2                                 <== NOT EXECUTED
  /*                                                                  
   * write "empty" values for free cluster count and next cluster number
   */                                                                 
  FAT_SET_FSINFO_FREE_CLUSTER_COUNT(fsinfo+FAT_FSI_INFO,              
4000dda0:	82 10 3f ff 	mov  -1, %g1                                   <== NOT EXECUTED
   */                                                                 
  memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);                             
  /*                                                                  
   * write LEADSIG, STRUCTSIG, TRAILSIG                               
   */                                                                 
  FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
4000dda4:	86 10 20 41 	mov  0x41, %g3                                 <== NOT EXECUTED
  FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
4000dda8:	88 10 20 72 	mov  0x72, %g4                                 <== NOT EXECUTED
  FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
4000ddac:	c4 2f bf fe 	stb  %g2, [ %fp + -2 ]                         <== NOT EXECUTED
4000ddb0:	84 10 3f aa 	mov  -86, %g2                                  <== NOT EXECUTED
   */                                                                 
  memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);                             
  /*                                                                  
   * write LEADSIG, STRUCTSIG, TRAILSIG                               
   */                                                                 
  FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
4000ddb4:	b8 10 20 52 	mov  0x52, %i4                                 <== NOT EXECUTED
4000ddb8:	c6 2f be 03 	stb  %g3, [ %fp + -509 ]                       <== NOT EXECUTED
4000ddbc:	f8 2f be 00 	stb  %i4, [ %fp + -512 ]                       <== NOT EXECUTED
4000ddc0:	f8 2f be 01 	stb  %i4, [ %fp + -511 ]                       <== NOT EXECUTED
  FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
4000ddc4:	c8 2f bf e4 	stb  %g4, [ %fp + -28 ]                        <== NOT EXECUTED
4000ddc8:	c8 2f bf e5 	stb  %g4, [ %fp + -27 ]                        <== NOT EXECUTED
4000ddcc:	c6 2f bf e6 	stb  %g3, [ %fp + -26 ]                        <== NOT EXECUTED
  FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
4000ddd0:	c4 2f bf ff 	stb  %g2, [ %fp + -1 ]                         <== NOT EXECUTED
  /*                                                                  
   * write "empty" values for free cluster count and next cluster number
   */                                                                 
  FAT_SET_FSINFO_FREE_CLUSTER_COUNT(fsinfo+FAT_FSI_INFO,              
4000ddd4:	c2 2f bf e8 	stb  %g1, [ %fp + -24 ]                        <== NOT EXECUTED
4000ddd8:	c2 2f bf e9 	stb  %g1, [ %fp + -23 ]                        <== NOT EXECUTED
4000dddc:	c2 2f bf ea 	stb  %g1, [ %fp + -22 ]                        <== NOT EXECUTED
4000dde0:	c2 2f bf eb 	stb  %g1, [ %fp + -21 ]                        <== NOT EXECUTED
				    0xffffffff);                                                  
  FAT_SET_FSINFO_NEXT_FREE_CLUSTER (fsinfo+FAT_FSI_INFO,              
4000dde4:	c2 2f bf ec 	stb  %g1, [ %fp + -20 ]                        <== NOT EXECUTED
4000dde8:	c2 2f bf ed 	stb  %g1, [ %fp + -19 ]                        <== NOT EXECUTED
4000ddec:	c2 2f bf ee 	stb  %g1, [ %fp + -18 ]                        <== NOT EXECUTED
4000ddf0:	c2 2f bf ef 	stb  %g1, [ %fp + -17 ]                        <== NOT EXECUTED
  /*                                                                  
   * write fsinfo sector                                              
   */                                                                 
  if ((ret_val == 0) &&                                               
      (fmt_params.fsinfo_sec != 0)) {                                 
    ret_val = msdos_format_write_sec(fd,                              
4000ddf4:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
4000ddf8:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
4000ddfc:	7f ff fd 6d 	call  4000d3b0 <msdos_format_write_sec>        <== NOT EXECUTED
4000de00:	96 07 be 00 	add  %fp, -512, %o3                            <== NOT EXECUTED
  }                                                                   
  /*                                                                  
   * write FAT as all empty                                           
   * -> write all FAT sectors as zero                                 
   */                                                                 
  if (ret_val == 0) {                                                 
4000de04:	ae 92 20 00 	orcc  %o0, 0, %l7                              <== NOT EXECUTED
4000de08:	12 bf fe 40 	bne  4000d708 <msdos_format+0xc0>              <== NOT EXECUTED
4000de0c:	80 a6 ff ff 	cmp  %i3, -1                                   <== NOT EXECUTED
    ret_val = msdos_format_fill_sectors                               
      (rqdata,                                                        
4000de10:	10 bf ff 42 	b  4000db18 <msdos_format+0x4d0>               <== NOT EXECUTED
4000de14:	d2 07 bd bc 	ld  [ %fp + -580 ], %o1                        <== 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));                                
4000de18:	94 10 22 00 	mov  0x200, %o2                                <== NOT EXECUTED
4000de1c:	40 00 3c 3f 	call  4001cf18 <memset>                        <== NOT EXECUTED
4000de20:	90 07 be 00 	add  %fp, -512, %o0                            <== NOT EXECUTED
    memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
4000de24:	c2 0f bd f2 	ldub  [ %fp + -526 ], %g1                      <== NOT EXECUTED
4000de28:	c6 07 bd ec 	ld  [ %fp + -532 ], %g3                        <== NOT EXECUTED
4000de2c:	c4 17 bd f0 	lduh  [ %fp + -528 ], %g2                      <== NOT EXECUTED
4000de30:	c8 07 bd e8 	ld  [ %fp + -536 ], %g4                        <== NOT EXECUTED
    *MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;                  
    ret_val = msdos_format_write_sec                                  
4000de34:	d2 07 bd cc 	ld  [ %fp + -564 ], %o1                        <== NOT EXECUTED
4000de38:	d4 07 bd ac 	ld  [ %fp + -596 ], %o2                        <== 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);
4000de3c:	c2 2f be 0a 	stb  %g1, [ %fp + -502 ]                       <== NOT EXECUTED
    *MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;                  
4000de40:	82 10 20 08 	mov  8, %g1                                    <== 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);
4000de44:	c8 27 be 00 	st  %g4, [ %fp + -512 ]                        <== NOT EXECUTED
4000de48:	c6 27 be 04 	st  %g3, [ %fp + -508 ]                        <== NOT EXECUTED
4000de4c:	c4 37 be 08 	sth  %g2, [ %fp + -504 ]                       <== NOT EXECUTED
    *MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;                  
    ret_val = msdos_format_write_sec                                  
4000de50:	90 10 00 1b 	mov  %i3, %o0                                  <== 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;                  
4000de54:	c2 2f be 0b 	stb  %g1, [ %fp + -501 ]                       <== NOT EXECUTED
    ret_val = msdos_format_write_sec                                  
4000de58:	7f ff fd 56 	call  4000d3b0 <msdos_format_write_sec>        <== NOT EXECUTED
4000de5c:	96 07 be 00 	add  %fp, -512, %o3                            <== 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) {                                                 
4000de60:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4000de64:	22 bf ff 47 	be,a   4000db80 <msdos_format+0x538>           <== NOT EXECUTED
4000de68:	90 07 be 00 	add  %fp, -512, %o0                            <== NOT EXECUTED
         fmt_params.bytes_per_sector,                                 
         tmp_sec);                                                    
    }                                                                 
  }                                                                   
                                                                      
  if (ret_val == 0 && rqdata != NULL && rqdata->sync_device) {        
4000de6c:	10 bf fe 26 	b  4000d704 <msdos_format+0xbc>                <== NOT EXECUTED
4000de70:	ae 10 00 08 	mov  %o0, %l7                                  <== NOT EXECUTED
4000de74:	82 40 20 00 	addx  %g0, 0, %g1                              <== NOT EXECUTED
4000de78:	c2 2f bd 57 	stb  %g1, [ %fp + -681 ]                       <== NOT EXECUTED
      ++iteration_cnt;                                                
    }                                                                 
  }                                                                   
  if ( fmt_params->totl_sector_cnt == 0 )                             
  {                                                                   
    errno = EINVAL;                                                   
4000de7c:	40 00 39 45 	call  4001c390 <__errno>                       <== NOT EXECUTED
4000de80:	ae 10 3f ff 	mov  -1, %l7                                   <== NOT EXECUTED
4000de84:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
4000de88:	10 bf fe 39 	b  4000d76c <msdos_format+0x124>               <== NOT EXECUTED
4000de8c:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== 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);           
4000de90:	7f ff d1 bf 	call  4000258c <.umul>                         <== NOT EXECUTED
4000de94:	01 00 00 00 	nop                                            <== NOT EXECUTED
    fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
4000de98:	c2 07 bd b8 	ld  [ %fp + -584 ], %g1                        <== 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);           
4000de9c:	90 07 40 08 	add  %i5, %o0, %o0                             <== NOT EXECUTED
    fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
4000dea0:	c2 27 bd d0 	st  %g1, [ %fp + -560 ]                        <== NOT EXECUTED
  }                                                                   
  else {                                                              
    /*                                                                
     * for FAT32: root directory is in cluster 2                      
     */                                                               
    fmt_params->root_dir_start_sec =                                  
4000dea4:	10 bf fe 3e 	b  4000d79c <msdos_format+0x154>               <== NOT EXECUTED
4000dea8:	d0 27 bd cc 	st  %o0, [ %fp + -564 ]                        <== 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);      
4000deac:	c4 0f bd dd 	ldub  [ %fp + -547 ], %g2                      <== NOT EXECUTED
4000deb0:	82 10 3f ff 	mov  -1, %g1                                   <== NOT EXECUTED
4000deb4:	c4 2f be 00 	stb  %g2, [ %fp + -512 ]                       <== NOT EXECUTED
4000deb8:	c2 2f be 01 	stb  %g1, [ %fp + -511 ]                       <== NOT EXECUTED
4000debc:	c2 2f be 02 	stb  %g1, [ %fp + -510 ]                       <== NOT EXECUTED
4000dec0:	c2 2f be 03 	stb  %g1, [ %fp + -509 ]                       <== NOT EXECUTED
      /* FAT entry 1: EOC */                                          
      FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);                         
4000dec4:	84 10 3f f8 	mov  -8, %g2                                   <== NOT EXECUTED
4000dec8:	c2 2f be 05 	stb  %g1, [ %fp + -507 ]                       <== NOT EXECUTED
4000decc:	c2 2f be 06 	stb  %g1, [ %fp + -506 ]                       <== NOT EXECUTED
4000ded0:	c4 2f be 04 	stb  %g2, [ %fp + -508 ]                       <== NOT EXECUTED
4000ded4:	82 10 20 0f 	mov  0xf, %g1                                  <== NOT EXECUTED
4000ded8:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4000dedc:	c2 2f be 07 	stb  %g1, [ %fp + -505 ]                       <== 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);                         
4000dee0:	82 10 3f ff 	mov  -1, %g1                                   <== NOT EXECUTED
4000dee4:	84 10 3f f8 	mov  -8, %g2                                   <== NOT EXECUTED
4000dee8:	c2 2f be 09 	stb  %g1, [ %fp + -503 ]                       <== NOT EXECUTED
4000deec:	c2 2f be 0a 	stb  %g1, [ %fp + -502 ]                       <== NOT EXECUTED
4000def0:	c4 2f be 08 	stb  %g2, [ %fp + -504 ]                       <== NOT EXECUTED
4000def4:	82 10 20 0f 	mov  0xf, %g1                                  <== NOT EXECUTED
4000def8:	10 bf ff 35 	b  4000dbcc <msdos_format+0x584>               <== NOT EXECUTED
4000defc:	c2 2f be 0b 	stb  %g1, [ %fp + -501 ]                       <== NOT EXECUTED
      /* FAT entry 1: EOC */                                          
      FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);                         
      break;                                                          
                                                                      
    default:                                                          
      ret_val = -1;                                                   
4000df00:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
    memset(tmp_sec,0,sizeof(tmp_sec));                                
                                                                      
    switch(fmt_params.fattype) {                                      
    case FAT_FAT12:                                                   
      /* LSBits of FAT entry 0: media_type */                         
      FAT_SET_VAL8(tmp_sec,0,(fmt_params.media_code));                
4000df04:	c2 2f be 00 	stb  %g1, [ %fp + -512 ]                       <== 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)));          
4000df08:	82 10 3f 8f 	mov  -113, %g1                                 <== NOT EXECUTED
4000df0c:	c2 2f be 01 	stb  %g1, [ %fp + -511 ]                       <== NOT EXECUTED
      /* MSBits of FAT entry 1: MSBits of EOC */                      
      FAT_SET_VAL8(tmp_sec,2,(FAT_FAT12_EOC >> 4));                   
4000df10:	82 10 3f ff 	mov  -1, %g1                                   <== NOT EXECUTED
4000df14:	10 bf ff 2e 	b  4000dbcc <msdos_format+0x584>               <== NOT EXECUTED
4000df18:	c2 2f be 02 	stb  %g1, [ %fp + -510 ]                       <== NOT EXECUTED
      break;                                                          
                                                                      
    case FAT_FAT16:                                                   
      /* FAT entry 0: 0xff00|media_type */                            
      FAT_SET_VAL8(tmp_sec,0,fmt_params.media_code);                  
4000df1c:	c4 0f bd dd 	ldub  [ %fp + -547 ], %g2                      <== NOT EXECUTED
      FAT_SET_VAL8(tmp_sec,1,0xff);                                   
4000df20:	82 10 3f ff 	mov  -1, %g1                                   <== NOT EXECUTED
      FAT_SET_VAL8(tmp_sec,2,(FAT_FAT12_EOC >> 4));                   
      break;                                                          
                                                                      
    case FAT_FAT16:                                                   
      /* FAT entry 0: 0xff00|media_type */                            
      FAT_SET_VAL8(tmp_sec,0,fmt_params.media_code);                  
4000df24:	c4 2f be 00 	stb  %g2, [ %fp + -512 ]                       <== NOT EXECUTED
      FAT_SET_VAL8(tmp_sec,1,0xff);                                   
4000df28:	c2 2f be 01 	stb  %g1, [ %fp + -511 ]                       <== NOT EXECUTED
      /* FAT entry 1: EOC */                                          
      FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);                         
4000df2c:	84 10 3f f8 	mov  -8, %g2                                   <== NOT EXECUTED
4000df30:	c2 2f be 03 	stb  %g1, [ %fp + -509 ]                       <== NOT EXECUTED
4000df34:	c4 2f be 02 	stb  %g2, [ %fp + -510 ]                       <== NOT EXECUTED
      /* FAT entry 1: EOC */                                          
      FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);                         
      break;                                                          
                                                                      
    default:                                                          
      ret_val = -1;                                                   
4000df38:	10 bf ff 25 	b  4000dbcc <msdos_format+0x584>               <== NOT EXECUTED
4000df3c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
   * determine number of FATs                                         
   */                                                                 
  if (ret_val == 0) {                                                 
    if ((rqdata == NULL) ||                                           
	(rqdata->fat_num == 0)) {                                            
      fmt_params->fat_num = 2;                                        
4000df40:	c2 2f bd dc 	stb  %g1, [ %fp + -548 ]                       <== NOT EXECUTED
      ret_val = -1;                                                   
    }                                                                 
  }                                                                   
                                                                      
  if (ret_val == 0)                                                   
    msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,         
4000df44:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
4000df48:	92 10 20 02 	mov  2, %o1                                    <== NOT EXECUTED
4000df4c:	94 12 a3 28 	or  %o2, 0x328, %o2                            <== NOT EXECUTED
4000df50:	7f ff fd 03 	call  4000d35c <msdos_format_printf>           <== NOT EXECUTED
4000df54:	96 10 20 02 	mov  2, %o3                                    <== NOT EXECUTED
     * are a compromise concerning capacity and efficency             
     */                                                               
    uint32_t fat12_sect_per_clust = 8;                                
    uint32_t fat16_sect_per_clust = 32;                               
                                                                      
    if (rqdata != NULL && rqdata->sectors_per_cluster != 0) {         
4000df58:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           <== NOT EXECUTED
4000df5c:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4000df60:	02 80 01 75 	be  4000e534 <msdos_format+0xeec>              <== NOT EXECUTED
4000df64:	07 00 00 1f 	sethi  %hi(0x7c00), %g3                        <== NOT EXECUTED
4000df68:	85 28 60 02 	sll  %g1, 2, %g2                               <== NOT EXECUTED
4000df6c:	87 28 60 0a 	sll  %g1, 0xa, %g3                             <== NOT EXECUTED
4000df70:	86 20 c0 02 	sub  %g3, %g2, %g3                             <== NOT EXECUTED
4000df74:	86 00 c0 01 	add  %g3, %g1, %g3                             <== NOT EXECUTED
4000df78:	87 28 e0 02 	sll  %g3, 2, %g3                               <== NOT EXECUTED
4000df7c:	86 00 c0 01 	add  %g3, %g1, %g3                             <== NOT EXECUTED
      fat12_sect_per_clust = rqdata->sectors_per_cluster;             
      fat16_sect_per_clust = rqdata->sectors_per_cluster;             
    }                                                                 
                                                                      
    if (fmt_params->totl_sector_cnt < FAT_FAT12_MAX_CLN * fat12_sect_per_clust) {
4000df80:	c4 07 bd b0 	ld  [ %fp + -592 ], %g2                        <== NOT EXECUTED
4000df84:	80 a0 80 03 	cmp  %g2, %g3                                  <== NOT EXECUTED
4000df88:	1a 80 01 4f 	bcc  4000e4c4 <msdos_format+0xe7c>             <== NOT EXECUTED
4000df8c:	87 28 60 02 	sll  %g1, 2, %g3                               <== NOT EXECUTED
      fmt_params->fattype = FAT_FAT12;                                
4000df90:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
4000df94:	c2 2f bd de 	stb  %g1, [ %fp + -546 ]                       <== NOT EXECUTED
      /* start trying with small clusters */                          
      fmt_params->sectors_per_cluster = 2;                            
4000df98:	82 10 20 02 	mov  2, %g1                                    <== NOT EXECUTED
4000df9c:	c2 27 bd b8 	st  %g1, [ %fp + -584 ]                        <== NOT EXECUTED
        if ((gigs & (1 << b)) != 0)                                   
          break;                                                      
      fmt_params->sectors_per_cluster = 1 << b;                       
    }                                                                 
                                                                      
    ret_val = msdos_set_sectors_per_cluster_from_request( rqdata, fmt_params );
4000dfa0:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
4000dfa4:	7f ff fd 88 	call  4000d5c4 <msdos_set_sectors_per_cluster_from_request><== NOT EXECUTED
4000dfa8:	92 07 bd ac 	add  %fp, -596, %o1                            <== NOT EXECUTED
    if (ret_val == 0) {                                               
      data_clusters_cnt =                                             
        fmt_params->totl_sector_cnt / fmt_params->sectors_per_cluster;
    }                                                                 
                                                                      
    while(   ret_val == 0                                             
4000dfac:	ae 92 20 00 	orcc  %o0, 0, %l7                              <== NOT EXECUTED
4000dfb0:	12 80 01 d2 	bne  4000e6f8 <msdos_format+0x10b0>            <== NOT EXECUTED
4000dfb4:	c2 0f bd de 	ldub  [ %fp + -546 ], %g1                      <== NOT EXECUTED
          && fmt_params->fattype != fat_type                          
4000dfb8:	80 a0 60 ff 	cmp  %g1, 0xff                                 <== NOT EXECUTED
4000dfbc:	02 80 01 d5 	be  4000e710 <msdos_format+0x10c8>             <== NOT EXECUTED
4000dfc0:	c2 07 bd b0 	ld  [ %fp + -592 ], %g1                        <== NOT EXECUTED
          && fmt_params->totl_sector_cnt > 0 ) {                      
4000dfc4:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4000dfc8:	02 bf ff ab 	be  4000de74 <msdos_format+0x82c>              <== NOT EXECUTED
4000dfcc:	80 a0 00 19 	cmp  %g0, %i1                                  <== NOT EXECUTED
4000dfd0:	84 40 20 00 	addx  %g0, 0, %g2                              <== NOT EXECUTED
4000dfd4:	c4 2f bd 57 	stb  %g2, [ %fp + -681 ]                       <== NOT EXECUTED
4000dfd8:	ec 0f bd 57 	ldub  [ %fp + -681 ], %l6                      <== 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;                 
4000dfdc:	98 10 20 00 	clr  %o4                                       <== NOT EXECUTED
4000dfe0:	1b 10 00 00 	sethi  %hi(0x40000000), %o5                    <== NOT EXECUTED
4000dfe4:	86 87 40 0d 	addcc  %i5, %o5, %g3                           <== NOT EXECUTED
4000dfe8:	84 47 00 0c 	addx  %i4, %o4, %g2                            <== NOT EXECUTED
4000dfec:	a6 10 20 00 	clr  %l3                                       <== NOT EXECUTED
4000dff0:	89 28 a0 02 	sll  %g2, 2, %g4                               <== NOT EXECUTED
                                                                      
  if (   number_of_clusters < FAT_FAT12_MAX_CLN                       
      && sectors_per_cluster <= ms_sectors_per_cluster_limit_FAT12 ) {
    fattype = FAT_FAT12;                                              
  }                                                                   
  else if (   number_of_clusters < FAT_FAT16_MAX_CLN                  
4000dff4:	f6 27 bd 40 	st  %i3, [ %fp + -704 ]                        <== 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;                 
4000dff8:	85 30 e0 1e 	srl  %g3, 0x1e, %g2                            <== NOT EXECUTED
                                                                      
  if (   number_of_clusters < FAT_FAT12_MAX_CLN                       
      && sectors_per_cluster <= ms_sectors_per_cluster_limit_FAT12 ) {
    fattype = FAT_FAT12;                                              
  }                                                                   
  else if (   number_of_clusters < FAT_FAT16_MAX_CLN                  
4000dffc:	ee 27 bd 3c 	st  %l7, [ %fp + -708 ]                        <== 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;                 
4000e000:	84 11 00 02 	or  %g4, %g2, %g2                              <== NOT EXECUTED
4000e004:	c4 27 bd 38 	st  %g2, [ %fp + -712 ]                        <== NOT EXECUTED
          && fmt_params->fattype != fat_type                          
          && fmt_params->totl_sector_cnt > 0 ) {                      
      /*                                                              
       * Skip aligning structures or d align them                     
       */                                                             
      if (ret_val == 0 && rqdata != NULL)                             
4000e008:	80 a5 a0 00 	cmp  %l6, 0                                    <== NOT EXECUTED
4000e00c:	02 80 00 05 	be  4000e020 <msdos_format+0x9d8>              <== NOT EXECUTED
4000e010:	d6 07 bd b8 	ld  [ %fp + -584 ], %o3                        <== NOT EXECUTED
        fmt_params->skip_alignment = rqdata->skip_alignment;          
4000e014:	c2 0e 60 16 	ldub  [ %i1 + 0x16 ], %g1                      <== NOT EXECUTED
4000e018:	c2 2f bd fc 	stb  %g1, [ %fp + -516 ]                       <== NOT EXECUTED
                                                                      
      if (ret_val == 0) {                                             
        msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,     
4000e01c:	d6 07 bd b8 	ld  [ %fp + -584 ], %o3                        <== NOT EXECUTED
4000e020:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
4000e024:	92 10 20 02 	mov  2, %o1                                    <== NOT EXECUTED
4000e028:	15 10 00 b2 	sethi  %hi(0x4002c800), %o2                    <== NOT EXECUTED
4000e02c:	7f ff fc cc 	call  4000d35c <msdos_format_printf>           <== NOT EXECUTED
4000e030:	94 12 a3 40 	or  %o2, 0x340, %o2	! 4002cb40 <_CPU_Trap_slot_template+0xd0><== NOT EXECUTED
                             "sectors per cluster: %d\n", fmt_params->sectors_per_cluster);
                                                                      
        if (fmt_params->fattype == FAT_FAT32) {                       
4000e034:	fa 0f bd de 	ldub  [ %fp + -546 ], %i5                      <== NOT EXECUTED
4000e038:	80 a7 60 04 	cmp  %i5, 4                                    <== NOT EXECUTED
4000e03c:	02 80 01 13 	be  4000e488 <msdos_format+0xe40>              <== NOT EXECUTED
4000e040:	88 10 20 01 	mov  1, %g4                                    <== 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) &&                                     
4000e044:	80 a5 a0 00 	cmp  %l6, 0                                    <== NOT EXECUTED
4000e048:	02 80 01 0a 	be  4000e470 <msdos_format+0xe28>              <== NOT EXECUTED
4000e04c:	c8 27 bd b4 	st  %g4, [ %fp + -588 ]                        <== NOT EXECUTED
              (rqdata->files_per_root_dir > 0)) {                     
4000e050:	d0 06 60 10 	ld  [ %i1 + 0x10 ], %o0                        <== 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) &&                                     
4000e054:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4000e058:	02 80 01 07 	be  4000e474 <msdos_format+0xe2c>              <== NOT EXECUTED
4000e05c:	82 1f 60 02 	xor  %i5, 2, %g1                               <== NOT EXECUTED
4000e060:	90 02 3f ff 	add  %o0, -1, %o0                              <== NOT EXECUTED
            else {                                                    
              fmt_params->files_per_root_dir = 64;                    
            }                                                         
          }                                                           
          fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
                                           (2*fmt_params->bytes_per_sector/
4000e064:	f6 07 bd ac 	ld  [ %fp + -596 ], %i3                        <== NOT EXECUTED
                                           FAT_DIRENTRY_SIZE-1));     
          fmt_params->files_per_root_dir -= (fmt_params->files_per_root_dir %
4000e068:	a8 10 20 01 	mov  1, %l4                                    <== NOT EXECUTED
            else {                                                    
              fmt_params->files_per_root_dir = 64;                    
            }                                                         
          }                                                           
          fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
                                           (2*fmt_params->bytes_per_sector/
4000e06c:	93 2e e0 01 	sll  %i3, 1, %o1                               <== NOT EXECUTED
4000e070:	93 32 60 05 	srl  %o1, 5, %o1                               <== NOT EXECUTED
            }                                                         
            else {                                                    
              fmt_params->files_per_root_dir = 64;                    
            }                                                         
          }                                                           
          fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
4000e074:	b8 02 00 09 	add  %o0, %o1, %i4                             <== NOT EXECUTED
                                           (2*fmt_params->bytes_per_sector/
                                           FAT_DIRENTRY_SIZE-1));     
          fmt_params->files_per_root_dir -= (fmt_params->files_per_root_dir %
4000e078:	40 00 6d 20 	call  400294f8 <.urem>                         <== NOT EXECUTED
4000e07c:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
4000e080:	90 27 00 08 	sub  %i4, %o0, %o0                             <== NOT EXECUTED
4000e084:	d0 27 bd c4 	st  %o0, [ %fp + -572 ]                        <== NOT EXECUTED
4000e088:	91 2a 20 05 	sll  %o0, 5, %o0                               <== NOT EXECUTED
                                                                      
        }                                                             
        fmt_params->root_dir_sectors =                                
          (((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)      
            + fmt_params->bytes_per_sector - 1)                       
           / fmt_params->bytes_per_sector);                           
4000e08c:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
                                            /FAT_DIRENTRY_SIZE));     
                                                                      
        }                                                             
        fmt_params->root_dir_sectors =                                
          (((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)      
            + fmt_params->bytes_per_sector - 1)                       
4000e090:	a4 06 ff ff 	add  %i3, -1, %l2                              <== NOT EXECUTED
           / fmt_params->bytes_per_sector);                           
4000e094:	7f ff d1 78 	call  40002674 <.udiv>                         <== NOT EXECUTED
4000e098:	90 04 80 08 	add  %l2, %o0, %o0                             <== NOT EXECUTED
      if (ret_val == 0) {                                             
        /*                                                            
         * check values to get legal arrangement of FAT type and cluster count
         */                                                           
                                                                      
        ret_val = msdos_format_eval_sectors_per_cluster(fmt_params->fattype,
4000e09c:	ee 07 bd b8 	ld  [ %fp + -584 ], %l7                        <== NOT EXECUTED
                                                                      
        }                                                             
        fmt_params->root_dir_sectors =                                
          (((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)      
            + fmt_params->bytes_per_sector - 1)                       
           / fmt_params->bytes_per_sector);                           
4000e0a0:	d0 27 bd 4c 	st  %o0, [ %fp + -692 ]                        <== 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 =                                
4000e0a4:	d0 27 bd c8 	st  %o0, [ %fp + -568 ]                        <== NOT EXECUTED
  uint32_t fatdata_sect_cnt;                                          
  uint32_t fat_sectors_cnt;                                           
  /*                                                                  
   * ensure, that maximum cluster size (32KByte) is not exceeded      
   */                                                                 
  while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
4000e0a8:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
4000e0ac:	7f ff d1 72 	call  40002674 <.udiv>                         <== NOT EXECUTED
4000e0b0:	11 00 00 20 	sethi  %hi(0x8000), %o0                        <== NOT EXECUTED
      if (ret_val == 0) {                                             
        /*                                                            
         * check values to get legal arrangement of FAT type and cluster count
         */                                                           
                                                                      
        ret_val = msdos_format_eval_sectors_per_cluster(fmt_params->fattype,
4000e0b4:	ea 07 bd b0 	ld  [ %fp + -592 ], %l5                        <== NOT EXECUTED
4000e0b8:	e2 0f bd dc 	ldub  [ %fp + -548 ], %l1                      <== NOT EXECUTED
  uint32_t fatdata_sect_cnt;                                          
  uint32_t fat_sectors_cnt;                                           
  /*                                                                  
   * ensure, that maximum cluster size (32KByte) is not exceeded      
   */                                                                 
  while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
4000e0bc:	80 a5 c0 08 	cmp  %l7, %o0                                  <== NOT EXECUTED
4000e0c0:	08 80 00 06 	bleu  4000e0d8 <msdos_format+0xa90>            <== NOT EXECUTED
4000e0c4:	f4 0f bd fc 	ldub  [ %fp + -516 ], %i2                      <== NOT EXECUTED
    sectors_per_cluster /= 2;                                         
4000e0c8:	af 35 e0 01 	srl  %l7, 1, %l7                               <== NOT EXECUTED
  uint32_t fatdata_sect_cnt;                                          
  uint32_t fat_sectors_cnt;                                           
  /*                                                                  
   * ensure, that maximum cluster size (32KByte) is not exceeded      
   */                                                                 
  while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
4000e0cc:	80 a2 00 17 	cmp  %o0, %l7                                  <== NOT EXECUTED
4000e0d0:	2a bf ff ff 	bcs,a   4000e0cc <msdos_format+0xa84>          <== NOT EXECUTED
4000e0d4:	af 35 e0 01 	srl  %l7, 1, %l7                               <== NOT EXECUTED
 loc_align_object (const uint32_t sectors,                            
                   const uint32_t clustersize,                        
                   const bool     skip_alignment)                     
{                                                                     
  if (! skip_alignment)                                               
    return (sectors + clustersize - 1) & ~(clustersize - 1);          
4000e0d8:	c4 07 bd 4c 	ld  [ %fp + -692 ], %g2                        <== 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_sect_cnt = total_sector_cnt                               
4000e0dc:	82 25 40 14 	sub  %l5, %l4, %g1                             <== NOT EXECUTED
 loc_align_object (const uint32_t sectors,                            
                   const uint32_t clustersize,                        
                   const bool     skip_alignment)                     
{                                                                     
  if (! skip_alignment)                                               
    return (sectors + clustersize - 1) & ~(clustersize - 1);          
4000e0e0:	84 00 bf ff 	add  %g2, -1, %g2                              <== NOT EXECUTED
4000e0e4:	a2 0c 60 ff 	and  %l1, 0xff, %l1                            <== NOT EXECUTED
4000e0e8:	b4 0e a0 ff 	and  %i2, 0xff, %i2                            <== 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_sect_cnt = total_sector_cnt                               
4000e0ec:	c2 27 bd 44 	st  %g1, [ %fp + -700 ]                        <== NOT EXECUTED
 loc_align_object (const uint32_t sectors,                            
                   const uint32_t clustersize,                        
                   const bool     skip_alignment)                     
{                                                                     
  if (! skip_alignment)                                               
    return (sectors + clustersize - 1) & ~(clustersize - 1);          
4000e0f0:	a8 05 3f ff 	add  %l4, -1, %l4                              <== NOT EXECUTED
4000e0f4:	c4 27 bd 48 	st  %g2, [ %fp + -696 ]                        <== NOT EXECUTED
static uint32_t                                                       
 loc_align_object (const uint32_t sectors,                            
                   const uint32_t clustersize,                        
                   const bool     skip_alignment)                     
{                                                                     
  if (! skip_alignment)                                               
4000e0f8:	80 a6 a0 00 	cmp  %i2, 0                                    <== NOT EXECUTED
4000e0fc:	02 80 00 0a 	be  4000e124 <msdos_format+0xadc>              <== NOT EXECUTED
4000e100:	82 20 00 17 	neg  %l7, %g1                                  <== NOT EXECUTED
     * - compute storage size for FAT                                 
     * - subtract from total cluster count                            
     */                                                               
    fatdata_sect_cnt = total_sector_cnt                               
      - loc_align_object (rsvd_sector_cnt, sectors_per_cluster, skip_alignment);
    if (fattype == FAT_FAT12) {                                       
4000e104:	80 a7 60 01 	cmp  %i5, 1                                    <== NOT EXECUTED
4000e108:	02 80 01 8e 	be  4000e740 <msdos_format+0x10f8>             <== NOT EXECUTED
4000e10c:	d0 07 bd 44 	ld  [ %fp + -700 ], %o0                        <== NOT EXECUTED
      fatdata_sect_cnt    = fatdata_sect_cnt                          
        - loc_align_object (root_dir_sector_cnt, sectors_per_cluster, skip_alignment);
      fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;     
      fat_capacity        = fatdata_cluster_cnt * 3 / 2;              
    }                                                                 
    else if (fattype == FAT_FAT16) {                                  
4000e110:	80 a7 60 02 	cmp  %i5, 2                                    <== NOT EXECUTED
4000e114:	12 80 00 0c 	bne  4000e144 <msdos_format+0xafc>             <== NOT EXECUTED
4000e118:	c2 07 bd 4c 	ld  [ %fp + -692 ], %g1                        <== NOT EXECUTED
      fatdata_sect_cnt    = fatdata_sect_cnt                          
        - loc_align_object (root_dir_sector_cnt, sectors_per_cluster, skip_alignment);
      fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;     
4000e11c:	10 80 00 99 	b  4000e380 <msdos_format+0xd38>               <== NOT EXECUTED
4000e120:	90 22 00 01 	sub  %o0, %g1, %o0                             <== NOT EXECUTED
 loc_align_object (const uint32_t sectors,                            
                   const uint32_t clustersize,                        
                   const bool     skip_alignment)                     
{                                                                     
  if (! skip_alignment)                                               
    return (sectors + clustersize - 1) & ~(clustersize - 1);          
4000e124:	90 05 00 17 	add  %l4, %l7, %o0                             <== NOT EXECUTED
     * - compute storage size for FAT                                 
     * - subtract from total cluster count                            
     */                                                               
    fatdata_sect_cnt = total_sector_cnt                               
      - loc_align_object (rsvd_sector_cnt, sectors_per_cluster, skip_alignment);
    if (fattype == FAT_FAT12) {                                       
4000e128:	80 a7 60 01 	cmp  %i5, 1                                    <== NOT EXECUTED
 loc_align_object (const uint32_t sectors,                            
                   const uint32_t clustersize,                        
                   const bool     skip_alignment)                     
{                                                                     
  if (! skip_alignment)                                               
    return (sectors + clustersize - 1) & ~(clustersize - 1);          
4000e12c:	90 08 40 08 	and  %g1, %o0, %o0                             <== NOT EXECUTED
     * - compute storage size for FAT                                 
     * - subtract from total cluster count                            
     */                                                               
    fatdata_sect_cnt = total_sector_cnt                               
      - loc_align_object (rsvd_sector_cnt, sectors_per_cluster, skip_alignment);
    if (fattype == FAT_FAT12) {                                       
4000e130:	02 80 00 86 	be  4000e348 <msdos_format+0xd00>              <== NOT EXECUTED
4000e134:	90 25 40 08 	sub  %l5, %o0, %o0                             <== NOT EXECUTED
      fatdata_sect_cnt    = fatdata_sect_cnt                          
        - loc_align_object (root_dir_sector_cnt, sectors_per_cluster, skip_alignment);
      fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;     
      fat_capacity        = fatdata_cluster_cnt * 3 / 2;              
    }                                                                 
    else if (fattype == FAT_FAT16) {                                  
4000e138:	80 a7 60 02 	cmp  %i5, 2                                    <== NOT EXECUTED
4000e13c:	02 80 00 8e 	be  4000e374 <msdos_format+0xd2c>              <== NOT EXECUTED
4000e140:	c8 07 bd 48 	ld  [ %fp + -696 ], %g4                        <== NOT EXECUTED
        - loc_align_object (root_dir_sector_cnt, sectors_per_cluster, skip_alignment);
      fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;     
      fat_capacity        = fatdata_cluster_cnt * 2;                  
    }                                                                 
    else { /* FAT32 */                                                
      fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;     
4000e144:	7f ff d1 4c 	call  40002674 <.udiv>                         <== NOT EXECUTED
4000e148:	92 10 00 17 	mov  %l7, %o1                                  <== NOT EXECUTED
4000e14c:	a0 10 00 08 	mov  %o0, %l0                                  <== NOT EXECUTED
      fat_capacity        = fatdata_cluster_cnt * 4;                  
4000e150:	91 2a 20 02 	sll  %o0, 2, %o0                               <== NOT EXECUTED
    }                                                                 
                                                                      
    sectors_per_fat = ((fat_capacity                                  
4000e154:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
4000e158:	7f ff d1 47 	call  40002674 <.udiv>                         <== NOT EXECUTED
4000e15c:	90 02 00 12 	add  %o0, %l2, %o0                             <== NOT EXECUTED
			+ (bytes_per_sector - 1))                                          
		       / bytes_per_sector);                                         
                                                                      
    fat_sectors_cnt = loc_align_object (sectors_per_fat * fat_num,    
4000e160:	7f ff d1 0b 	call  4000258c <.umul>                         <== NOT EXECUTED
4000e164:	92 10 00 11 	mov  %l1, %o1                                  <== NOT EXECUTED
static uint32_t                                                       
 loc_align_object (const uint32_t sectors,                            
                   const uint32_t clustersize,                        
                   const bool     skip_alignment)                     
{                                                                     
  if (! skip_alignment)                                               
4000e168:	80 a6 a0 00 	cmp  %i2, 0                                    <== NOT EXECUTED
                                                                      
    sectors_per_fat = ((fat_capacity                                  
			+ (bytes_per_sector - 1))                                          
		       / bytes_per_sector);                                         
                                                                      
    fat_sectors_cnt = loc_align_object (sectors_per_fat * fat_num,    
4000e16c:	b8 10 00 08 	mov  %o0, %i4                                  <== NOT EXECUTED
static uint32_t                                                       
 loc_align_object (const uint32_t sectors,                            
                   const uint32_t clustersize,                        
                   const bool     skip_alignment)                     
{                                                                     
  if (! skip_alignment)                                               
4000e170:	12 80 00 05 	bne  4000e184 <msdos_format+0xb3c>             <== NOT EXECUTED
4000e174:	90 05 ff ff 	add  %l7, -1, %o0                              <== NOT EXECUTED
    return (sectors + clustersize - 1) & ~(clustersize - 1);          
4000e178:	82 20 00 17 	neg  %l7, %g1                                  <== NOT EXECUTED
4000e17c:	b8 07 00 08 	add  %i4, %o0, %i4                             <== NOT EXECUTED
4000e180:	b8 0f 00 01 	and  %i4, %g1, %i4                             <== NOT EXECUTED
                                        skip_alignment);              
                                                                      
    *data_cluster_cnt = (fatdata_cluster_cnt -                        
			((fat_sectors_cnt                                                  
			  + (sectors_per_cluster - 1))                                     
			 / sectors_per_cluster));                                          
4000e184:	90 02 00 1c 	add  %o0, %i4, %o0                             <== NOT EXECUTED
4000e188:	7f ff d1 3b 	call  40002674 <.udiv>                         <== NOT EXECUTED
4000e18c:	92 10 00 17 	mov  %l7, %o1                                  <== NOT EXECUTED
    /*                                                                
     * data cluster count too big? Then make clusters bigger          
     */                                                               
    if (((fattype == FAT_FAT12) && (*data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
4000e190:	80 a7 60 01 	cmp  %i5, 1                                    <== NOT EXECUTED
4000e194:	02 80 00 54 	be  4000e2e4 <msdos_format+0xc9c>              <== NOT EXECUTED
4000e198:	b0 24 00 08 	sub  %l0, %o0, %i0                             <== NOT EXECUTED
4000e19c:	80 a7 60 02 	cmp  %i5, 2                                    <== NOT EXECUTED
4000e1a0:	02 80 00 62 	be  4000e328 <msdos_format+0xce0>              <== NOT EXECUTED
4000e1a4:	a0 10 20 01 	mov  1, %l0                                    <== NOT EXECUTED
     */                                                               
    if (fattype == FAT_FAT12) {                                       
      if (MS_BYTES_PER_CLUSTER_LIMIT_FAT12 < (sectors_per_cluster * bytes_per_sector)) {
        finished = true;                                              
      }                                                               
    } else if ((sectors_per_cluster * bytes_per_sector)               
4000e1a8:	90 10 00 17 	mov  %l7, %o0                                  <== NOT EXECUTED
4000e1ac:	7f ff d0 f8 	call  4000258c <.umul>                         <== NOT EXECUTED
4000e1b0:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
4000e1b4:	07 00 00 20 	sethi  %hi(0x8000), %g3                        <== NOT EXECUTED
4000e1b8:	80 a2 00 03 	cmp  %o0, %g3                                  <== NOT EXECUTED
4000e1bc:	08 80 00 57 	bleu  4000e318 <msdos_format+0xcd0>            <== NOT EXECUTED
4000e1c0:	80 8c 20 ff 	btst  0xff, %l0                                <== NOT EXECUTED
      finished = true;                                                
    }                                                                 
  } while (!finished);                                                
                                                                      
  *sectors_per_cluster_adj = sectors_per_cluster;                     
  *sectors_per_fat_ptr     = fat_sectors_cnt / fat_num;               
4000e1c4:	92 10 00 11 	mov  %l1, %o1                                  <== NOT EXECUTED
4000e1c8:	7f ff d1 2b 	call  40002674 <.udiv>                         <== NOT EXECUTED
4000e1cc:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
static uint8_t                                                        
msdos_get_fat_type( const uint32_t bytes_per_sector,                  
                    const uint32_t sectors_per_cluster,               
                    const uint32_t number_of_clusters )               
{                                                                     
  uint32_t ms_sectors_per_cluster_limit_FAT12 =                       
4000e1d0:	09 10 00 b2 	sethi  %hi(0x4002c800), %g4                    <== NOT EXECUTED
      finished = true;                                                
    }                                                                 
  } while (!finished);                                                
                                                                      
  *sectors_per_cluster_adj = sectors_per_cluster;                     
  *sectors_per_fat_ptr     = fat_sectors_cnt / fat_num;               
4000e1d4:	d0 27 bd bc 	st  %o0, [ %fp + -580 ]                        <== NOT EXECUTED
static uint8_t                                                        
msdos_get_fat_type( const uint32_t bytes_per_sector,                  
                    const uint32_t sectors_per_cluster,               
                    const uint32_t number_of_clusters )               
{                                                                     
  uint32_t ms_sectors_per_cluster_limit_FAT12 =                       
4000e1d8:	d0 01 23 f8 	ld  [ %g4 + 0x3f8 ], %o0                       <== NOT EXECUTED
4000e1dc:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
                                                        fmt_params->sectors_per_cluster,
                                                        fmt_params->skip_alignment,
                                                        §ors_per_cluster_adj,
                                                        &fmt_params->sectors_per_fat,
                                                        &data_clusters_cnt);
        fmt_params->sectors_per_cluster = sectors_per_cluster_adj;    
4000e1e0:	ee 27 bd b8 	st  %l7, [ %fp + -584 ]                        <== NOT EXECUTED
static uint8_t                                                        
msdos_get_fat_type( const uint32_t bytes_per_sector,                  
                    const uint32_t sectors_per_cluster,               
                    const uint32_t number_of_clusters )               
{                                                                     
  uint32_t ms_sectors_per_cluster_limit_FAT12 =                       
4000e1e4:	7f ff d1 24 	call  40002674 <.udiv>                         <== NOT EXECUTED
4000e1e8:	a0 10 00 18 	mov  %i0, %l0                                  <== NOT EXECUTED
    ( MS_BYTES_PER_CLUSTER_LIMIT_FAT12 +1 ) / bytes_per_sector;       
  uint32_t ms_sectors_per_cluster_limit_FAT16 =                       
    ( MS_BYTES_PER_CLUSTER_LIMIT +1 ) / bytes_per_sector;             
  uint8_t fattype = FAT_FAT32;                                        
                                                                      
  if (   number_of_clusters < FAT_FAT12_MAX_CLN                       
4000e1ec:	80 a2 00 17 	cmp  %o0, %l7                                  <== NOT EXECUTED
4000e1f0:	1a 80 00 69 	bcc  4000e394 <msdos_format+0xd4c>             <== NOT EXECUTED
4000e1f4:	80 a6 2f f4 	cmp  %i0, 0xff4                                <== NOT EXECUTED
                    const uint32_t sectors_per_cluster,               
                    const uint32_t number_of_clusters )               
{                                                                     
  uint32_t ms_sectors_per_cluster_limit_FAT12 =                       
    ( MS_BYTES_PER_CLUSTER_LIMIT_FAT12 +1 ) / bytes_per_sector;       
  uint32_t ms_sectors_per_cluster_limit_FAT16 =                       
4000e1f8:	03 10 00 b2 	sethi  %hi(0x4002c800), %g1                    <== NOT EXECUTED
4000e1fc:	d0 00 63 fc 	ld  [ %g1 + 0x3fc ], %o0	! 4002cbfc <_CPU_Trap_slot_template+0x18c><== NOT EXECUTED
4000e200:	7f ff d1 1d 	call  40002674 <.udiv>                         <== NOT EXECUTED
4000e204:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
                                                                      
  if (   number_of_clusters < FAT_FAT12_MAX_CLN                       
      && sectors_per_cluster <= ms_sectors_per_cluster_limit_FAT12 ) {
    fattype = FAT_FAT12;                                              
  }                                                                   
  else if (   number_of_clusters < FAT_FAT16_MAX_CLN                  
4000e208:	80 a2 00 17 	cmp  %o0, %l7                                  <== NOT EXECUTED
4000e20c:	2a 80 00 07 	bcs,a   4000e228 <msdos_format+0xbe0>          <== NOT EXECUTED
4000e210:	84 10 20 04 	mov  4, %g2                                    <== NOT EXECUTED
4000e214:	07 00 00 3f 	sethi  %hi(0xfc00), %g3                        <== NOT EXECUTED
4000e218:	86 10 e3 f4 	or  %g3, 0x3f4, %g3	! fff4 <PROM_START+0xfff4> <== NOT EXECUTED
4000e21c:	80 a0 c0 10 	cmp  %g3, %l0                                  <== NOT EXECUTED
4000e220:	0a 80 00 2f 	bcs  4000e2dc <msdos_format+0xc94>             <== NOT EXECUTED
4000e224:	84 10 20 02 	mov  2, %g2                                    <== NOT EXECUTED
          fmt_params->fattype = msdos_get_fat_type(                   
            fmt_params->bytes_per_sector,                             
            fmt_params->sectors_per_cluster,                          
            data_clusters_cnt );                                      
          /* Correct sectors per cluster to the fat type specific default value */
          if (fat_type != fmt_params->fattype) {                      
4000e228:	82 08 a0 ff 	and  %g2, 0xff, %g1                            <== NOT EXECUTED
4000e22c:	80 a7 40 01 	cmp  %i5, %g1                                  <== NOT EXECUTED
4000e230:	02 80 00 5f 	be  4000e3ac <msdos_format+0xd64>              <== NOT EXECUTED
4000e234:	c4 2f bd de 	stb  %g2, [ %fp + -546 ]                       <== NOT EXECUTED
msdos_set_default_sectors_per_cluster_for_fattype(                    
  msdos_format_param_t *fmt_params,                                   
  const uint64_t        total_size )                                  
{                                                                     
  if (   fmt_params->fattype == FAT_FAT12                             
      || fmt_params->fattype == FAT_FAT16 ) {                         
4000e238:	84 00 bf ff 	add  %g2, -1, %g2                              <== NOT EXECUTED
static void                                                           
msdos_set_default_sectors_per_cluster_for_fattype(                    
  msdos_format_param_t *fmt_params,                                   
  const uint64_t        total_size )                                  
{                                                                     
  if (   fmt_params->fattype == FAT_FAT12                             
4000e23c:	82 10 20 1f 	mov  0x1f, %g1                                 <== NOT EXECUTED
4000e240:	84 08 a0 ff 	and  %g2, 0xff, %g2                            <== NOT EXECUTED
4000e244:	80 a0 a0 01 	cmp  %g2, 1                                    <== NOT EXECUTED
4000e248:	18 80 00 06 	bgu  4000e260 <msdos_format+0xc18>             <== NOT EXECUTED
4000e24c:	c6 07 bd 38 	ld  [ %fp + -712 ], %g3                        <== NOT EXECUTED
      || fmt_params->fattype == FAT_FAT16 ) {                         
    /* start trying with small clusters */                            
    fmt_params->sectors_per_cluster = 2;                              
4000e250:	10 80 01 16 	b  4000e6a8 <msdos_format+0x1060>              <== NOT EXECUTED
4000e254:	82 10 20 02 	mov  2, %g1                                    <== NOT EXECUTED
  else {                                                              
    #define ONE_GB ( 1024L * 1024L * 1024L )                          
    uint32_t gigs = ( total_size + ONE_GB ) / ONE_GB;                 
    int b;                                                            
    /* scale with the size of disk... */                              
    for ( b = 31; b > 0; b-- ) {                                      
4000e258:	02 80 00 07 	be  4000e274 <msdos_format+0xc2c>              <== NOT EXECUTED
4000e25c:	84 10 20 01 	mov  1, %g2                                    <== NOT EXECUTED
      if ( (gigs & ( 1 << b) ) != 0 )                                 
4000e260:	88 10 20 01 	mov  1, %g4                                    <== NOT EXECUTED
4000e264:	85 29 00 01 	sll  %g4, %g1, %g2                             <== NOT EXECUTED
4000e268:	80 88 80 03 	btst  %g2, %g3                                 <== NOT EXECUTED
4000e26c:	02 bf ff fb 	be  4000e258 <msdos_format+0xc10>              <== NOT EXECUTED
4000e270:	82 80 7f ff 	addcc  %g1, -1, %g1                            <== NOT EXECUTED
        break;                                                        
    }                                                                 
    fmt_params->sectors_per_cluster = 1 << b;                         
4000e274:	c4 27 bd b8 	st  %g2, [ %fp + -584 ]                        <== NOT EXECUTED
            data_clusters_cnt );                                      
          /* Correct sectors per cluster to the fat type specific default value */
          if (fat_type != fmt_params->fattype) {                      
            msdos_set_default_sectors_per_cluster_for_fattype( fmt_params,
                                                               total_size );
            ret_val = msdos_set_sectors_per_cluster_from_request( rqdata,
4000e278:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
4000e27c:	7f ff fc d2 	call  4000d5c4 <msdos_set_sectors_per_cluster_from_request><== NOT EXECUTED
4000e280:	92 07 bd ac 	add  %fp, -596, %o1                            <== NOT EXECUTED
                                                                  fmt_params );
          }                                                           
        }                                                             
        if (fat_type != fmt_params->fattype && 1 < iteration_cnt) {   
4000e284:	c2 0f bd de 	ldub  [ %fp + -546 ], %g1                      <== NOT EXECUTED
4000e288:	84 08 60 ff 	and  %g1, 0xff, %g2                            <== NOT EXECUTED
4000e28c:	80 a7 40 02 	cmp  %i5, %g2                                  <== NOT EXECUTED
4000e290:	02 80 00 08 	be  4000e2b0 <msdos_format+0xc68>              <== NOT EXECUTED
4000e294:	ea 07 bd b0 	ld  [ %fp + -592 ], %l5                        <== NOT EXECUTED
4000e298:	84 0c e0 ff 	and  %l3, 0xff, %g2                            <== NOT EXECUTED
4000e29c:	80 a0 a0 01 	cmp  %g2, 1                                    <== NOT EXECUTED
4000e2a0:	08 80 00 05 	bleu  4000e2b4 <msdos_format+0xc6c>            <== NOT EXECUTED
4000e2a4:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
          --fmt_params->totl_sector_cnt;                              
4000e2a8:	aa 05 7f ff 	add  %l5, -1, %l5                              <== NOT EXECUTED
4000e2ac:	ea 27 bd b0 	st  %l5, [ %fp + -592 ]                        <== NOT EXECUTED
    if (ret_val == 0) {                                               
      data_clusters_cnt =                                             
        fmt_params->totl_sector_cnt / fmt_params->sectors_per_cluster;
    }                                                                 
                                                                      
    while(   ret_val == 0                                             
4000e2b0:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4000e2b4:	12 80 00 b6 	bne  4000e58c <msdos_format+0xf44>             <== NOT EXECUTED
4000e2b8:	a6 04 e0 01 	inc  %l3                                       <== NOT EXECUTED
          && fmt_params->fattype != fat_type                          
4000e2bc:	82 08 60 ff 	and  %g1, 0xff, %g1                            <== NOT EXECUTED
4000e2c0:	80 a7 40 01 	cmp  %i5, %g1                                  <== NOT EXECUTED
4000e2c4:	02 80 00 3a 	be  4000e3ac <msdos_format+0xd64>              <== NOT EXECUTED
4000e2c8:	80 a5 60 00 	cmp  %l5, 0                                    <== NOT EXECUTED
          && fmt_params->totl_sector_cnt > 0 ) {                      
4000e2cc:	12 bf ff 50 	bne  4000e00c <msdos_format+0x9c4>             <== NOT EXECUTED
4000e2d0:	80 a5 a0 00 	cmp  %l6, 0                                    <== NOT EXECUTED
4000e2d4:	10 bf fe ea 	b  4000de7c <msdos_format+0x834>               <== NOT EXECUTED
4000e2d8:	f6 07 bd 40 	ld  [ %fp + -704 ], %i3                        <== NOT EXECUTED
{                                                                     
  uint32_t ms_sectors_per_cluster_limit_FAT12 =                       
    ( MS_BYTES_PER_CLUSTER_LIMIT_FAT12 +1 ) / bytes_per_sector;       
  uint32_t ms_sectors_per_cluster_limit_FAT16 =                       
    ( MS_BYTES_PER_CLUSTER_LIMIT +1 ) / bytes_per_sector;             
  uint8_t fattype = FAT_FAT32;                                        
4000e2dc:	10 bf ff d3 	b  4000e228 <msdos_format+0xbe0>               <== NOT EXECUTED
4000e2e0:	84 10 20 04 	mov  4, %g2                                    <== NOT EXECUTED
			  + (sectors_per_cluster - 1))                                     
			 / sectors_per_cluster));                                          
    /*                                                                
     * data cluster count too big? Then make clusters bigger          
     */                                                               
    if (((fattype == FAT_FAT12) && (*data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
4000e2e4:	80 a6 2f f5 	cmp  %i0, 0xff5                                <== NOT EXECUTED
4000e2e8:	08 80 00 04 	bleu  4000e2f8 <msdos_format+0xcb0>            <== NOT EXECUTED
4000e2ec:	a0 10 20 01 	mov  1, %l0                                    <== NOT EXECUTED
        ((fattype == FAT_FAT16) && (*data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
      sectors_per_cluster *= 2;                                       
4000e2f0:	af 2d e0 01 	sll  %l7, 1, %l7                               <== NOT EXECUTED
4000e2f4:	a0 10 20 00 	clr  %l0                                       <== NOT EXECUTED
    }                                                                 
    /*                                                                
     * when maximum cluster size is exceeded, we have invalid data, abort...
     */                                                               
    if (fattype == FAT_FAT12) {                                       
      if (MS_BYTES_PER_CLUSTER_LIMIT_FAT12 < (sectors_per_cluster * bytes_per_sector)) {
4000e2f8:	90 10 00 17 	mov  %l7, %o0                                  <== NOT EXECUTED
4000e2fc:	7f ff d0 a4 	call  4000258c <.umul>                         <== NOT EXECUTED
4000e300:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
4000e304:	05 00 00 04 	sethi  %hi(0x1000), %g2                        <== NOT EXECUTED
4000e308:	80 a2 00 02 	cmp  %o0, %g2                                  <== NOT EXECUTED
4000e30c:	38 bf ff af 	bgu,a   4000e1c8 <msdos_format+0xb80>          <== NOT EXECUTED
4000e310:	92 10 00 11 	mov  %l1, %o1                                  <== NOT EXECUTED
      }                                                               
    } else if ((sectors_per_cluster * bytes_per_sector)               
	> MS_BYTES_PER_CLUSTER_LIMIT) {                                      
      finished = true;                                                
    }                                                                 
  } while (!finished);                                                
4000e314:	80 8c 20 ff 	btst  0xff, %l0                                <== NOT EXECUTED
4000e318:	02 bf ff 79 	be  4000e0fc <msdos_format+0xab4>              <== NOT EXECUTED
4000e31c:	80 a6 a0 00 	cmp  %i2, 0                                    <== NOT EXECUTED
                                                                      
  *sectors_per_cluster_adj = sectors_per_cluster;                     
  *sectors_per_fat_ptr     = fat_sectors_cnt / fat_num;               
4000e320:	10 bf ff aa 	b  4000e1c8 <msdos_format+0xb80>               <== NOT EXECUTED
4000e324:	92 10 00 11 	mov  %l1, %o1                                  <== NOT EXECUTED
			 / sectors_per_cluster));                                          
    /*                                                                
     * data cluster count too big? Then make clusters bigger          
     */                                                               
    if (((fattype == FAT_FAT12) && (*data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
        ((fattype == FAT_FAT16) && (*data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
4000e328:	03 00 00 3f 	sethi  %hi(0xfc00), %g1                        <== NOT EXECUTED
4000e32c:	82 10 63 f5 	or  %g1, 0x3f5, %g1	! fff5 <PROM_START+0xfff5> <== NOT EXECUTED
4000e330:	80 a6 00 01 	cmp  %i0, %g1                                  <== NOT EXECUTED
4000e334:	08 bf ff 9e 	bleu  4000e1ac <msdos_format+0xb64>            <== NOT EXECUTED
4000e338:	90 10 00 17 	mov  %l7, %o0                                  <== NOT EXECUTED
      sectors_per_cluster *= 2;                                       
4000e33c:	af 2d e0 01 	sll  %l7, 1, %l7                               <== NOT EXECUTED
4000e340:	10 bf ff 9a 	b  4000e1a8 <msdos_format+0xb60>               <== NOT EXECUTED
4000e344:	a0 10 20 00 	clr  %l0                                       <== NOT EXECUTED
 loc_align_object (const uint32_t sectors,                            
                   const uint32_t clustersize,                        
                   const bool     skip_alignment)                     
{                                                                     
  if (! skip_alignment)                                               
    return (sectors + clustersize - 1) & ~(clustersize - 1);          
4000e348:	c6 07 bd 48 	ld  [ %fp + -696 ], %g3                        <== NOT EXECUTED
4000e34c:	84 00 c0 17 	add  %g3, %l7, %g2                             <== NOT EXECUTED
4000e350:	82 08 80 01 	and  %g2, %g1, %g1                             <== NOT EXECUTED
    fatdata_sect_cnt = total_sector_cnt                               
      - loc_align_object (rsvd_sector_cnt, sectors_per_cluster, skip_alignment);
    if (fattype == FAT_FAT12) {                                       
      fatdata_sect_cnt    = fatdata_sect_cnt                          
        - loc_align_object (root_dir_sector_cnt, sectors_per_cluster, skip_alignment);
      fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;     
4000e354:	90 22 00 01 	sub  %o0, %g1, %o0                             <== NOT EXECUTED
4000e358:	7f ff d0 c7 	call  40002674 <.udiv>                         <== NOT EXECUTED
4000e35c:	92 10 00 17 	mov  %l7, %o1                                  <== NOT EXECUTED
4000e360:	a0 10 00 08 	mov  %o0, %l0                                  <== NOT EXECUTED
      fat_capacity        = fatdata_cluster_cnt * 3 / 2;              
4000e364:	91 2a 20 01 	sll  %o0, 1, %o0                               <== NOT EXECUTED
4000e368:	90 02 00 10 	add  %o0, %l0, %o0                             <== NOT EXECUTED
4000e36c:	10 bf ff 7a 	b  4000e154 <msdos_format+0xb0c>               <== NOT EXECUTED
4000e370:	91 32 20 01 	srl  %o0, 1, %o0                               <== NOT EXECUTED
 loc_align_object (const uint32_t sectors,                            
                   const uint32_t clustersize,                        
                   const bool     skip_alignment)                     
{                                                                     
  if (! skip_alignment)                                               
    return (sectors + clustersize - 1) & ~(clustersize - 1);          
4000e374:	84 01 00 17 	add  %g4, %l7, %g2                             <== NOT EXECUTED
4000e378:	82 08 40 02 	and  %g1, %g2, %g1                             <== NOT EXECUTED
      fat_capacity        = fatdata_cluster_cnt * 3 / 2;              
    }                                                                 
    else if (fattype == FAT_FAT16) {                                  
      fatdata_sect_cnt    = fatdata_sect_cnt                          
        - loc_align_object (root_dir_sector_cnt, sectors_per_cluster, skip_alignment);
      fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;     
4000e37c:	90 22 00 01 	sub  %o0, %g1, %o0                             <== NOT EXECUTED
4000e380:	7f ff d0 bd 	call  40002674 <.udiv>                         <== NOT EXECUTED
4000e384:	92 10 00 17 	mov  %l7, %o1                                  <== NOT EXECUTED
4000e388:	a0 10 00 08 	mov  %o0, %l0                                  <== NOT EXECUTED
      fat_capacity        = fatdata_cluster_cnt * 2;                  
4000e38c:	10 bf ff 72 	b  4000e154 <msdos_format+0xb0c>               <== NOT EXECUTED
4000e390:	91 2a 20 01 	sll  %o0, 1, %o0                               <== NOT EXECUTED
    ( MS_BYTES_PER_CLUSTER_LIMIT_FAT12 +1 ) / bytes_per_sector;       
  uint32_t ms_sectors_per_cluster_limit_FAT16 =                       
    ( MS_BYTES_PER_CLUSTER_LIMIT +1 ) / bytes_per_sector;             
  uint8_t fattype = FAT_FAT32;                                        
                                                                      
  if (   number_of_clusters < FAT_FAT12_MAX_CLN                       
4000e394:	18 bf ff 99 	bgu  4000e1f8 <msdos_format+0xbb0>             <== NOT EXECUTED
4000e398:	84 10 20 01 	mov  1, %g2                                    <== NOT EXECUTED
          fmt_params->fattype = msdos_get_fat_type(                   
            fmt_params->bytes_per_sector,                             
            fmt_params->sectors_per_cluster,                          
            data_clusters_cnt );                                      
          /* Correct sectors per cluster to the fat type specific default value */
          if (fat_type != fmt_params->fattype) {                      
4000e39c:	82 08 a0 ff 	and  %g2, 0xff, %g1                            <== NOT EXECUTED
4000e3a0:	80 a7 40 01 	cmp  %i5, %g1                                  <== NOT EXECUTED
4000e3a4:	12 bf ff a5 	bne  4000e238 <msdos_format+0xbf0>             <== NOT EXECUTED
4000e3a8:	c4 2f bd de 	stb  %g2, [ %fp + -546 ]                       <== NOT EXECUTED
4000e3ac:	f6 07 bd 40 	ld  [ %fp + -704 ], %i3                        <== NOT EXECUTED
4000e3b0:	ee 07 bd 3c 	ld  [ %fp + -708 ], %l7                        <== NOT EXECUTED
      }                                                               
                                                                      
      ++iteration_cnt;                                                
    }                                                                 
  }                                                                   
  if ( fmt_params->totl_sector_cnt == 0 )                             
4000e3b4:	80 a5 60 00 	cmp  %l5, 0                                    <== NOT EXECUTED
4000e3b8:	02 bf fe b1 	be  4000de7c <msdos_format+0x834>              <== NOT EXECUTED
4000e3bc:	c2 0f bd de 	ldub  [ %fp + -546 ], %g1                      <== NOT EXECUTED
    ret_val = -1;                                                     
  }                                                                   
                                                                      
  if (0 == ret_val)                                                   
  {                                                                   
    if (FAT_FAT32 != fmt_params->fattype)                             
4000e3c0:	80 a0 60 04 	cmp  %g1, 4                                    <== NOT EXECUTED
4000e3c4:	02 80 00 8b 	be  4000e5f0 <msdos_format+0xfa8>              <== NOT EXECUTED
4000e3c8:	d0 07 bd c8 	ld  [ %fp + -568 ], %o0                        <== NOT EXECUTED
static uint32_t                                                       
 loc_align_object (const uint32_t sectors,                            
                   const uint32_t clustersize,                        
                   const bool     skip_alignment)                     
{                                                                     
  if (! skip_alignment)                                               
4000e3cc:	f8 0f bd fc 	ldub  [ %fp + -516 ], %i4                      <== NOT EXECUTED
4000e3d0:	80 a7 20 00 	cmp  %i4, 0                                    <== NOT EXECUTED
4000e3d4:	12 80 00 06 	bne  4000e3ec <msdos_format+0xda4>             <== NOT EXECUTED
4000e3d8:	f4 07 bd b8 	ld  [ %fp + -584 ], %i2                        <== NOT EXECUTED
    return (sectors + clustersize - 1) & ~(clustersize - 1);          
4000e3dc:	90 02 00 1a 	add  %o0, %i2, %o0                             <== NOT EXECUTED
4000e3e0:	82 20 00 1a 	neg  %i2, %g1                                  <== NOT EXECUTED
4000e3e4:	90 02 3f ff 	add  %o0, -1, %o0                              <== NOT EXECUTED
4000e3e8:	90 0a 00 01 	and  %o0, %g1, %o0                             <== NOT EXECUTED
    if (FAT_FAT32 != fmt_params->fattype)                             
    {                                                                 
      fmt_params->files_per_root_dir = loc_align_object (fmt_params->root_dir_sectors,
                                                         fmt_params->sectors_per_cluster,
                                                         fmt_params->skip_alignment)
                                       * (fmt_params->bytes_per_sector / FAT_DIRENTRY_SIZE);
4000e3ec:	d2 07 bd ac 	ld  [ %fp + -596 ], %o1                        <== NOT EXECUTED
4000e3f0:	7f ff d0 67 	call  4000258c <.umul>                         <== NOT EXECUTED
4000e3f4:	93 32 60 05 	srl  %o1, 5, %o1                               <== NOT EXECUTED
                                                                      
  if (0 == ret_val)                                                   
  {                                                                   
    if (FAT_FAT32 != fmt_params->fattype)                             
    {                                                                 
      fmt_params->files_per_root_dir = loc_align_object (fmt_params->root_dir_sectors,
4000e3f8:	d0 27 bd c4 	st  %o0, [ %fp + -572 ]                        <== NOT EXECUTED
static uint32_t                                                       
 loc_align_object (const uint32_t sectors,                            
                   const uint32_t clustersize,                        
                   const bool     skip_alignment)                     
{                                                                     
  if (! skip_alignment)                                               
4000e3fc:	80 a7 20 00 	cmp  %i4, 0                                    <== NOT EXECUTED
4000e400:	12 80 00 06 	bne  4000e418 <msdos_format+0xdd0>             <== NOT EXECUTED
4000e404:	fa 07 bd b4 	ld  [ %fp + -588 ], %i5                        <== NOT EXECUTED
    return (sectors + clustersize - 1) & ~(clustersize - 1);          
4000e408:	ba 07 7f ff 	add  %i5, -1, %i5                              <== NOT EXECUTED
4000e40c:	82 20 00 1a 	neg  %i2, %g1                                  <== NOT EXECUTED
4000e410:	ba 07 40 1a 	add  %i5, %i2, %i5                             <== NOT EXECUTED
4000e414:	ba 0f 40 01 	and  %i5, %g1, %i5                             <== NOT EXECUTED
                                                                      
  /*                                                                  
   * determine media code                                             
   */                                                                 
  if (ret_val == 0) {                                                 
    if ((rqdata != NULL) &&                                           
4000e418:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
4000e41c:	02 80 00 26 	be  4000e4b4 <msdos_format+0xe6c>              <== NOT EXECUTED
4000e420:	fa 27 bd b4 	st  %i5, [ %fp + -588 ]                        <== NOT EXECUTED
	(rqdata->media != 0)) {                                              
4000e424:	f8 0e 60 14 	ldub  [ %i1 + 0x14 ], %i4                      <== NOT EXECUTED
                                                                      
  /*                                                                  
   * determine media code                                             
   */                                                                 
  if (ret_val == 0) {                                                 
    if ((rqdata != NULL) &&                                           
4000e428:	b4 8f 20 ff 	andcc  %i4, 0xff, %i2                          <== NOT EXECUTED
4000e42c:	02 80 00 23 	be  4000e4b8 <msdos_format+0xe70>              <== NOT EXECUTED
4000e430:	82 10 3f f8 	mov  -8, %g1                                   <== NOT EXECUTED
	(rqdata->media != 0)) {                                              
      const char valid_media_codes[] =                                
4000e434:	94 10 20 09 	mov  9, %o2                                    <== NOT EXECUTED
4000e438:	90 07 be 00 	add  %fp, -512, %o0                            <== NOT EXECUTED
4000e43c:	13 10 00 b2 	sethi  %hi(0x4002c800), %o1                    <== NOT EXECUTED
4000e440:	40 00 3a 79 	call  4001ce24 <memcpy>                        <== NOT EXECUTED
4000e444:	92 12 63 e8 	or  %o1, 0x3e8, %o1	! 4002cbe8 <_CPU_Trap_slot_template+0x178><== NOT EXECUTED
	{0xF0,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};                      
      if (NULL==memchr(valid_media_codes,                             
4000e448:	90 07 be 00 	add  %fp, -512, %o0                            <== NOT EXECUTED
4000e44c:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
4000e450:	40 00 3a 07 	call  4001cc6c <memchr>                        <== NOT EXECUTED
4000e454:	94 10 20 09 	mov  9, %o2                                    <== NOT EXECUTED
4000e458:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4000e45c:	02 80 00 b2 	be  4000e724 <msdos_format+0x10dc>             <== NOT EXECUTED
4000e460:	01 00 00 00 	nop                                            <== NOT EXECUTED
		       sizeof(valid_media_codes))) {                                
	ret_val = -1;                                                        
	errno = EINVAL;                                                      
      }                                                               
      else {                                                          
	fmt_params->media_code = rqdata->media;                              
4000e464:	f8 2f bd dd 	stb  %i4, [ %fp + -547 ]                       <== NOT EXECUTED
4000e468:	10 bf fc c3 	b  4000d774 <msdos_format+0x12c>               <== NOT EXECUTED
4000e46c:	f8 0f bd 57 	ldub  [ %fp + -681 ], %i4                      <== NOT EXECUTED
          if ((rqdata != NULL) &&                                     
              (rqdata->files_per_root_dir > 0)) {                     
            fmt_params->files_per_root_dir = rqdata->files_per_root_dir;
          }                                                           
          else {                                                      
            if (fmt_params->fattype == FAT_FAT16) {                   
4000e470:	82 1f 60 02 	xor  %i5, 2, %g1                               <== NOT EXECUTED
4000e474:	80 a0 00 01 	cmp  %g0, %g1                                  <== NOT EXECUTED
4000e478:	90 40 3f ff 	addx  %g0, -1, %o0                             <== NOT EXECUTED
4000e47c:	90 0a 21 c0 	and  %o0, 0x1c0, %o0                           <== NOT EXECUTED
4000e480:	10 bf fe f9 	b  4000e064 <msdos_format+0xa1c>               <== NOT EXECUTED
4000e484:	90 02 20 3f 	add  %o0, 0x3f, %o0                            <== NOT EXECUTED
        msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,     
                             "sectors per cluster: %d\n", fmt_params->sectors_per_cluster);
                                                                      
        if (fmt_params->fattype == FAT_FAT32) {                       
          /* recommended: for FAT32, always set reserved sector count to 32 */
          fmt_params->rsvd_sector_cnt = 32;                           
4000e488:	82 10 20 20 	mov  0x20, %g1                                 <== 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;                               
4000e48c:	84 10 20 06 	mov  6, %g2                                    <== NOT EXECUTED
          /* location of fsinfo sector */                             
          fmt_params->fsinfo_sec = 1;                                 
4000e490:	86 10 20 01 	mov  1, %g3                                    <== NOT EXECUTED
        msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,     
                             "sectors per cluster: %d\n", fmt_params->sectors_per_cluster);
                                                                      
        if (fmt_params->fattype == FAT_FAT32) {                       
          /* recommended: for FAT32, always set reserved sector count to 32 */
          fmt_params->rsvd_sector_cnt = 32;                           
4000e494:	c2 27 bd b4 	st  %g1, [ %fp + -588 ]                        <== NOT EXECUTED
          /* for FAT32, always set files per root directory 0 */      
          fmt_params->files_per_root_dir = 0;                         
4000e498:	c0 27 bd c4 	clr  [ %fp + -572 ]                            <== NOT EXECUTED
          /* location of copy of MBR */                               
          fmt_params->mbr_copy_sec = 6;                               
4000e49c:	c4 27 bd d4 	st  %g2, [ %fp + -556 ]                        <== NOT EXECUTED
          /* location of fsinfo sector */                             
          fmt_params->fsinfo_sec = 1;                                 
4000e4a0:	c6 27 bd d8 	st  %g3, [ %fp + -552 ]                        <== NOT EXECUTED
4000e4a4:	f6 07 bd ac 	ld  [ %fp + -596 ], %i3                        <== NOT EXECUTED
4000e4a8:	a8 10 20 20 	mov  0x20, %l4                                 <== NOT EXECUTED
4000e4ac:	10 bf fe f8 	b  4000e08c <msdos_format+0xa44>               <== NOT EXECUTED
4000e4b0:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
      else {                                                          
	fmt_params->media_code = rqdata->media;                              
      }                                                               
    }                                                                 
    else {                                                            
      fmt_params->media_code = FAT_BR_MEDIA_FIXED;                    
4000e4b4:	82 10 3f f8 	mov  -8, %g1                                   <== NOT EXECUTED
4000e4b8:	f8 0f bd 57 	ldub  [ %fp + -681 ], %i4                      <== NOT EXECUTED
4000e4bc:	10 bf fc ae 	b  4000d774 <msdos_format+0x12c>               <== NOT EXECUTED
4000e4c0:	c2 2f bd dd 	stb  %g1, [ %fp + -547 ]                       <== NOT EXECUTED
    if (fmt_params->totl_sector_cnt < FAT_FAT12_MAX_CLN * fat12_sect_per_clust) {
      fmt_params->fattype = FAT_FAT12;                                
      /* start trying with small clusters */                          
      fmt_params->sectors_per_cluster = 2;                            
    }                                                                 
    else if (fmt_params->totl_sector_cnt < FAT_FAT16_MAX_CLN * fat16_sect_per_clust) {
4000e4c4:	89 28 60 0e 	sll  %g1, 0xe, %g4                             <== NOT EXECUTED
4000e4c8:	86 21 00 03 	sub  %g4, %g3, %g3                             <== NOT EXECUTED
4000e4cc:	86 00 c0 01 	add  %g3, %g1, %g3                             <== NOT EXECUTED
4000e4d0:	87 28 e0 02 	sll  %g3, 2, %g3                               <== NOT EXECUTED
4000e4d4:	82 00 c0 01 	add  %g3, %g1, %g1                             <== NOT EXECUTED
4000e4d8:	80 a0 80 01 	cmp  %g2, %g1                                  <== NOT EXECUTED
4000e4dc:	2a 80 00 1f 	bcs,a   4000e558 <msdos_format+0xf10>          <== NOT EXECUTED
4000e4e0:	82 10 20 02 	mov  2, %g1                                    <== 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;                                
4000e4e4:	82 10 20 04 	mov  4, %g1                                    <== 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;                 
4000e4e8:	98 10 20 00 	clr  %o4                                       <== NOT EXECUTED
4000e4ec:	1b 10 00 00 	sethi  %hi(0x40000000), %o5                    <== NOT EXECUTED
4000e4f0:	86 87 40 0d 	addcc  %i5, %o5, %g3                           <== NOT EXECUTED
4000e4f4:	84 47 00 0c 	addx  %i4, %o4, %g2                            <== NOT EXECUTED
      int b;                                                          
      fmt_params->fattype = FAT_FAT32;                                
4000e4f8:	c2 2f bd de 	stb  %g1, [ %fp + -546 ]                       <== 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;                 
4000e4fc:	89 28 a0 02 	sll  %g2, 2, %g4                               <== NOT EXECUTED
      int b;                                                          
      fmt_params->fattype = FAT_FAT32;                                
      /* scale with the size of disk... */                            
      for (b = 31; b > 0; b--)                                        
4000e500:	82 10 20 1f 	mov  0x1f, %g1                                 <== 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;                 
4000e504:	85 30 e0 1e 	srl  %g3, 0x1e, %g2                            <== 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)                                   
4000e508:	86 10 20 01 	mov  1, %g3                                    <== 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;                 
4000e50c:	10 80 00 04 	b  4000e51c <msdos_format+0xed4>               <== NOT EXECUTED
4000e510:	88 11 00 02 	or  %g4, %g2, %g4                              <== NOT EXECUTED
      int b;                                                          
      fmt_params->fattype = FAT_FAT32;                                
      /* scale with the size of disk... */                            
      for (b = 31; b > 0; b--)                                        
4000e514:	02 80 00 67 	be  4000e6b0 <msdos_format+0x1068>             <== NOT EXECUTED
4000e518:	84 10 20 01 	mov  1, %g2                                    <== NOT EXECUTED
        if ((gigs & (1 << b)) != 0)                                   
4000e51c:	85 28 c0 01 	sll  %g3, %g1, %g2                             <== NOT EXECUTED
4000e520:	80 88 80 04 	btst  %g2, %g4                                 <== NOT EXECUTED
4000e524:	02 bf ff fc 	be  4000e514 <msdos_format+0xecc>              <== NOT EXECUTED
4000e528:	82 80 7f ff 	addcc  %g1, -1, %g1                            <== NOT EXECUTED
          break;                                                      
      fmt_params->sectors_per_cluster = 1 << b;                       
4000e52c:	10 bf fe 9d 	b  4000dfa0 <msdos_format+0x958>               <== NOT EXECUTED
4000e530:	c4 27 bd b8 	st  %g2, [ %fp + -584 ]                        <== 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             
     */                                                               
    uint32_t fat12_sect_per_clust = 8;                                
    uint32_t fat16_sect_per_clust = 32;                               
4000e534:	82 10 20 20 	mov  0x20, %g1                                 <== NOT EXECUTED
                                                                      
    if (rqdata != NULL && rqdata->sectors_per_cluster != 0) {         
4000e538:	10 bf fe 92 	b  4000df80 <msdos_format+0x938>               <== NOT EXECUTED
4000e53c:	86 10 e3 a8 	or  %g3, 0x3a8, %g3                            <== NOT EXECUTED
4000e540:	a1 30 60 08 	srl  %g1, 8, %l0                               <== 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) {                        
4000e544:	a2 10 20 00 	clr  %l1                                       <== NOT EXECUTED
4000e548:	a4 10 20 00 	clr  %l2                                       <== NOT EXECUTED
4000e54c:	a6 10 20 00 	clr  %l3                                       <== NOT EXECUTED
4000e550:	10 bf fd 0c 	b  4000d980 <msdos_format+0x338>               <== NOT EXECUTED
4000e554:	a8 10 20 00 	clr  %l4                                       <== NOT EXECUTED
      fmt_params->fattype = FAT_FAT12;                                
      /* start trying with small clusters */                          
      fmt_params->sectors_per_cluster = 2;                            
    }                                                                 
    else if (fmt_params->totl_sector_cnt < FAT_FAT16_MAX_CLN * fat16_sect_per_clust) {
      fmt_params->fattype = FAT_FAT16;                                
4000e558:	c2 2f bd de 	stb  %g1, [ %fp + -546 ]                       <== NOT EXECUTED
      /* start trying with small clusters */                          
      fmt_params->sectors_per_cluster = 2;                            
4000e55c:	82 10 20 02 	mov  2, %g1                                    <== NOT EXECUTED
4000e560:	10 bf fe 90 	b  4000dfa0 <msdos_format+0x958>               <== NOT EXECUTED
4000e564:	c2 27 bd b8 	st  %g1, [ %fp + -584 ]                        <== NOT EXECUTED
    }                                                                 
    else if (rqdata->fat_num <= 6) {                                  
      fmt_params->fat_num = rqdata->fat_num;                          
    }                                                                 
    else {                                                            
      errno = EINVAL;                                                 
4000e568:	40 00 37 8a 	call  4001c390 <__errno>                       <== NOT EXECUTED
4000e56c:	01 00 00 00 	nop                                            <== NOT EXECUTED
4000e570:	82 10 20 16 	mov  0x16, %g1	! 16 <PROM_START+0x16>          <== NOT EXECUTED
      ret_val = -1;                                                   
4000e574:	84 10 3f ff 	mov  -1, %g2                                   <== NOT EXECUTED
    }                                                                 
    else if (rqdata->fat_num <= 6) {                                  
      fmt_params->fat_num = rqdata->fat_num;                          
    }                                                                 
    else {                                                            
      errno = EINVAL;                                                 
4000e578:	10 bf fc 75 	b  4000d74c <msdos_format+0x104>               <== NOT EXECUTED
4000e57c:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
    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),                                 
	 fmt_params->VolLabel,                                               
	 FAT_BR_VOLLAB_SIZE);                                                
    memcpy(FAT_GET_ADDR_BR_FILSYSTYPE(mbr),                           
4000e580:	03 10 00 b2 	sethi  %hi(0x4002c800), %g1                    <== NOT EXECUTED
4000e584:	10 bf fd 3f 	b  4000da80 <msdos_format+0x438>               <== NOT EXECUTED
4000e588:	82 10 62 b0 	or  %g1, 0x2b0, %g1	! 4002cab0 <_CPU_Trap_slot_template+0x40><== NOT EXECUTED
4000e58c:	f6 07 bd 40 	ld  [ %fp + -704 ], %i3                        <== NOT EXECUTED
4000e590:	10 bf fc 73 	b  4000d75c <msdos_format+0x114>               <== NOT EXECUTED
4000e594:	84 10 00 08 	mov  %o0, %g2                                  <== NOT EXECUTED
  rc = rtems_clock_get_tod_timeval(&time_value);                      
  if (rc == RTEMS_SUCCESSFUL) {                                       
    *volid_ptr = time_value.tv_sec + time_value.tv_sec;               
  }                                                                   
  else {                                                              
    *volid_ptr = rand();                                              
4000e598:	40 00 3c df 	call  4001d914 <rand>                          <== NOT EXECUTED
4000e59c:	01 00 00 00 	nop                                            <== NOT EXECUTED
4000e5a0:	10 bf fc c5 	b  4000d8b4 <msdos_format+0x26c>               <== NOT EXECUTED
4000e5a4:	d0 27 bd f8 	st  %o0, [ %fp + -520 ]                        <== NOT EXECUTED
    if ((ret_val == 0) &&                                             
        (fmt_params.mbr_copy_sec != 0)) {                             
      /*                                                              
       * write copy of MBR                                            
       */                                                             
      msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,       
4000e5a8:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
4000e5ac:	15 10 00 b2 	sethi  %hi(0x4002c800), %o2                    <== NOT EXECUTED
4000e5b0:	7f ff fb 6b 	call  4000d35c <msdos_format_printf>           <== NOT EXECUTED
4000e5b4:	94 12 a3 90 	or  %o2, 0x390, %o2	! 4002cb90 <_CPU_Trap_slot_template+0x120><== NOT EXECUTED
                           "write back up MRB sector\n");             
      ret_val = msdos_format_write_sec(fd,                            
4000e5b8:	d2 07 bd d4 	ld  [ %fp + -556 ], %o1                        <== NOT EXECUTED
4000e5bc:	d4 07 bd ac 	ld  [ %fp + -596 ], %o2                        <== NOT EXECUTED
4000e5c0:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
4000e5c4:	7f ff fb 7b 	call  4000d3b0 <msdos_format_write_sec>        <== NOT EXECUTED
4000e5c8:	96 07 be 00 	add  %fp, -512, %o3                            <== NOT EXECUTED
    }                                                                 
  }                                                                   
  /*                                                                  
   * for FAT32: initialize info sector on disk                        
   */                                                                 
  if ((ret_val == 0) &&                                               
4000e5cc:	ae 92 20 00 	orcc  %o0, 0, %l7                              <== NOT EXECUTED
4000e5d0:	02 bf fd 4f 	be  4000db0c <msdos_format+0x4c4>              <== NOT EXECUTED
4000e5d4:	fa 07 bd d8 	ld  [ %fp + -552 ], %i5                        <== NOT EXECUTED
  /*                                                                  
   * cleanup:                                                         
   * sync and unlock disk                                             
   * free any data structures (not needed now)                        
   */                                                                 
  if (fd != -1) {                                                     
4000e5d8:	10 bf fc 4c 	b  4000d708 <msdos_format+0xc0>                <== NOT EXECUTED
4000e5dc:	80 a6 ff ff 	cmp  %i3, -1                                   <== 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 */     
4000e5e0:	10 bf fc 79 	b  4000d7c4 <msdos_format+0x17c>               <== NOT EXECUTED
4000e5e4:	88 11 22 d0 	or  %g4, 0x2d0, %g4                            <== NOT EXECUTED
   */                                                                 
  if (ret_val == 0) {                                                 
      const char *from;                                               
      char        *to = fmt_params->VolLabel;                         
      int          cnt;                                               
      from = ""; /* default: make "from" point to empty string */     
4000e5e8:	10 bf fc 97 	b  4000d844 <msdos_format+0x1fc>               <== NOT EXECUTED
4000e5ec:	88 11 21 30 	or  %g4, 0x130, %g4                            <== NOT EXECUTED
4000e5f0:	f4 07 bd b8 	ld  [ %fp + -584 ], %i2                        <== NOT EXECUTED
4000e5f4:	10 bf ff 82 	b  4000e3fc <msdos_format+0xdb4>               <== NOT EXECUTED
4000e5f8:	f8 0f bd fc 	ldub  [ %fp + -516 ], %i4                      <== NOT EXECUTED
	   ? "FAT12   "                                                      
	   : "FAT16   ",                                                     
	   FAT_BR_FILSYSTYPE_SIZE);                                          
  }                                                                   
  else {                                                              
    FAT_SET_BR_SECTORS_PER_FAT32(mbr   ,fmt_params->sectors_per_fat); 
4000e5fc:	c2 07 bd bc 	ld  [ %fp + -580 ], %g1                        <== 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 */
4000e600:	c4 07 bd d4 	ld  [ %fp + -556 ], %g2                        <== NOT EXECUTED
	   ? "FAT12   "                                                      
	   : "FAT16   ",                                                     
	   FAT_BR_FILSYSTYPE_SIZE);                                          
  }                                                                   
  else {                                                              
    FAT_SET_BR_SECTORS_PER_FAT32(mbr   ,fmt_params->sectors_per_fat); 
4000e604:	b1 30 60 08 	srl  %g1, 8, %i0                               <== NOT EXECUTED
4000e608:	bb 30 60 10 	srl  %g1, 0x10, %i5                            <== NOT EXECUTED
4000e60c:	89 30 60 18 	srl  %g1, 0x18, %g4                            <== NOT EXECUTED
4000e610:	c2 2f be 24 	stb  %g1, [ %fp + -476 ]                       <== 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);      
4000e614:	82 10 20 29 	mov  0x29, %g1                                 <== NOT EXECUTED
4000e618:	c2 2f be 42 	stb  %g1, [ %fp + -446 ]                       <== NOT EXECUTED
    FAT_SET_BR_FAT32_VOLID(mbr       , 0); /* not set */              
    memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr)   ,0,FAT_BR_VOLLAB_SIZE);
    memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),                     
4000e61c:	03 00 00 11 	sethi  %hi(0x4400), %g1                        <== NOT EXECUTED
4000e620:	82 10 62 41 	or  %g1, 0x241, %g1	! 4641 <PROM_START+0x4641> <== NOT EXECUTED
4000e624:	c2 37 be 52 	sth  %g1, [ %fp + -430 ]                       <== NOT EXECUTED
4000e628:	03 00 00 15 	sethi  %hi(0x5400), %g1                        <== NOT EXECUTED
4000e62c:	82 10 60 33 	or  %g1, 0x33, %g1	! 5433 <PROM_START+0x5433>  <== NOT EXECUTED
4000e630:	c2 37 be 54 	sth  %g1, [ %fp + -428 ]                       <== NOT EXECUTED
4000e634:	03 00 00 0c 	sethi  %hi(0x3000), %g1                        <== NOT EXECUTED
4000e638:	82 10 62 20 	or  %g1, 0x220, %g1	! 3220 <PROM_START+0x3220> <== 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 */
4000e63c:	87 30 a0 08 	srl  %g2, 8, %g3                               <== 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);
    memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),                     
4000e640:	c2 37 be 56 	sth  %g1, [ %fp + -426 ]                       <== NOT EXECUTED
	   ? "FAT12   "                                                      
	   : "FAT16   ",                                                     
	   FAT_BR_FILSYSTYPE_SIZE);                                          
  }                                                                   
  else {                                                              
    FAT_SET_BR_SECTORS_PER_FAT32(mbr   ,fmt_params->sectors_per_fat); 
4000e644:	f0 2f be 25 	stb  %i0, [ %fp + -475 ]                       <== 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);
    memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),                     
4000e648:	03 00 00 08 	sethi  %hi(0x2000), %g1                        <== NOT EXECUTED
	   ? "FAT12   "                                                      
	   : "FAT16   ",                                                     
	   FAT_BR_FILSYSTYPE_SIZE);                                          
  }                                                                   
  else {                                                              
    FAT_SET_BR_SECTORS_PER_FAT32(mbr   ,fmt_params->sectors_per_fat); 
4000e64c:	fa 2f be 26 	stb  %i5, [ %fp + -474 ]                       <== 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);
    memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),                     
4000e650:	82 10 60 20 	or  %g1, 0x20, %g1                             <== NOT EXECUTED
	   ? "FAT12   "                                                      
	   : "FAT16   ",                                                     
	   FAT_BR_FILSYSTYPE_SIZE);                                          
  }                                                                   
  else {                                                              
    FAT_SET_BR_SECTORS_PER_FAT32(mbr   ,fmt_params->sectors_per_fat); 
4000e654:	c8 2f be 27 	stb  %g4, [ %fp + -473 ]                       <== 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 */
4000e658:	f4 2f be 2c 	stb  %i2, [ %fp + -468 ]                       <== NOT EXECUTED
    FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo  to rsrvd sec 1*/
4000e65c:	f8 2f be 30 	stb  %i4, [ %fp + -464 ]                       <== NOT EXECUTED
    FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
4000e660:	c4 2f be 32 	stb  %g2, [ %fp + -462 ]                       <== NOT EXECUTED
4000e664:	c6 2f be 33 	stb  %g3, [ %fp + -461 ]                       <== NOT EXECUTED
    memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
4000e668:	c0 27 be 34 	clr  [ %fp + -460 ]                            <== NOT EXECUTED
4000e66c:	c0 27 be 38 	clr  [ %fp + -456 ]                            <== NOT EXECUTED
4000e670:	c0 27 be 3c 	clr  [ %fp + -452 ]                            <== 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);
4000e674:	c0 2f be 47 	clrb  [ %fp + -441 ]                           <== NOT EXECUTED
4000e678:	c0 2f be 48 	clrb  [ %fp + -440 ]                           <== NOT EXECUTED
4000e67c:	c0 2f be 49 	clrb  [ %fp + -439 ]                           <== NOT EXECUTED
4000e680:	c0 2f be 4a 	clrb  [ %fp + -438 ]                           <== NOT EXECUTED
4000e684:	c0 2f be 4b 	clrb  [ %fp + -437 ]                           <== NOT EXECUTED
4000e688:	c0 2f be 4c 	clrb  [ %fp + -436 ]                           <== NOT EXECUTED
4000e68c:	c0 2f be 4d 	clrb  [ %fp + -435 ]                           <== NOT EXECUTED
4000e690:	c0 2f be 4e 	clrb  [ %fp + -434 ]                           <== NOT EXECUTED
4000e694:	c0 2f be 4f 	clrb  [ %fp + -433 ]                           <== NOT EXECUTED
4000e698:	c0 2f be 50 	clrb  [ %fp + -432 ]                           <== NOT EXECUTED
4000e69c:	c0 2f be 51 	clrb  [ %fp + -431 ]                           <== NOT EXECUTED
    memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),                     
4000e6a0:	10 bf fd 00 	b  4000daa0 <msdos_format+0x458>               <== NOT EXECUTED
4000e6a4:	c2 37 be 58 	sth  %g1, [ %fp + -424 ]                       <== NOT EXECUTED
  const uint64_t        total_size )                                  
{                                                                     
  if (   fmt_params->fattype == FAT_FAT12                             
      || fmt_params->fattype == FAT_FAT16 ) {                         
    /* start trying with small clusters */                            
    fmt_params->sectors_per_cluster = 2;                              
4000e6a8:	10 bf fe f4 	b  4000e278 <msdos_format+0xc30>               <== NOT EXECUTED
4000e6ac:	c2 27 bd b8 	st  %g1, [ %fp + -584 ]                        <== NOT EXECUTED
      fmt_params->fattype = FAT_FAT32;                                
      /* 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;                       
4000e6b0:	10 bf fe 3c 	b  4000dfa0 <msdos_format+0x958>               <== NOT EXECUTED
4000e6b4:	c4 27 bd b8 	st  %g2, [ %fp + -584 ]                        <== NOT EXECUTED
4000e6b8:	c6 0f bd 57 	ldub  [ %fp + -681 ], %g3                      <== NOT EXECUTED
4000e6bc:	80 a0 00 08 	cmp  %g0, %o0                                  <== NOT EXECUTED
4000e6c0:	82 60 3f ff 	subx  %g0, -1, %g1                             <== NOT EXECUTED
4000e6c4:	10 bf fd 66 	b  4000dc5c <msdos_format+0x614>               <== NOT EXECUTED
4000e6c8:	82 08 40 03 	and  %g1, %g3, %g1                             <== NOT EXECUTED
      ret_val = -1;                                                   
    }                                                                 
  }                                                                   
                                                                      
  if (ret_val == 0)                                                   
    msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,         
4000e6cc:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
   * determine number of FATs                                         
   */                                                                 
  if (ret_val == 0) {                                                 
    if ((rqdata == NULL) ||                                           
	(rqdata->fat_num == 0)) {                                            
      fmt_params->fat_num = 2;                                        
4000e6d0:	c2 2f bd dc 	stb  %g1, [ %fp + -548 ]                       <== NOT EXECUTED
      ret_val = -1;                                                   
    }                                                                 
  }                                                                   
                                                                      
  if (ret_val == 0)                                                   
    msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,         
4000e6d4:	92 10 20 02 	mov  2, %o1                                    <== NOT EXECUTED
4000e6d8:	96 10 20 02 	mov  2, %o3                                    <== NOT EXECUTED
4000e6dc:	15 10 00 b2 	sethi  %hi(0x4002c800), %o2                    <== NOT EXECUTED
4000e6e0:	7f ff fb 1f 	call  4000d35c <msdos_format_printf>           <== NOT EXECUTED
4000e6e4:	94 12 a3 28 	or  %o2, 0x328, %o2	! 4002cb28 <_CPU_Trap_slot_template+0xb8><== NOT EXECUTED
  /*                                                                  
   * determine FAT type and sectors per cluster                       
   * depends on                                                       
   */                                                                 
  if (ret_val == 0) {                                                 
    fmt_params->sectors_per_cluster = 1;                              
4000e6e8:	07 00 00 1f 	sethi  %hi(0x7c00), %g3                        <== 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             
     */                                                               
    uint32_t fat12_sect_per_clust = 8;                                
    uint32_t fat16_sect_per_clust = 32;                               
4000e6ec:	82 10 20 20 	mov  0x20, %g1                                 <== NOT EXECUTED
  /*                                                                  
   * determine FAT type and sectors per cluster                       
   * depends on                                                       
   */                                                                 
  if (ret_val == 0) {                                                 
    fmt_params->sectors_per_cluster = 1;                              
4000e6f0:	10 bf fe 24 	b  4000df80 <msdos_format+0x938>               <== NOT EXECUTED
4000e6f4:	86 10 e3 a8 	or  %g3, 0x3a8, %g3                            <== NOT EXECUTED
4000e6f8:	80 a0 00 19 	cmp  %g0, %i1                                  <== NOT EXECUTED
4000e6fc:	ea 07 bd b0 	ld  [ %fp + -592 ], %l5                        <== NOT EXECUTED
4000e700:	82 40 20 00 	addx  %g0, 0, %g1                              <== NOT EXECUTED
    if (ret_val == 0) {                                               
      data_clusters_cnt =                                             
        fmt_params->totl_sector_cnt / fmt_params->sectors_per_cluster;
    }                                                                 
                                                                      
    while(   ret_val == 0                                             
4000e704:	84 10 00 17 	mov  %l7, %g2                                  <== NOT EXECUTED
4000e708:	10 bf fc 15 	b  4000d75c <msdos_format+0x114>               <== NOT EXECUTED
4000e70c:	c2 2f bd 57 	stb  %g1, [ %fp + -681 ]                       <== NOT EXECUTED
4000e710:	80 a0 00 19 	cmp  %g0, %i1                                  <== NOT EXECUTED
4000e714:	ea 07 bd b0 	ld  [ %fp + -592 ], %l5                        <== NOT EXECUTED
4000e718:	82 40 20 00 	addx  %g0, 0, %g1                              <== NOT EXECUTED
4000e71c:	10 bf ff 26 	b  4000e3b4 <msdos_format+0xd6c>               <== NOT EXECUTED
4000e720:	c2 2f bd 57 	stb  %g1, [ %fp + -681 ]                       <== NOT EXECUTED
	{0xF0,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};                      
      if (NULL==memchr(valid_media_codes,                             
		       rqdata->media,                                               
		       sizeof(valid_media_codes))) {                                
	ret_val = -1;                                                        
	errno = EINVAL;                                                      
4000e724:	40 00 37 1b 	call  4001c390 <__errno>                       <== NOT EXECUTED
4000e728:	b8 10 20 00 	clr  %i4                                       <== NOT EXECUTED
4000e72c:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
4000e730:	fa 07 bd b4 	ld  [ %fp + -588 ], %i5                        <== NOT EXECUTED
4000e734:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
      const char valid_media_codes[] =                                
	{0xF0,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};                      
      if (NULL==memchr(valid_media_codes,                             
		       rqdata->media,                                               
		       sizeof(valid_media_codes))) {                                
	ret_val = -1;                                                        
4000e738:	10 bf fc 0f 	b  4000d774 <msdos_format+0x12c>               <== NOT EXECUTED
4000e73c:	ae 10 3f ff 	mov  -1, %l7                                   <== NOT EXECUTED
                   const bool     skip_alignment)                     
{                                                                     
  if (! skip_alignment)                                               
    return (sectors + clustersize - 1) & ~(clustersize - 1);          
  else                                                                
    return sectors;                                                   
4000e740:	10 bf ff 05 	b  4000e354 <msdos_format+0xd0c>               <== NOT EXECUTED
4000e744:	c2 07 bd 4c 	ld  [ %fp + -692 ], %g1                        <== NOT EXECUTED
                                                                      

4000d410 <msdos_format_fill_sectors>: ) /*-------------------------------------------------------------------------*\ | Return Value: | | 0, if success, -1 and errno if failed | \*=========================================================================*/ {
4000d410:	9d e3 bf a0 	save  %sp, -96, %sp                            
                                                                      
  /*                                                                  
   * allocate and fill buffer                                         
   */                                                                 
  if (ret_val == 0) {                                                 
    fill_buffer = malloc(sector_size);                                
4000d414:	90 10 00 1c 	mov  %i4, %o0                                  
4000d418:	7f ff df 38 	call  400050f8 <malloc>                        
4000d41c:	a6 10 00 18 	mov  %i0, %l3                                  
    if (fill_buffer == NULL) {                                        
4000d420:	80 a2 20 00 	cmp  %o0, 0                                    
4000d424:	02 80 00 47 	be  4000d540 <msdos_format_fill_sectors+0x130> <== NEVER TAKEN
4000d428:	a4 10 00 08 	mov  %o0, %l2                                  
      errno = ENOMEM;                                                 
      ret_val = -1;                                                   
    }                                                                 
    else {                                                            
      memset(fill_buffer,fill_byte,sector_size);                      
4000d42c:	92 10 00 1d 	mov  %i5, %o1                                  
4000d430:	40 00 3e ba 	call  4001cf18 <memset>                        
4000d434:	94 10 00 1c 	mov  %i4, %o2                                  
    }                                                                 
  }                                                                   
                                                                      
  msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,           
4000d438:	90 10 00 18 	mov  %i0, %o0                                  
4000d43c:	92 10 20 02 	mov  2, %o1                                    
4000d440:	15 10 00 b2 	sethi  %hi(0x4002c800), %o2                    
4000d444:	7f ff ff c6 	call  4000d35c <msdos_format_printf>           
4000d448:	94 12 a2 80 	or  %o2, 0x280, %o2	! 4002ca80 <_CPU_Trap_slot_template+0x10>
                       "Filling : ");                                 
  /*                                                                  
   * write to consecutive sectors                                     
   */                                                                 
  while ((ret_val == 0) &&                                            
4000d44c:	80 a6 e0 00 	cmp  %i3, 0                                    
4000d450:	02 80 00 56 	be  4000d5a8 <msdos_format_fill_sectors+0x198> <== NEVER TAKEN
4000d454:	83 2e e0 04 	sll  %i3, 4, %g1                               
4000d458:	bb 2e e0 02 	sll  %i3, 2, %i5                               
	 (sector_cnt > 0)) {                                                 
    int percent = (sector_cnt * 100) / total_sectors;                 
    if (percent != last_percent) {                                    
      if ((percent & 1) == 0)                                         
        msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
4000d45c:	29 10 00 b2 	sethi  %hi(0x4002c800), %l4                    
4000d460:	ba 07 40 01 	add  %i5, %g1, %i5                             
  msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,           
                       "Filling : ");                                 
  /*                                                                  
   * write to consecutive sectors                                     
   */                                                                 
  while ((ret_val == 0) &&                                            
4000d464:	a0 10 00 1b 	mov  %i3, %l0                                  
4000d468:	83 2f 60 02 	sll  %i5, 2, %g1                               
\*=========================================================================*/
{                                                                     
  int ret_val = 0;                                                    
  char *fill_buffer = NULL;                                           
  uint32_t total_sectors = sector_cnt;                                
  int last_percent = -1;                                              
4000d46c:	a2 10 3f ff 	mov  -1, %l1                                   
4000d470:	ba 07 40 01 	add  %i5, %g1, %i5                             
  while ((ret_val == 0) &&                                            
	 (sector_cnt > 0)) {                                                 
    int percent = (sector_cnt * 100) / total_sectors;                 
    if (percent != last_percent) {                                    
      if ((percent & 1) == 0)                                         
        msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
4000d474:	10 80 00 10 	b  4000d4b4 <msdos_format_fill_sectors+0xa4>   
4000d478:	a8 15 20 28 	or  %l4, 0x28, %l4                             
      last_percent = percent;                                         
    }                                                                 
    ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
4000d47c:	92 10 00 1a 	mov  %i2, %o1                                  
4000d480:	90 10 00 19 	mov  %i1, %o0                                  
4000d484:	94 10 00 1c 	mov  %i4, %o2                                  
4000d488:	96 10 00 12 	mov  %l2, %o3                                  
4000d48c:	7f ff ff c9 	call  4000d3b0 <msdos_format_write_sec>        
4000d490:	a0 04 3f ff 	add  %l0, -1, %l0                              
    start_sector++;                                                   
4000d494:	b4 06 a0 01 	inc  %i2                                       
    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);
4000d498:	b0 10 00 08 	mov  %o0, %i0                                  
  msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,           
                       "Filling : ");                                 
  /*                                                                  
   * write to consecutive sectors                                     
   */                                                                 
  while ((ret_val == 0) &&                                            
4000d49c:	80 a2 20 00 	cmp  %o0, 0                                    
4000d4a0:	12 80 00 1c 	bne  4000d510 <msdos_format_fill_sectors+0x100><== NEVER TAKEN
4000d4a4:	ba 07 7f 9c 	add  %i5, -100, %i5                            
4000d4a8:	80 a4 20 00 	cmp  %l0, 0                                    
4000d4ac:	02 80 00 1a 	be  4000d514 <msdos_format_fill_sectors+0x104> 
4000d4b0:	90 10 00 13 	mov  %l3, %o0                                  
	 (sector_cnt > 0)) {                                                 
    int percent = (sector_cnt * 100) / total_sectors;                 
4000d4b4:	92 10 00 1b 	mov  %i3, %o1                                  
4000d4b8:	7f ff d4 6f 	call  40002674 <.udiv>                         
4000d4bc:	90 10 00 1d 	mov  %i5, %o0                                  
    if (percent != last_percent) {                                    
4000d4c0:	80 a2 00 11 	cmp  %o0, %l1                                  
4000d4c4:	02 bf ff ee 	be  4000d47c <msdos_format_fill_sectors+0x6c>  
4000d4c8:	80 8a 20 01 	btst  1, %o0                                   
      if ((percent & 1) == 0)                                         
4000d4cc:	12 bf ff ec 	bne  4000d47c <msdos_format_fill_sectors+0x6c> 
4000d4d0:	a2 10 00 08 	mov  %o0, %l1                                  
        msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
4000d4d4:	90 10 00 13 	mov  %l3, %o0                                  
4000d4d8:	92 10 20 02 	mov  2, %o1                                    
4000d4dc:	7f ff ff a0 	call  4000d35c <msdos_format_printf>           
4000d4e0:	94 10 00 14 	mov  %l4, %o2                                  
      last_percent = percent;                                         
    }                                                                 
    ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
4000d4e4:	92 10 00 1a 	mov  %i2, %o1                                  
4000d4e8:	90 10 00 19 	mov  %i1, %o0                                  
4000d4ec:	94 10 00 1c 	mov  %i4, %o2                                  
4000d4f0:	96 10 00 12 	mov  %l2, %o3                                  
4000d4f4:	7f ff ff af 	call  4000d3b0 <msdos_format_write_sec>        
4000d4f8:	a0 04 3f ff 	add  %l0, -1, %l0                              
    start_sector++;                                                   
4000d4fc:	b4 06 a0 01 	inc  %i2                                       
    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);
4000d500:	b0 10 00 08 	mov  %o0, %i0                                  
  msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,           
                       "Filling : ");                                 
  /*                                                                  
   * write to consecutive sectors                                     
   */                                                                 
  while ((ret_val == 0) &&                                            
4000d504:	80 a2 20 00 	cmp  %o0, 0                                    
4000d508:	02 bf ff e8 	be  4000d4a8 <msdos_format_fill_sectors+0x98>  <== ALWAYS TAKEN
4000d50c:	ba 07 7f 9c 	add  %i5, -100, %i5                            
    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");    
4000d510:	90 10 00 13 	mov  %l3, %o0                                  <== NOT EXECUTED
4000d514:	92 10 20 02 	mov  2, %o1                                    
4000d518:	15 10 00 b2 	sethi  %hi(0x4002c800), %o2                    
4000d51c:	7f ff ff 90 	call  4000d35c <msdos_format_printf>           
4000d520:	94 12 a3 88 	or  %o2, 0x388, %o2	! 4002cb88 <_CPU_Trap_slot_template+0x118>
                                                                      
  if (ret_val)                                                        
4000d524:	80 a6 20 00 	cmp  %i0, 0                                    
4000d528:	12 80 00 16 	bne  4000d580 <msdos_format_fill_sectors+0x170><== NEVER TAKEN
4000d52c:	90 10 00 13 	mov  %l3, %o0                                  
                                                                      
  /*                                                                  
   * cleanup                                                          
   */                                                                 
  if (fill_buffer != NULL) {                                          
    free(fill_buffer);                                                
4000d530:	7f ff dd 9f 	call  40004bac <free>                          
4000d534:	90 10 00 12 	mov  %l2, %o0                                  
4000d538:	81 c7 e0 08 	ret                                            
4000d53c:	81 e8 00 00 	restore                                        
   * allocate and fill buffer                                         
   */                                                                 
  if (ret_val == 0) {                                                 
    fill_buffer = malloc(sector_size);                                
    if (fill_buffer == NULL) {                                        
      errno = ENOMEM;                                                 
4000d540:	40 00 3b 94 	call  4001c390 <__errno>                       <== NOT EXECUTED
4000d544:	01 00 00 00 	nop                                            <== NOT EXECUTED
4000d548:	82 10 20 0c 	mov  0xc, %g1	! c <PROM_START+0xc>             <== NOT EXECUTED
    else {                                                            
      memset(fill_buffer,fill_byte,sector_size);                      
    }                                                                 
  }                                                                   
                                                                      
  msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,           
4000d54c:	92 10 20 02 	mov  2, %o1                                    <== NOT EXECUTED
   * allocate and fill buffer                                         
   */                                                                 
  if (ret_val == 0) {                                                 
    fill_buffer = malloc(sector_size);                                
    if (fill_buffer == NULL) {                                        
      errno = ENOMEM;                                                 
4000d550:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
    else {                                                            
      memset(fill_buffer,fill_byte,sector_size);                      
    }                                                                 
  }                                                                   
                                                                      
  msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,           
4000d554:	15 10 00 b2 	sethi  %hi(0x4002c800), %o2                    <== NOT EXECUTED
4000d558:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4000d55c:	7f ff ff 80 	call  4000d35c <msdos_format_printf>           <== NOT EXECUTED
4000d560:	94 12 a2 80 	or  %o2, 0x280, %o2                            <== 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");    
4000d564:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4000d568:	15 10 00 b2 	sethi  %hi(0x4002c800), %o2                    <== NOT EXECUTED
4000d56c:	92 10 20 02 	mov  2, %o1                                    <== NOT EXECUTED
   */                                                                 
  if (ret_val == 0) {                                                 
    fill_buffer = malloc(sector_size);                                
    if (fill_buffer == NULL) {                                        
      errno = ENOMEM;                                                 
      ret_val = -1;                                                   
4000d570:	b0 10 3f ff 	mov  -1, %i0                                   <== 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");    
4000d574:	7f ff ff 7a 	call  4000d35c <msdos_format_printf>           <== NOT EXECUTED
4000d578:	94 12 a3 88 	or  %o2, 0x388, %o2                            <== NOT EXECUTED
                                                                      
  if (ret_val)                                                        
    msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,           
4000d57c:	90 10 00 13 	mov  %l3, %o0                                  <== NOT EXECUTED
4000d580:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
4000d584:	96 10 00 1a 	mov  %i2, %o3                                  <== NOT EXECUTED
4000d588:	15 10 00 b2 	sethi  %hi(0x4002c800), %o2                    <== NOT EXECUTED
4000d58c:	7f ff ff 74 	call  4000d35c <msdos_format_printf>           <== NOT EXECUTED
4000d590:	94 12 a2 90 	or  %o2, 0x290, %o2	! 4002ca90 <_CPU_Trap_slot_template+0x20><== NOT EXECUTED
                         "filling error on sector: %d\n", start_sector);
                                                                      
  /*                                                                  
   * cleanup                                                          
   */                                                                 
  if (fill_buffer != NULL) {                                          
4000d594:	80 a4 a0 00 	cmp  %l2, 0                                    <== NOT EXECUTED
4000d598:	12 bf ff e6 	bne  4000d530 <msdos_format_fill_sectors+0x120><== NOT EXECUTED
4000d59c:	01 00 00 00 	nop                                            <== NOT EXECUTED
    free(fill_buffer);                                                
    fill_buffer = NULL;                                               
  }                                                                   
  return ret_val;                                                     
}                                                                     
4000d5a0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000d5a4:	81 e8 00 00 	restore                                        <== 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");    
4000d5a8:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4000d5ac:	92 10 20 02 	mov  2, %o1                                    <== NOT EXECUTED
/*-------------------------------------------------------------------------*\
| Return Value:                                                             |
|    0, if success, -1 and errno if failed                                  |
\*=========================================================================*/
{                                                                     
  int ret_val = 0;                                                    
4000d5b0:	b0 10 20 00 	clr  %i0                                       <== 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");    
4000d5b4:	15 10 00 b2 	sethi  %hi(0x4002c800), %o2                    <== NOT EXECUTED
4000d5b8:	7f ff ff 69 	call  4000d35c <msdos_format_printf>           <== NOT EXECUTED
4000d5bc:	94 12 a3 88 	or  %o2, 0x388, %o2	! 4002cb88 <_CPU_Trap_slot_template+0x118><== NOT EXECUTED
4000d5c0:	30 bf ff dc 	b,a   4000d530 <msdos_format_fill_sectors+0x120><== NOT EXECUTED
                                                                      

4000d35c <msdos_format_printf>: */ static void msdos_format_printf (const msdos_format_request_param_t *rqdata, int info_level, const char *format, ...) {
4000d35c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  va_list args;                                                       
  va_start (args, format);                                            
4000d360:	94 07 a0 50 	add  %fp, 0x50, %o2                            
4000d364:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]                        
4000d368:	f8 27 a0 54 	st  %i4, [ %fp + 0x54 ]                        
4000d36c:	fa 27 a0 58 	st  %i5, [ %fp + 0x58 ]                        
  if (rqdata != NULL && rqdata->info_level >= info_level)             
4000d370:	80 a6 20 00 	cmp  %i0, 0                                    
4000d374:	02 80 00 0d 	be  4000d3a8 <msdos_format_printf+0x4c>        
4000d378:	d4 27 bf fc 	st  %o2, [ %fp + -4 ]                          
4000d37c:	c2 06 20 18 	ld  [ %i0 + 0x18 ], %g1                        
4000d380:	80 a0 40 19 	cmp  %g1, %i1                                  
4000d384:	06 80 00 09 	bl  4000d3a8 <msdos_format_printf+0x4c>        <== ALWAYS TAKEN
4000d388:	3b 10 00 b6 	sethi  %hi(0x4002d800), %i5                    
  {                                                                   
    vfprintf (stdout, format, args);                                  
4000d38c:	c2 07 63 48 	ld  [ %i5 + 0x348 ], %g1	! 4002db48 <_impure_ptr><== NOT EXECUTED
4000d390:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
4000d394:	40 00 5d 0c 	call  400247c4 <vfprintf>                      <== NOT EXECUTED
4000d398:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           <== NOT EXECUTED
    fflush (stdout);                                                  
4000d39c:	c2 07 63 48 	ld  [ %i5 + 0x348 ], %g1                       <== NOT EXECUTED
4000d3a0:	40 00 3c ff 	call  4001c79c <fflush>                        <== NOT EXECUTED
4000d3a4:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           <== NOT EXECUTED
4000d3a8:	81 c7 e0 08 	ret                                            
4000d3ac:	81 e8 00 00 	restore                                        
                                                                      

4000d3b0 <msdos_format_write_sec>: ) /*-------------------------------------------------------------------------*\ | Return Value: | | 0, if success, -1 and errno if failed | \*=========================================================================*/ {
4000d3b0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int ret_val = 0;                                                    
                                                                      
  if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {     
4000d3b4:	94 10 20 00 	clr  %o2                                       
4000d3b8:	96 10 00 1a 	mov  %i2, %o3                                  
4000d3bc:	90 10 20 00 	clr  %o0                                       
4000d3c0:	7f ff d3 56 	call  40002118 <__muldi3>                      
4000d3c4:	92 10 00 19 	mov  %i1, %o1                                  
4000d3c8:	84 10 00 08 	mov  %o0, %g2                                  
4000d3cc:	86 10 00 09 	mov  %o1, %g3                                  
4000d3d0:	90 10 00 18 	mov  %i0, %o0                                  
4000d3d4:	92 10 00 02 	mov  %g2, %o1                                  
4000d3d8:	94 10 00 03 	mov  %g3, %o2                                  
4000d3dc:	40 00 1f 49 	call  40015100 <lseek>                         
4000d3e0:	96 10 20 00 	clr  %o3                                       
4000d3e4:	80 a2 20 00 	cmp  %o0, 0                                    
4000d3e8:	16 80 00 04 	bge  4000d3f8 <msdos_format_write_sec+0x48>    <== ALWAYS TAKEN
4000d3ec:	90 10 00 18 	mov  %i0, %o0                                  
4000d3f0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000d3f4:	91 e8 3f ff 	restore  %g0, -1, %o0                          <== NOT EXECUTED
    ret_val = -1;                                                     
  }                                                                   
  if (ret_val == 0) {                                                 
    if (0 > write(fd,buffer,sector_size)) {                           
4000d3f8:	92 10 00 1b 	mov  %i3, %o1                                  
4000d3fc:	7f ff ee 0f 	call  40008c38 <write>                         
4000d400:	94 10 00 1a 	mov  %i2, %o2                                  
4000d404:	b1 3a 20 1f 	sra  %o0, 0x1f, %i0                            
      ret_val = -1;                                                   
    }                                                                 
  }                                                                   
                                                                      
  return ret_val;                                                     
}                                                                     
4000d408:	81 c7 e0 08 	ret                                            
4000d40c:	81 e8 00 00 	restore                                        
                                                                      

400199a4 <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 ) {
400199a4:	9d e3 bf 50 	save  %sp, -176, %sp                           
    int              rc = RC_OK;                                      
    msdos_fs_info_t *fs_info = mt_entry->fs_info;                     
400199a8:	f8 06 20 08 	ld  [ %i0 + 8 ], %i4                           
    fat_file_fd_t   *fat_fd = NULL;                                   
400199ac:	c0 27 bf bc 	clr  [ %fp + -68 ]                             
    uint32_t         cl4find = 0;                                     
                                                                      
    /*                                                                
     * open fat-file corresponded to ".."                             
     */                                                               
    rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);              
400199b0:	90 10 00 1c 	mov  %i4, %o0                                  
400199b4:	92 10 00 1a 	mov  %i2, %o1                                  
400199b8:	7f ff e2 bc 	call  400124a8 <fat_file_open>                 
400199bc:	94 07 bf bc 	add  %fp, -68, %o2                             
    if (rc != RC_OK)                                                  
400199c0:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400199c4:	02 80 00 04 	be  400199d4 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x30><== ALWAYS TAKEN
400199c8:	d2 07 bf bc 	ld  [ %fp + -68 ], %o1                         
        fat_file_close(&fs_info->fat, fat_fd);                        
        return rc;                                                    
    }                                                                 
    rc = fat_file_close(&fs_info->fat, fat_fd);                       
    return rc;                                                        
}                                                                     
400199cc:	81 c7 e0 08 	ret                                            
400199d0:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
    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;                        
400199d4:	05 00 08 00 	sethi  %hi(0x200000), %g2                      
     */                                                               
    rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);              
    if (rc != RC_OK)                                                  
        return rc;                                                    
                                                                      
    fat_fd->cln = cln;                                                
400199d8:	f2 22 60 1c 	st  %i1, [ %o1 + 0x1c ]                        
    fat_fd->fat_file_type = FAT_DIRECTORY;                            
400199dc:	c0 22 60 10 	clr  [ %o1 + 0x10 ]                            
    fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                        
400199e0:	c4 22 60 14 	st  %g2, [ %o1 + 0x14 ]                        
                                                                      
    fat_fd->map.file_cln = 0;                                         
400199e4:	c0 22 60 34 	clr  [ %o1 + 0x34 ]                            
    fat_fd->map.disk_cln = fat_fd->cln;                               
400199e8:	f2 22 60 38 	st  %i1, [ %o1 + 0x38 ]                        
                                                                      
    rc = fat_file_size(&fs_info->fat, fat_fd);                        
400199ec:	7f ff e5 e5 	call  40013180 <fat_file_size>                 
400199f0:	90 10 00 1c 	mov  %i4, %o0                                  
    if (rc != RC_OK)                                                  
400199f4:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400199f8:	12 80 00 95 	bne  40019c4c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2a8><== NEVER TAKEN
400199fc:	33 10 00 b2 	sethi  %hi(0x4002c800), %i1                    
        fat_file_close(&fs_info->fat, fat_fd);                        
        return rc;                                                    
    }                                                                 
                                                                      
    /* find "." node in opened directory */                           
    memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);           
40019a00:	ba 07 bf c0 	add  %fp, -64, %i5                             
    msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);      
40019a04:	94 10 00 1d 	mov  %i5, %o2                                  
40019a08:	92 10 20 01 	mov  1, %o1                                    
40019a0c:	96 10 20 0b 	mov  0xb, %o3                                  
        fat_file_close(&fs_info->fat, fat_fd);                        
        return rc;                                                    
    }                                                                 
                                                                      
    /* find "." node in opened directory */                           
    memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);           
40019a10:	c0 27 bf c0 	clr  [ %fp + -64 ]                             
40019a14:	c0 27 bf c4 	clr  [ %fp + -60 ]                             
40019a18:	c0 27 bf c8 	clr  [ %fp + -56 ]                             
40019a1c:	c0 27 bf cc 	clr  [ %fp + -52 ]                             
40019a20:	c0 27 bf d0 	clr  [ %fp + -48 ]                             
40019a24:	c0 27 bf d4 	clr  [ %fp + -44 ]                             
40019a28:	c0 27 bf d8 	clr  [ %fp + -40 ]                             
40019a2c:	c0 27 bf dc 	clr  [ %fp + -36 ]                             
    msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);      
40019a30:	7f ff fa eb 	call  400185dc <msdos_long_to_short>           
40019a34:	90 16 60 28 	or  %i1, 0x28, %o0                             
    rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, ".", 1, 
40019a38:	d2 07 bf bc 	ld  [ %fp + -68 ], %o1                         
40019a3c:	fa 23 a0 60 	st  %i5, [ %sp + 0x60 ]                        
40019a40:	f4 23 a0 5c 	st  %i2, [ %sp + 0x5c ]                        
40019a44:	90 10 00 18 	mov  %i0, %o0                                  
40019a48:	94 10 20 00 	clr  %o2                                       
40019a4c:	96 16 60 28 	or  %i1, 0x28, %o3                             
40019a50:	98 10 20 01 	mov  1, %o4                                    
40019a54:	7f ff fc da 	call  40018dbc <msdos_find_name_in_fat_file>   
40019a58:	9a 10 20 01 	mov  1, %o5                                    
                                     MSDOS_NAME_SHORT, dir_pos, dot_node);
                                                                      
    if (rc != RC_OK)                                                  
40019a5c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40019a60:	12 80 00 7b 	bne  40019c4c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2a8><== NEVER TAKEN
40019a64:	33 10 00 b3 	sethi  %hi(0x4002cc00), %i1                    
        fat_file_close(&fs_info->fat, fat_fd);                        
        return rc;                                                    
    }                                                                 
                                                                      
    /* find ".." node in opened directory */                          
    memset(dotdot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);        
40019a68:	ba 07 bf e0 	add  %fp, -32, %i5                             
    msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);  
40019a6c:	94 10 00 1d 	mov  %i5, %o2                                  
40019a70:	92 10 20 02 	mov  2, %o1                                    
40019a74:	96 10 20 0b 	mov  0xb, %o3                                  
        fat_file_close(&fs_info->fat, fat_fd);                        
        return rc;                                                    
    }                                                                 
                                                                      
    /* find ".." node in opened directory */                          
    memset(dotdot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);        
40019a78:	c0 27 bf e0 	clr  [ %fp + -32 ]                             
40019a7c:	c0 27 bf e4 	clr  [ %fp + -28 ]                             
40019a80:	c0 27 bf e8 	clr  [ %fp + -24 ]                             
40019a84:	c0 27 bf ec 	clr  [ %fp + -20 ]                             
40019a88:	c0 27 bf f0 	clr  [ %fp + -16 ]                             
40019a8c:	c0 27 bf f4 	clr  [ %fp + -12 ]                             
40019a90:	c0 27 bf f8 	clr  [ %fp + -8 ]                              
40019a94:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
    msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);  
40019a98:	7f ff fa d1 	call  400185dc <msdos_long_to_short>           
40019a9c:	90 16 62 b0 	or  %i1, 0x2b0, %o0                            
    rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, "..", 2,
40019aa0:	d2 07 bf bc 	ld  [ %fp + -68 ], %o1                         
40019aa4:	fa 23 a0 60 	st  %i5, [ %sp + 0x60 ]                        
40019aa8:	f4 23 a0 5c 	st  %i2, [ %sp + 0x5c ]                        
40019aac:	90 10 00 18 	mov  %i0, %o0                                  
40019ab0:	94 10 20 00 	clr  %o2                                       
40019ab4:	96 16 62 b0 	or  %i1, 0x2b0, %o3                            
40019ab8:	98 10 20 02 	mov  2, %o4                                    
40019abc:	7f ff fc c0 	call  40018dbc <msdos_find_name_in_fat_file>   
40019ac0:	9a 10 20 01 	mov  1, %o5                                    
                                     MSDOS_NAME_SHORT, dir_pos,       
                                     dotdot_node);                    
                                                                      
    if (rc != RC_OK)                                                  
    {                                                                 
        fat_file_close(&fs_info->fat, fat_fd);                        
40019ac4:	d2 07 bf bc 	ld  [ %fp + -68 ], %o1                         
    msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);  
    rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, "..", 2,
                                     MSDOS_NAME_SHORT, dir_pos,       
                                     dotdot_node);                    
                                                                      
    if (rc != RC_OK)                                                  
40019ac8:	80 a2 20 00 	cmp  %o0, 0                                    
40019acc:	12 80 00 66 	bne  40019c64 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2c0><== NEVER TAKEN
40019ad0:	ba 10 00 08 	mov  %o0, %i5                                  
    {                                                                 
        fat_file_close(&fs_info->fat, fat_fd);                        
        return rc;                                                    
    }                                                                 
                                                                      
    cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);                    
40019ad4:	f2 17 bf da 	lduh  [ %fp + -38 ], %i1                       
40019ad8:	e0 17 bf d4 	lduh  [ %fp + -44 ], %l0                       
                                                                      
    /* close fat-file corresponded to ".." directory */               
    rc = fat_file_close(&fs_info->fat, fat_fd);                       
40019adc:	7f ff e3 ed 	call  40012a90 <fat_file_close>                
40019ae0:	90 10 00 1c 	mov  %i4, %o0                                  
    if ( rc != RC_OK )                                                
40019ae4:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40019ae8:	12 bf ff b9 	bne  400199cc <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x28><== NEVER TAKEN
40019aec:	c4 17 bf fa 	lduh  [ %fp + -6 ], %g2                        
        return rc;                                                    
                                                                      
    if ( (MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)               
40019af0:	c6 17 bf f4 	lduh  [ %fp + -12 ], %g3                       
40019af4:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
40019af8:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
40019afc:	89 30 a0 18 	srl  %g2, 0x18, %g4                            
40019b00:	bb 30 e0 18 	srl  %g3, 0x18, %i5                            
40019b04:	03 00 00 3f 	sethi  %hi(0xfc00), %g1                        
40019b08:	87 30 e0 08 	srl  %g3, 8, %g3                               
40019b0c:	82 10 63 ff 	or  %g1, 0x3ff, %g1                            
40019b10:	85 30 a0 08 	srl  %g2, 8, %g2                               
40019b14:	86 08 c0 01 	and  %g3, %g1, %g3                             
40019b18:	82 08 80 01 	and  %g2, %g1, %g1                             
40019b1c:	86 17 40 03 	or  %i5, %g3, %g3                              
40019b20:	82 11 00 01 	or  %g4, %g1, %g1                              
40019b24:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
40019b28:	80 90 c0 01 	orcc  %g3, %g1, %g0                            
40019b2c:	12 80 00 08 	bne  40019b4c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1a8><== ALWAYS TAKEN
40019b30:	90 10 00 1c 	mov  %i4, %o0                                  
    fat_dir_pos_t *dir_pos                                            
    )                                                                 
{                                                                     
  dir_pos->sname.cln = 0;                                             
  dir_pos->sname.ofs = 0;                                             
  dir_pos->lname.cln = FAT_FILE_SHORT_NAME;                           
40019b34:	82 10 3f ff 	mov  -1, %g1                                   <== NOT EXECUTED
fat_dir_pos_init(                                                     
    fat_dir_pos_t *dir_pos                                            
    )                                                                 
{                                                                     
  dir_pos->sname.cln = 0;                                             
  dir_pos->sname.ofs = 0;                                             
40019b38:	c0 26 a0 04 	clr  [ %i2 + 4 ]                               <== NOT EXECUTED
  dir_pos->lname.cln = FAT_FILE_SHORT_NAME;                           
40019b3c:	c2 26 a0 08 	st  %g1, [ %i2 + 8 ]                           <== NOT EXECUTED
  dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;                           
40019b40:	c2 26 a0 0c 	st  %g1, [ %i2 + 0xc ]                         <== 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;                 
40019b44:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
40019b48:	c2 26 80 00 	st  %g1, [ %i2 ]                               <== NOT EXECUTED
    }                                                                 
                                                                      
    /* open fat-file corresponded to second ".." */                   
    rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);              
40019b4c:	92 10 00 1a 	mov  %i2, %o1                                  
40019b50:	7f ff e2 56 	call  400124a8 <fat_file_open>                 
40019b54:	94 07 bf bc 	add  %fp, -68, %o2                             
    if (rc != RC_OK)                                                  
40019b58:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40019b5c:	12 bf ff 9c 	bne  400199cc <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x28><== NEVER TAKEN
40019b60:	c2 17 bf f4 	lduh  [ %fp + -12 ], %g1                       
        return rc;                                                    
                                                                      
    if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)                
40019b64:	c8 17 bf fa 	lduh  [ %fp + -6 ], %g4                        
40019b68:	83 28 60 10 	sll  %g1, 0x10, %g1                            
40019b6c:	07 00 00 3f 	sethi  %hi(0xfc00), %g3                        
40019b70:	85 30 60 18 	srl  %g1, 0x18, %g2                            
40019b74:	86 10 e3 ff 	or  %g3, 0x3ff, %g3                            
40019b78:	83 30 60 08 	srl  %g1, 8, %g1                               
40019b7c:	82 08 40 03 	and  %g1, %g3, %g1                             
40019b80:	89 29 20 10 	sll  %g4, 0x10, %g4                            
40019b84:	84 10 80 01 	or  %g2, %g1, %g2                              
40019b88:	bb 31 20 18 	srl  %g4, 0x18, %i5                            
40019b8c:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
40019b90:	89 31 20 08 	srl  %g4, 8, %g4                               
40019b94:	86 09 00 03 	and  %g4, %g3, %g3                             
40019b98:	82 17 40 03 	or  %i5, %g3, %g1                              
40019b9c:	82 90 80 01 	orcc  %g2, %g1, %g1                            
40019ba0:	12 80 00 35 	bne  40019c74 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2d0><== ALWAYS TAKEN
40019ba4:	d2 07 bf bc 	ld  [ %fp + -68 ], %o1                         
        fat_fd->cln = fs_info->fat.vol.rdir_cl;                       
40019ba8:	c2 07 20 3c 	ld  [ %i4 + 0x3c ], %g1                        <== NOT EXECUTED
40019bac:	c2 22 60 1c 	st  %g1, [ %o1 + 0x1c ]                        <== NOT EXECUTED
                                                                      
    fat_fd->fat_file_type = FAT_DIRECTORY;                            
    fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                        
                                                                      
    fat_fd->map.file_cln = 0;                                         
    fat_fd->map.disk_cln = fat_fd->cln;                               
40019bb0:	c2 02 60 1c 	ld  [ %o1 + 0x1c ], %g1                        
        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;                            
    fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                        
40019bb4:	05 00 08 00 	sethi  %hi(0x200000), %g2                      
    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;                            
40019bb8:	c0 22 60 10 	clr  [ %o1 + 0x10 ]                            
    fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                        
                                                                      
    fat_fd->map.file_cln = 0;                                         
40019bbc:	c0 22 60 34 	clr  [ %o1 + 0x34 ]                            
        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;                            
    fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                        
40019bc0:	c4 22 60 14 	st  %g2, [ %o1 + 0x14 ]                        
                                                                      
    fat_fd->map.file_cln = 0;                                         
    fat_fd->map.disk_cln = fat_fd->cln;                               
40019bc4:	c2 22 60 38 	st  %g1, [ %o1 + 0x38 ]                        
                                                                      
    rc = fat_file_size(&fs_info->fat, fat_fd);                        
40019bc8:	7f ff e5 6e 	call  40013180 <fat_file_size>                 
40019bcc:	90 10 00 1c 	mov  %i4, %o0                                  
    if (rc != RC_OK)                                                  
    {                                                                 
        fat_file_close(&fs_info->fat, fat_fd);                        
40019bd0:	d2 07 bf bc 	ld  [ %fp + -68 ], %o1                         
                                                                      
    fat_fd->map.file_cln = 0;                                         
    fat_fd->map.disk_cln = fat_fd->cln;                               
                                                                      
    rc = fat_file_size(&fs_info->fat, fat_fd);                        
    if (rc != RC_OK)                                                  
40019bd4:	80 a2 20 00 	cmp  %o0, 0                                    
40019bd8:	12 80 00 23 	bne  40019c64 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2c0><== NEVER TAKEN
40019bdc:	ba 10 00 08 	mov  %o0, %i5                                  
    {                                                                 
        fat_file_close(&fs_info->fat, fat_fd);                        
        return rc;                                                    
    }                                                                 
                                                                      
    cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);                    
40019be0:	a1 2c 20 10 	sll  %l0, 0x10, %l0                            
40019be4:	b3 2e 60 10 	sll  %i1, 0x10, %i1                            
40019be8:	95 34 20 18 	srl  %l0, 0x18, %o2                            
40019bec:	85 36 60 18 	srl  %i1, 0x18, %g2                            
40019bf0:	a1 34 20 08 	srl  %l0, 8, %l0                               
40019bf4:	b3 36 60 08 	srl  %i1, 8, %i1                               
40019bf8:	03 00 00 3f 	sethi  %hi(0xfc00), %g1                        
40019bfc:	82 10 63 ff 	or  %g1, 0x3ff, %g1	! ffff <PROM_START+0xffff> 
40019c00:	a0 0c 00 01 	and  %l0, %g1, %l0                             
40019c04:	82 0e 40 01 	and  %i1, %g1, %g1                             
40019c08:	82 10 80 01 	or  %g2, %g1, %g1                              
        fat_file_close(&fs_info->fat, 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,
40019c0c:	90 10 00 18 	mov  %i0, %o0                                  
40019c10:	96 10 00 1a 	mov  %i2, %o3                                  
    {                                                                 
        fat_file_close(&fs_info->fat, fat_fd);                        
        return rc;                                                    
    }                                                                 
                                                                      
    cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);                    
40019c14:	94 12 80 10 	or  %o2, %l0, %o2                              
        fat_file_close(&fs_info->fat, 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,
40019c18:	98 10 00 1b 	mov  %i3, %o4                                  
    {                                                                 
        fat_file_close(&fs_info->fat, fat_fd);                        
        return rc;                                                    
    }                                                                 
                                                                      
    cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);                    
40019c1c:	95 2a a0 10 	sll  %o2, 0x10, %o2                            
        fat_file_close(&fs_info->fat, 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,
40019c20:	7f ff fe fe 	call  40019818 <msdos_find_node_by_cluster_num_in_fat_file>
40019c24:	94 12 80 01 	or  %o2, %g1, %o2                              
                                                    dir_pos, dir_entry);
    if (rc != RC_OK)                                                  
    {                                                                 
        fat_file_close(&fs_info->fat, fat_fd);                        
40019c28:	d2 07 bf bc 	ld  [ %fp + -68 ], %o1                         
        fat_file_close(&fs_info->fat, 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,
40019c2c:	ba 10 00 08 	mov  %o0, %i5                                  
                                                    dir_pos, dir_entry);
    if (rc != RC_OK)                                                  
40019c30:	80 a7 60 00 	cmp  %i5, 0                                    
40019c34:	12 80 00 12 	bne  40019c7c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2d8><== NEVER TAKEN
40019c38:	90 10 00 1c 	mov  %i4, %o0                                  
    {                                                                 
        fat_file_close(&fs_info->fat, fat_fd);                        
        return rc;                                                    
    }                                                                 
    rc = fat_file_close(&fs_info->fat, fat_fd);                       
40019c3c:	7f ff e3 95 	call  40012a90 <fat_file_close>                
40019c40:	01 00 00 00 	nop                                            
40019c44:	10 bf ff 62 	b  400199cc <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x28>
40019c48:	ba 10 00 08 	mov  %o0, %i5                                  
    rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, ".", 1, 
                                     MSDOS_NAME_SHORT, dir_pos, dot_node);
                                                                      
    if (rc != RC_OK)                                                  
    {                                                                 
        fat_file_close(&fs_info->fat, fat_fd);                        
40019c4c:	d2 07 bf bc 	ld  [ %fp + -68 ], %o1                         <== NOT EXECUTED
40019c50:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
40019c54:	7f ff e3 8f 	call  40012a90 <fat_file_close>                <== NOT EXECUTED
40019c58:	b0 10 00 1d 	mov  %i5, %i0                                  <== NOT EXECUTED
        fat_file_close(&fs_info->fat, fat_fd);                        
        return rc;                                                    
    }                                                                 
    rc = fat_file_close(&fs_info->fat, fat_fd);                       
    return rc;                                                        
}                                                                     
40019c5c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40019c60:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    fat_fd->map.disk_cln = fat_fd->cln;                               
                                                                      
    rc = fat_file_size(&fs_info->fat, fat_fd);                        
    if (rc != RC_OK)                                                  
    {                                                                 
        fat_file_close(&fs_info->fat, fat_fd);                        
40019c64:	7f ff e3 8b 	call  40012a90 <fat_file_close>                <== NOT EXECUTED
40019c68:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
        fat_file_close(&fs_info->fat, fat_fd);                        
        return rc;                                                    
    }                                                                 
    rc = fat_file_close(&fs_info->fat, fat_fd);                       
    return rc;                                                        
}                                                                     
40019c6c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40019c70:	91 e8 00 1d 	restore  %g0, %i5, %o0                         <== 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);         
40019c74:	10 bf ff cf 	b  40019bb0 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x20c>
40019c78:	c2 22 60 1c 	st  %g1, [ %o1 + 0x1c ]                        
    /* in this directory find slot with specified cluster num */      
    rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
                                                    dir_pos, dir_entry);
    if (rc != RC_OK)                                                  
    {                                                                 
        fat_file_close(&fs_info->fat, fat_fd);                        
40019c7c:	7f ff e3 85 	call  40012a90 <fat_file_close>                <== NOT EXECUTED
40019c80:	b0 10 00 1d 	mov  %i5, %i0                                  <== NOT EXECUTED
40019c84:	30 bf ff f6 	b,a   40019c5c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2b8><== NOT EXECUTED
                                                                      

40019c88 <msdos_get_name_node>: int name_len, msdos_name_type_t name_type, fat_dir_pos_t *dir_pos, char *name_dir_entry ) {
40019c88:	9d e3 bf 98 	save  %sp, -104, %sp                           
    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,    
40019c8c:	d0 06 20 14 	ld  [ %i0 + 0x14 ], %o0                        
40019c90:	d2 06 20 08 	ld  [ %i0 + 8 ], %o1                           
    int                                     name_len,                 
    msdos_name_type_t                       name_type,                
    fat_dir_pos_t                          *dir_pos,                  
    char                                   *name_dir_entry            
    )                                                                 
{                                                                     
40019c94:	e0 07 a0 5c 	ld  [ %fp + 0x5c ], %l0                        
    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,    
40019c98:	9a 10 00 1c 	mov  %i4, %o5                                  
40019c9c:	e0 23 a0 60 	st  %l0, [ %sp + 0x60 ]                        
40019ca0:	fa 23 a0 5c 	st  %i5, [ %sp + 0x5c ]                        
40019ca4:	94 10 00 19 	mov  %i1, %o2                                  
40019ca8:	96 10 00 1a 	mov  %i2, %o3                                  
40019cac:	7f ff fc 44 	call  40018dbc <msdos_find_name_in_fat_file>   
40019cb0:	98 10 00 1b 	mov  %i3, %o4                                  
                                     create_node, name, name_len, name_type,
                                     dir_pos, name_dir_entry);        
    if ((rc != RC_OK) && (rc != MSDOS_NAME_NOT_FOUND_ERR))            
40019cb4:	03 00 00 1f 	sethi  %hi(0x7c00), %g1                        
40019cb8:	82 10 61 01 	or  %g1, 0x101, %g1	! 7d01 <PROM_START+0x7d01> 
40019cbc:	80 a2 00 01 	cmp  %o0, %g1                                  
40019cc0:	12 80 00 2a 	bne  40019d68 <msdos_get_name_node+0xe0>       
40019cc4:	b8 10 00 08 	mov  %o0, %i4                                  
        return rc;                                                    
                                                                      
    if (!create_node)                                                 
40019cc8:	80 a6 60 00 	cmp  %i1, 0                                    
40019ccc:	12 80 00 25 	bne  40019d60 <msdos_get_name_node+0xd8>       
40019cd0:	03 00 00 1f 	sethi  %hi(0x7c00), %g1                        
    {                                                                 
        /* if we search for valid name and name not found -> return */
        if (rc == MSDOS_NAME_NOT_FOUND_ERR)                           
40019cd4:	82 10 61 01 	or  %g1, 0x101, %g1	! 7d01 <PROM_START+0x7d01> 
40019cd8:	80 a7 00 01 	cmp  %i4, %g1                                  
40019cdc:	02 80 00 21 	be  40019d60 <msdos_get_name_node+0xd8>        
40019ce0:	80 a7 20 00 	cmp  %i4, 0                                    
         * 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)                                              
40019ce4:	12 80 00 1f 	bne  40019d60 <msdos_get_name_node+0xd8>       <== NEVER TAKEN
40019ce8:	90 10 00 1a 	mov  %i2, %o0                                  
        {                                                             
            if (strncmp(name, "..", 2) == 0)                          
40019cec:	94 10 20 02 	mov  2, %o2                                    
40019cf0:	13 10 00 b3 	sethi  %hi(0x4002cc00), %o1                    
40019cf4:	40 00 10 9c 	call  4001df64 <strncmp>                       
40019cf8:	92 12 62 b0 	or  %o1, 0x2b0, %o1	! 4002ceb0 <IMFS_memfile_handlers+0x44>
40019cfc:	80 a2 20 00 	cmp  %o0, 0                                    
40019d00:	12 80 00 18 	bne  40019d60 <msdos_get_name_node+0xd8>       
40019d04:	05 00 00 3f 	sethi  %hi(0xfc00), %g2                        
            {                                                         
                dotdot_cln = MSDOS_EXTRACT_CLUSTER_NUM((name_dir_entry));
40019d08:	c2 14 20 14 	lduh  [ %l0 + 0x14 ], %g1                      
40019d0c:	c6 14 20 1a 	lduh  [ %l0 + 0x1a ], %g3                      
40019d10:	83 28 60 10 	sll  %g1, 0x10, %g1                            
40019d14:	b3 30 60 18 	srl  %g1, 0x18, %i1                            
40019d18:	84 10 a3 ff 	or  %g2, 0x3ff, %g2                            
40019d1c:	83 30 60 08 	srl  %g1, 8, %g1                               
40019d20:	82 08 40 02 	and  %g1, %g2, %g1                             
40019d24:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
40019d28:	b2 16 40 01 	or  %i1, %g1, %i1                              
40019d2c:	89 30 e0 18 	srl  %g3, 0x18, %g4                            
40019d30:	b3 2e 60 10 	sll  %i1, 0x10, %i1                            
40019d34:	87 30 e0 08 	srl  %g3, 8, %g3                               
40019d38:	84 08 c0 02 	and  %g3, %g2, %g2                             
40019d3c:	82 11 00 02 	or  %g4, %g2, %g1                              
                                                                      
                /* are we right under root dir ? */                   
                if (dotdot_cln == 0)                                  
40019d40:	b2 96 40 01 	orcc  %i1, %g1, %i1                            
40019d44:	12 80 00 0e 	bne  40019d7c <msdos_get_name_node+0xf4>       
40019d48:	82 10 3f ff 	mov  -1, %g1                                   
fat_dir_pos_init(                                                     
    fat_dir_pos_t *dir_pos                                            
    )                                                                 
{                                                                     
  dir_pos->sname.cln = 0;                                             
  dir_pos->sname.ofs = 0;                                             
40019d4c:	c0 27 60 04 	clr  [ %i5 + 4 ]                               
  dir_pos->lname.cln = FAT_FILE_SHORT_NAME;                           
40019d50:	c2 27 60 08 	st  %g1, [ %i5 + 8 ]                           
  dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;                           
40019d54:	c2 27 60 0c 	st  %g1, [ %i5 + 0xc ]                         
                    /*                                                
                     * 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;     
40019d58:	82 10 20 01 	mov  1, %g1                                    
40019d5c:	c2 27 40 00 	st  %g1, [ %i5 ]                               
                }                                                     
            }                                                         
        }                                                             
    }                                                                 
    return rc;                                                        
}                                                                     
40019d60:	81 c7 e0 08 	ret                                            
40019d64:	91 e8 00 1c 	restore  %g0, %i4, %o0                         
                                                                      
    /* find name in fat-file which corresponds to the directory */    
    rc = msdos_find_name_in_fat_file(parent_loc->mt_entry, fat_fd,    
                                     create_node, name, name_len, name_type,
                                     dir_pos, name_dir_entry);        
    if ((rc != RC_OK) && (rc != MSDOS_NAME_NOT_FOUND_ERR))            
40019d68:	80 a2 20 00 	cmp  %o0, 0                                    
40019d6c:	02 bf ff d8 	be  40019ccc <msdos_get_name_node+0x44>        
40019d70:	80 a6 60 00 	cmp  %i1, 0                                    
                }                                                     
            }                                                         
        }                                                             
    }                                                                 
    return rc;                                                        
}                                                                     
40019d74:	81 c7 e0 08 	ret                                            
40019d78:	91 e8 00 1c 	restore  %g0, %i4, %o0                         
                    fat_dir_pos_init(dir_pos);                        
                    dir_pos->sname.cln = FAT_ROOTDIR_CLUSTER_NUM;     
                }                                                     
                else                                                  
                {                                                     
                    rc =                                              
40019d7c:	f0 06 20 14 	ld  [ %i0 + 0x14 ], %i0                        
40019d80:	b4 10 00 1d 	mov  %i5, %i2                                  
40019d84:	7f ff ff 08 	call  400199a4 <msdos_get_dotdot_dir_info_cluster_num_and_offset>
40019d88:	97 e8 00 10 	restore  %g0, %l0, %o3                         
                                                                      

4000e7e4 <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 ) {
4000e7e4:	9d e3 bf 88 	save  %sp, -120, %sp                           
    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));  
4000e7e8:	90 10 20 01 	mov  1, %o0                                    
    )                                                                 
{                                                                     
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = NULL;                                
    fat_file_fd_t     *fat_fd = NULL;                                 
4000e7ec:	c0 27 bf ec 	clr  [ %fp + -20 ]                             
    fat_dir_pos_t      root_pos;                                      
    uint32_t           cl_buf_size;                                   
                                                                      
    fs_info = (msdos_fs_info_t *)calloc(1, sizeof(msdos_fs_info_t));  
4000e7f0:	7f ff d8 b8 	call  40004ad0 <calloc>                        
4000e7f4:	92 10 20 a4 	mov  0xa4, %o1                                 
    if (!fs_info)                                                     
4000e7f8:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4000e7fc:	02 80 00 58 	be  4000e95c <msdos_initialize_support+0x178>  <== NEVER TAKEN
4000e800:	01 00 00 00 	nop                                            
        rtems_set_errno_and_return_minus_one(ENOMEM);                 
                                                                      
    temp_mt_entry->fs_info = fs_info;                                 
                                                                      
    rc = fat_init_volume_info(&fs_info->fat, temp_mt_entry->dev);     
4000e804:	d2 06 20 38 	ld  [ %i0 + 0x38 ], %o1                        
4000e808:	40 00 14 42 	call  40013910 <fat_init_volume_info>          
4000e80c:	fa 26 20 08 	st  %i5, [ %i0 + 8 ]                           
    if (rc != RC_OK)                                                  
4000e810:	b8 92 20 00 	orcc  %o0, 0, %i4                              
4000e814:	12 80 00 34 	bne  4000e8e4 <msdos_initialize_support+0x100> <== NEVER TAKEN
4000e818:	82 10 3f ff 	mov  -1, %g1                                   
    fat_dir_pos_t *dir_pos                                            
    )                                                                 
{                                                                     
  dir_pos->sname.cln = 0;                                             
  dir_pos->sname.ofs = 0;                                             
  dir_pos->lname.cln = FAT_FILE_SHORT_NAME;                           
4000e81c:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]                          
  dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;                           
4000e820:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
    /*                                                                
     * 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;                     
4000e824:	82 10 20 01 	mov  1, %g1                                    
    {                                                                 
        free(fs_info);                                                
        return rc;                                                    
    }                                                                 
                                                                      
    fs_info->file_handlers      = file_handlers;                      
4000e828:	f4 27 60 98 	st  %i2, [ %i5 + 0x98 ]                        
    fs_info->directory_handlers = directory_handlers;                 
4000e82c:	f6 27 60 94 	st  %i3, [ %i5 + 0x94 ]                        
fat_dir_pos_init(                                                     
    fat_dir_pos_t *dir_pos                                            
    )                                                                 
{                                                                     
  dir_pos->sname.cln = 0;                                             
  dir_pos->sname.ofs = 0;                                             
4000e830:	c0 27 bf f4 	clr  [ %fp + -12 ]                             
     * 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(&fs_info->fat, &root_pos, &fat_fd);            
4000e834:	90 10 00 1d 	mov  %i5, %o0                                  
    /*                                                                
     * 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;                     
4000e838:	c2 27 bf f0 	st  %g1, [ %fp + -16 ]                         
    rc = fat_file_open(&fs_info->fat, &root_pos, &fat_fd);            
4000e83c:	92 07 bf f0 	add  %fp, -16, %o1                             
4000e840:	40 00 0f 1a 	call  400124a8 <fat_file_open>                 
4000e844:	94 07 bf ec 	add  %fp, -20, %o2                             
    if (rc != RC_OK)                                                  
4000e848:	b8 92 20 00 	orcc  %o0, 0, %i4                              
4000e84c:	12 80 00 24 	bne  4000e8dc <msdos_initialize_support+0xf8>  <== NEVER TAKEN
4000e850:	d2 07 bf ec 	ld  [ %fp + -20 ], %o1                         
    }                                                                 
                                                                      
    /* 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;                           
4000e854:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        
        return rc;                                                    
    }                                                                 
                                                                      
    /* again: unfortunately "fat-file" is just almost fat file :( */  
    fat_fd->fat_file_type = FAT_DIRECTORY;                            
    fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                        
4000e858:	05 00 08 00 	sethi  %hi(0x200000), %g2                      
        free(fs_info);                                                
        return rc;                                                    
    }                                                                 
                                                                      
    /* again: unfortunately "fat-file" is just almost fat file :( */  
    fat_fd->fat_file_type = FAT_DIRECTORY;                            
4000e85c:	c0 22 60 10 	clr  [ %o1 + 0x10 ]                            
    fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                        
4000e860:	c4 22 60 14 	st  %g2, [ %o1 + 0x14 ]                        
    fat_fd->cln = fs_info->fat.vol.rdir_cl;                           
4000e864:	c2 22 60 1c 	st  %g1, [ %o1 + 0x1c ]                        
                                                                      
    fat_fd->map.file_cln = 0;                                         
4000e868:	c0 22 60 34 	clr  [ %o1 + 0x34 ]                            
    fat_fd->map.disk_cln = fat_fd->cln;                               
                                                                      
    /* if we have FAT12/16 */                                         
    if ( fat_fd->cln == 0 )                                           
4000e86c:	80 a0 60 00 	cmp  %g1, 0                                    
4000e870:	12 80 00 24 	bne  4000e900 <msdos_initialize_support+0x11c> 
4000e874:	c2 22 60 38 	st  %g1, [ %o1 + 0x38 ]                        
    {                                                                 
        fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;           
4000e878:	c2 07 60 2c 	ld  [ %i5 + 0x2c ], %g1                        
        cl_buf_size = (fs_info->fat.vol.bpc > fs_info->fat.vol.rdir_size) ?
                      fs_info->fat.vol.bpc                                :
4000e87c:	d0 17 60 06 	lduh  [ %i5 + 6 ], %o0                         
                                                                      
    /* if we have FAT12/16 */                                         
    if ( fat_fd->cln == 0 )                                           
    {                                                                 
        fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;           
        cl_buf_size = (fs_info->fat.vol.bpc > fs_info->fat.vol.rdir_size) ?
4000e880:	80 a2 00 01 	cmp  %o0, %g1                                  
4000e884:	0a 80 00 1d 	bcs  4000e8f8 <msdos_initialize_support+0x114> 
4000e888:	c2 22 60 18 	st  %g1, [ %o1 + 0x18 ]                        
            return rc;                                                
        }                                                             
        cl_buf_size = fs_info->fat.vol.bpc;                           
    }                                                                 
                                                                      
    fs_info->cl_buf = (uint8_t *)calloc(cl_buf_size, sizeof(char));   
4000e88c:	7f ff d8 91 	call  40004ad0 <calloc>                        
4000e890:	92 10 20 01 	mov  1, %o1                                    
    if (fs_info->cl_buf == NULL)                                      
4000e894:	80 a2 20 00 	cmp  %o0, 0                                    
4000e898:	02 80 00 2a 	be  4000e940 <msdos_initialize_support+0x15c>  <== NEVER TAKEN
4000e89c:	d0 27 60 a0 	st  %o0, [ %i5 + 0xa0 ]                        
        fat_shutdown_drive(&fs_info->fat);                            
        free(fs_info);                                                
        rtems_set_errno_and_return_minus_one(ENOMEM);                 
    }                                                                 
                                                                      
    sc = rtems_semaphore_create(3,                                    
4000e8a0:	90 10 20 03 	mov  3, %o0                                    
4000e8a4:	92 10 20 01 	mov  1, %o1                                    
4000e8a8:	94 10 20 10 	mov  0x10, %o2                                 
4000e8ac:	96 10 20 00 	clr  %o3                                       
4000e8b0:	7f ff ea 2a 	call  40009158 <rtems_semaphore_create>        
4000e8b4:	98 07 60 9c 	add  %i5, 0x9c, %o4                            
                                1,                                    
                                RTEMS_BINARY_SEMAPHORE | RTEMS_FIFO,  
                                0,                                    
                                &fs_info->vol_sema);                  
    if (sc != RTEMS_SUCCESSFUL)                                       
4000e8b8:	80 a2 20 00 	cmp  %o0, 0                                    
4000e8bc:	12 80 00 2d 	bne  4000e970 <msdos_initialize_support+0x18c> <== NEVER TAKEN
4000e8c0:	c4 07 bf ec 	ld  [ %fp + -20 ], %g2                         
        free(fs_info->cl_buf);                                        
        free(fs_info);                                                
        rtems_set_errno_and_return_minus_one( EIO );                  
    }                                                                 
                                                                      
    temp_mt_entry->mt_fs_root->location.node_access = fat_fd;         
4000e8c4:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
    temp_mt_entry->mt_fs_root->location.handlers = directory_handlers;
4000e8c8:	f6 20 60 10 	st  %i3, [ %g1 + 0x10 ]                        
        free(fs_info->cl_buf);                                        
        free(fs_info);                                                
        rtems_set_errno_and_return_minus_one( EIO );                  
    }                                                                 
                                                                      
    temp_mt_entry->mt_fs_root->location.node_access = fat_fd;         
4000e8cc:	c4 20 60 08 	st  %g2, [ %g1 + 8 ]                           
    temp_mt_entry->mt_fs_root->location.handlers = directory_handlers;
    temp_mt_entry->ops = op_table;                                    
4000e8d0:	f2 26 20 0c 	st  %i1, [ %i0 + 0xc ]                         
                                                                      
    return rc;                                                        
}                                                                     
4000e8d4:	81 c7 e0 08 	ret                                            
4000e8d8:	91 e8 00 1c 	restore  %g0, %i4, %o0                         
    fat_dir_pos_init(&root_pos);                                      
    root_pos.sname.cln = FAT_ROOTDIR_CLUSTER_NUM;                     
    rc = fat_file_open(&fs_info->fat, &root_pos, &fat_fd);            
    if (rc != RC_OK)                                                  
    {                                                                 
        fat_shutdown_drive(&fs_info->fat);                            
4000e8dc:	40 00 16 5c 	call  4001424c <fat_shutdown_drive>            <== NOT EXECUTED
4000e8e0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
        free(fs_info);                                                
4000e8e4:	7f ff d8 b2 	call  40004bac <free>                          <== NOT EXECUTED
4000e8e8:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
    temp_mt_entry->mt_fs_root->location.node_access = fat_fd;         
    temp_mt_entry->mt_fs_root->location.handlers = directory_handlers;
    temp_mt_entry->ops = op_table;                                    
                                                                      
    return rc;                                                        
}                                                                     
4000e8ec:	b0 10 00 1c 	mov  %i4, %i0                                  <== NOT EXECUTED
4000e8f0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000e8f4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
    /* if we have FAT12/16 */                                         
    if ( fat_fd->cln == 0 )                                           
    {                                                                 
        fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;           
        cl_buf_size = (fs_info->fat.vol.bpc > fs_info->fat.vol.rdir_size) ?
4000e8f8:	10 bf ff e5 	b  4000e88c <msdos_initialize_support+0xa8>    
4000e8fc:	90 10 00 01 	mov  %g1, %o0                                  
                      fs_info->fat.vol.bpc                                :
                      fs_info->fat.vol.rdir_size;                     
    }                                                                 
    else                                                              
    {                                                                 
        rc = fat_file_size(&fs_info->fat, fat_fd);                    
4000e900:	40 00 12 20 	call  40013180 <fat_file_size>                 
4000e904:	90 10 00 1d 	mov  %i5, %o0                                  
        if ( rc != RC_OK )                                            
4000e908:	82 92 20 00 	orcc  %o0, 0, %g1                              
4000e90c:	12 80 00 04 	bne  4000e91c <msdos_initialize_support+0x138> <== NEVER TAKEN
4000e910:	d2 07 bf ec 	ld  [ %fp + -20 ], %o1                         
            fat_file_close(&fs_info->fat, fat_fd);                    
            fat_shutdown_drive(&fs_info->fat);                        
            free(fs_info);                                            
            return rc;                                                
        }                                                             
        cl_buf_size = fs_info->fat.vol.bpc;                           
4000e914:	10 bf ff de 	b  4000e88c <msdos_initialize_support+0xa8>    
4000e918:	d0 17 60 06 	lduh  [ %i5 + 6 ], %o0                         
        rc = fat_file_size(&fs_info->fat, fat_fd);                    
        if ( rc != RC_OK )                                            
        {                                                             
            fat_file_close(&fs_info->fat, fat_fd);                    
            fat_shutdown_drive(&fs_info->fat);                        
            free(fs_info);                                            
4000e91c:	b8 10 00 01 	mov  %g1, %i4                                  <== NOT EXECUTED
    else                                                              
    {                                                                 
        rc = fat_file_size(&fs_info->fat, fat_fd);                    
        if ( rc != RC_OK )                                            
        {                                                             
            fat_file_close(&fs_info->fat, fat_fd);                    
4000e920:	40 00 10 5c 	call  40012a90 <fat_file_close>                <== NOT EXECUTED
4000e924:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
            fat_shutdown_drive(&fs_info->fat);                        
4000e928:	40 00 16 49 	call  4001424c <fat_shutdown_drive>            <== NOT EXECUTED
4000e92c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
            free(fs_info);                                            
4000e930:	7f ff d8 9f 	call  40004bac <free>                          <== NOT EXECUTED
4000e934:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
    temp_mt_entry->mt_fs_root->location.node_access = fat_fd;         
    temp_mt_entry->mt_fs_root->location.handlers = directory_handlers;
    temp_mt_entry->ops = op_table;                                    
                                                                      
    return rc;                                                        
}                                                                     
4000e938:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000e93c:	91 e8 00 1c 	restore  %g0, %i4, %o0                         <== NOT EXECUTED
    }                                                                 
                                                                      
    fs_info->cl_buf = (uint8_t *)calloc(cl_buf_size, sizeof(char));   
    if (fs_info->cl_buf == NULL)                                      
    {                                                                 
        fat_file_close(&fs_info->fat, fat_fd);                        
4000e940:	d2 07 bf ec 	ld  [ %fp + -20 ], %o1                         <== NOT EXECUTED
4000e944:	40 00 10 53 	call  40012a90 <fat_file_close>                <== NOT EXECUTED
4000e948:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
        fat_shutdown_drive(&fs_info->fat);                            
4000e94c:	40 00 16 40 	call  4001424c <fat_shutdown_drive>            <== NOT EXECUTED
4000e950:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
        free(fs_info);                                                
4000e954:	7f ff d8 96 	call  40004bac <free>                          <== NOT EXECUTED
4000e958:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(ENOMEM);                 
4000e95c:	40 00 36 8d 	call  4001c390 <__errno>                       <== NOT EXECUTED
4000e960:	b8 10 3f ff 	mov  -1, %i4                                   <== NOT EXECUTED
4000e964:	82 10 20 0c 	mov  0xc, %g1                                  <== NOT EXECUTED
4000e968:	10 bf ff e1 	b  4000e8ec <msdos_initialize_support+0x108>   <== NOT EXECUTED
4000e96c:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
                                RTEMS_BINARY_SEMAPHORE | RTEMS_FIFO,  
                                0,                                    
                                &fs_info->vol_sema);                  
    if (sc != RTEMS_SUCCESSFUL)                                       
    {                                                                 
        fat_file_close(&fs_info->fat, fat_fd);                        
4000e970:	d2 07 bf ec 	ld  [ %fp + -20 ], %o1                         <== NOT EXECUTED
4000e974:	40 00 10 47 	call  40012a90 <fat_file_close>                <== NOT EXECUTED
4000e978:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
        fat_shutdown_drive(&fs_info->fat);                            
4000e97c:	40 00 16 34 	call  4001424c <fat_shutdown_drive>            <== NOT EXECUTED
4000e980:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
        free(fs_info->cl_buf);                                        
4000e984:	d0 07 60 a0 	ld  [ %i5 + 0xa0 ], %o0                        <== NOT EXECUTED
4000e988:	7f ff d8 89 	call  40004bac <free>                          <== NOT EXECUTED
4000e98c:	b8 10 3f ff 	mov  -1, %i4                                   <== NOT EXECUTED
        free(fs_info);                                                
4000e990:	7f ff d8 87 	call  40004bac <free>                          <== NOT EXECUTED
4000e994:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one( EIO );                  
4000e998:	40 00 36 7e 	call  4001c390 <__errno>                       <== NOT EXECUTED
4000e99c:	b0 10 00 1c 	mov  %i4, %i0                                  <== NOT EXECUTED
4000e9a0:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
4000e9a4:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4000e9a8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000e9ac:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4000e7ac <msdos_lock>: .rename_h = msdos_rename, .statvfs_h = rtems_filesystem_default_statvfs }; void msdos_lock(const rtems_filesystem_mount_table_entry_t *mt_entry) {
4000e7ac:	9d e3 bf a0 	save  %sp, -96, %sp                            
  msdos_fs_info_t *fs_info = mt_entry->fs_info;                       
  rtems_status_code sc = rtems_semaphore_obtain(                      
    fs_info->vol_sema,                                                
4000e7b0:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
};                                                                    
                                                                      
void msdos_lock(const rtems_filesystem_mount_table_entry_t *mt_entry) 
{                                                                     
  msdos_fs_info_t *fs_info = mt_entry->fs_info;                       
  rtems_status_code sc = rtems_semaphore_obtain(                      
4000e7b4:	92 10 20 00 	clr  %o1                                       
4000e7b8:	d0 00 60 9c 	ld  [ %g1 + 0x9c ], %o0                        
4000e7bc:	7f ff eb 0f 	call  400093f8 <rtems_semaphore_obtain>        
4000e7c0:	94 10 20 00 	clr  %o2                                       
    fs_info->vol_sema,                                                
    RTEMS_WAIT,                                                       
    RTEMS_NO_TIMEOUT                                                  
  );                                                                  
  if (sc != RTEMS_SUCCESSFUL) {                                       
4000e7c4:	80 a2 20 00 	cmp  %o0, 0                                    
4000e7c8:	12 80 00 04 	bne  4000e7d8 <msdos_lock+0x2c>                <== NEVER TAKEN
4000e7cc:	11 37 ab 6f 	sethi  %hi(0xdeadbc00), %o0                    
4000e7d0:	81 c7 e0 08 	ret                                            
4000e7d4:	81 e8 00 00 	restore                                        
    rtems_fatal_error_occurred(0xdeadbeef);                           
4000e7d8:	7f ff ec e9 	call  40009b7c <rtems_fatal_error_occurred>    <== NOT EXECUTED
4000e7dc:	90 12 22 ef 	or  %o0, 0x2ef, %o0                            <== NOT EXECUTED
                                                                      

400185dc <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) {
400185dc:	9d e3 bf a0 	save  %sp, -96, %sp                            
    int               i;                                              
                                                                      
    /*                                                                
     * Fill with spaces. This is how a short directory entry is padded.
     */                                                               
    memset (sfn, ' ', sfn_len);                                       
400185e0:	92 10 20 20 	mov  0x20, %o1                                 
400185e4:	90 10 00 1a 	mov  %i2, %o0                                  
400185e8:	40 00 12 4c 	call  4001cf18 <memset>                        
400185ec:	94 10 00 1b 	mov  %i3, %o2                                  
                                                                      
    /*                                                                
     * Handle '.' and '..' specially.                                 
     */                                                               
    if ((lfn[0] == '.') && (lfn_len == 1))                            
400185f0:	f8 0e 00 00 	ldub  [ %i0 ], %i4                             
400185f4:	85 2f 20 18 	sll  %i4, 0x18, %g2                            
400185f8:	83 38 a0 18 	sra  %g2, 0x18, %g1                            
400185fc:	80 a0 60 2e 	cmp  %g1, 0x2e                                 
40018600:	02 80 00 17 	be  4001865c <msdos_long_to_short+0x80>        
40018604:	a0 10 00 18 	mov  %i0, %l0                                  
    }                                                                 
                                                                      
    /*                                                                
     * Filenames with only blanks and dots are not allowed!           
     */                                                               
    for (i = 0; i < lfn_len; i++)                                     
40018608:	80 a6 60 00 	cmp  %i1, 0                                    
4001860c:	04 80 00 70 	ble  400187cc <msdos_long_to_short+0x1f0>      <== NEVER TAKEN
40018610:	83 38 a0 18 	sra  %g2, 0x18, %g1                            
        if ((lfn[i] != ' ') && (lfn[i] != '.'))                       
40018614:	80 a0 60 2e 	cmp  %g1, 0x2e                                 
40018618:	12 80 00 1f 	bne  40018694 <msdos_long_to_short+0xb8>       <== ALWAYS TAKEN
4001861c:	80 a0 60 20 	cmp  %g1, 0x20                                 
40018620:	10 80 00 05 	b  40018634 <msdos_long_to_short+0x58>         <== NOT EXECUTED
40018624:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
40018628:	80 a0 e0 2e 	cmp  %g3, 0x2e                                 
4001862c:	12 80 00 08 	bne  4001864c <msdos_long_to_short+0x70>       <== ALWAYS TAKEN
40018630:	80 a0 e0 20 	cmp  %g3, 0x20                                 
    }                                                                 
                                                                      
    /*                                                                
     * Filenames with only blanks and dots are not allowed!           
     */                                                               
    for (i = 0; i < lfn_len; i++)                                     
40018634:	82 00 60 01 	inc  %g1                                       
40018638:	80 a0 40 19 	cmp  %g1, %i1                                  
4001863c:	32 bf ff fb 	bne,a   40018628 <msdos_long_to_short+0x4c>    <== ALWAYS TAKEN
40018640:	c6 4c 00 01 	ldsb  [ %l0 + %g1 ], %g3                       
    if (type == MSDOS_NAME_INVALID)                                   
    {                                                                 
#if MSDOS_L2S_PRINT                                                   
        printf ("MSDOS_L2S: INVALID[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif                                                                
        return MSDOS_NAME_INVALID;                                    
40018644:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40018648:	91 e8 20 00 	restore  %g0, 0, %o0                           <== NOT EXECUTED
                                                                      
    /*                                                                
     * Filenames with only blanks and dots are not allowed!           
     */                                                               
    for (i = 0; i < lfn_len; i++)                                     
        if ((lfn[i] != ' ') && (lfn[i] != '.'))                       
4001864c:	02 bf ff fb 	be  40018638 <msdos_long_to_short+0x5c>        <== NEVER TAKEN
40018650:	82 00 60 01 	inc  %g1                                       
    bool lowercase = false;                                           
    bool uppercase = false;                                           
    int  dot_at = -1;                                                 
    int  count = 0;                                                   
                                                                      
    while (*name && (count < name_len))                               
40018654:	10 80 00 13 	b  400186a0 <msdos_long_to_short+0xc4>         
40018658:	80 a0 a0 00 	cmp  %g2, 0                                    
    memset (sfn, ' ', sfn_len);                                       
                                                                      
    /*                                                                
     * Handle '.' and '..' specially.                                 
     */                                                               
    if ((lfn[0] == '.') && (lfn_len == 1))                            
4001865c:	80 a6 60 01 	cmp  %i1, 1                                    
40018660:	22 80 00 0b 	be,a   4001868c <msdos_long_to_short+0xb0>     
40018664:	c2 2e 80 00 	stb  %g1, [ %i2 ]                              
        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))         
40018668:	c2 4e 20 01 	ldsb  [ %i0 + 1 ], %g1                         
4001866c:	80 a0 60 2e 	cmp  %g1, 0x2e                                 
40018670:	12 bf ff e7 	bne  4001860c <msdos_long_to_short+0x30>       <== NEVER TAKEN
40018674:	80 a6 60 00 	cmp  %i1, 0                                    
40018678:	80 a6 60 02 	cmp  %i1, 2                                    
4001867c:	12 bf ff e4 	bne  4001860c <msdos_long_to_short+0x30>       <== NEVER TAKEN
40018680:	80 a6 60 00 	cmp  %i1, 0                                    
    {                                                                 
        sfn[0] = sfn[1] = '.';                                        
40018684:	c2 2e a0 01 	stb  %g1, [ %i2 + 1 ]                          
40018688:	c2 2e 80 00 	stb  %g1, [ %i2 ]                              
#if MSDOS_L2S_PRINT                                                   
        printf ("MSDOS_L2S: SHORT[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif                                                                
        return MSDOS_NAME_SHORT;                                      
4001868c:	81 c7 e0 08 	ret                                            
40018690:	91 e8 20 01 	restore  %g0, 1, %o0                           
                                                                      
    /*                                                                
     * Filenames with only blanks and dots are not allowed!           
     */                                                               
    for (i = 0; i < lfn_len; i++)                                     
        if ((lfn[i] != ' ') && (lfn[i] != '.'))                       
40018694:	02 bf ff e8 	be  40018634 <msdos_long_to_short+0x58>        
40018698:	82 10 20 00 	clr  %g1                                       
    bool lowercase = false;                                           
    bool uppercase = false;                                           
    int  dot_at = -1;                                                 
    int  count = 0;                                                   
                                                                      
    while (*name && (count < name_len))                               
4001869c:	80 a0 a0 00 	cmp  %g2, 0                                    
400186a0:	02 80 00 44 	be  400187b0 <msdos_long_to_short+0x1d4>       <== NEVER TAKEN
400186a4:	03 10 00 b6 	sethi  %hi(0x4002d800), %g1                    
msdos_is_valid_name_char(const char ch)                               
{                                                                     
    if (strchr(" +,;=[]", ch) != NULL)                                
        return MSDOS_NAME_LONG;                                       
                                                                      
    if ((ch == '.') || isalnum((unsigned char)ch) ||                  
400186a8:	e8 00 63 44 	ld  [ %g1 + 0x344 ], %l4	! 4002db44 <__ctype_ptr__>
 *                                                                    
 */                                                                   
static msdos_name_type_t                                              
msdos_is_valid_name_char(const char ch)                               
{                                                                     
    if (strchr(" +,;=[]", ch) != NULL)                                
400186ac:	31 10 00 b4 	sethi  %hi(0x4002d000), %i0                    
        return MSDOS_NAME_LONG;                                       
                                                                      
    if ((ch == '.') || isalnum((unsigned char)ch) ||                  
        (strchr("$%'-_@~`!(){}^#&", ch) != NULL))                     
400186b0:	2b 10 00 b4 	sethi  %hi(0x4002d000), %l5                    
msdos_is_valid_name_char(const char ch)                               
{                                                                     
    if (strchr(" +,;=[]", ch) != NULL)                                
        return MSDOS_NAME_LONG;                                       
                                                                      
    if ((ch == '.') || isalnum((unsigned char)ch) ||                  
400186b4:	a4 10 20 00 	clr  %l2                                       
400186b8:	a6 10 20 00 	clr  %l3                                       
400186bc:	ba 10 20 00 	clr  %i5                                       
400186c0:	a2 10 3f ff 	mov  -1, %l1                                   
 *                                                                    
 */                                                                   
static msdos_name_type_t                                              
msdos_is_valid_name_char(const char ch)                               
{                                                                     
    if (strchr(" +,;=[]", ch) != NULL)                                
400186c4:	b0 16 20 e0 	or  %i0, 0xe0, %i0                             
        return MSDOS_NAME_LONG;                                       
                                                                      
    if ((ch == '.') || isalnum((unsigned char)ch) ||                  
        (strchr("$%'-_@~`!(){}^#&", ch) != NULL))                     
400186c8:	aa 15 60 e8 	or  %l5, 0xe8, %l5                             
 *                                                                    
 */                                                                   
static msdos_name_type_t                                              
msdos_is_valid_name_char(const char ch)                               
{                                                                     
    if (strchr(" +,;=[]", ch) != NULL)                                
400186cc:	b7 38 a0 18 	sra  %g2, 0x18, %i3                            
400186d0:	90 10 00 18 	mov  %i0, %o0                                  
400186d4:	40 00 15 55 	call  4001dc28 <strchr>                        
400186d8:	92 10 00 1b 	mov  %i3, %o1                                  
400186dc:	80 a2 20 00 	cmp  %o0, 0                                    
400186e0:	02 80 00 09 	be  40018704 <msdos_long_to_short+0x128>       
400186e4:	82 1e e0 2e 	xor  %i3, 0x2e, %g1                            
        return MSDOS_NAME_LONG;                                       
400186e8:	b0 10 20 02 	mov  2, %i0                                    
        printf ("MSDOS_L2S: INVALID[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif                                                                
        return MSDOS_NAME_INVALID;                                    
    }                                                                 
                                                                      
    msdos_filename_unix2dos (lfn, lfn_len, sfn);                      
400186ec:	90 10 00 10 	mov  %l0, %o0                                  
400186f0:	92 10 00 19 	mov  %i1, %o1                                  
400186f4:	40 00 0b c1 	call  4001b5f8 <msdos_filename_unix2dos>       
400186f8:	94 10 00 1a 	mov  %i2, %o2                                  
                                                                      
#if MSDOS_L2S_PRINT                                                   
    printf ("MSDOS_L2S: TYPE:%d lfn:'%s' SFN:'%s'\n", type, lfn, sfn);
#endif                                                                
    return type;                                                      
400186fc:	81 c7 e0 08 	ret                                            
40018700:	81 e8 00 00 	restore                                        
    int  dot_at = -1;                                                 
    int  count = 0;                                                   
                                                                      
    while (*name && (count < name_len))                               
    {                                                                 
        bool is_dot = *name == '.';                                   
40018704:	80 a0 00 01 	cmp  %g0, %g1                                  
40018708:	ac 60 3f ff 	subx  %g0, -1, %l6                             
msdos_is_valid_name_char(const char ch)                               
{                                                                     
    if (strchr(" +,;=[]", ch) != NULL)                                
        return MSDOS_NAME_LONG;                                       
                                                                      
    if ((ch == '.') || isalnum((unsigned char)ch) ||                  
4001870c:	80 a5 a0 00 	cmp  %l6, 0                                    
40018710:	12 80 00 3c 	bne  40018800 <msdos_long_to_short+0x224>      
40018714:	82 0f 20 ff 	and  %i4, 0xff, %g1                            
40018718:	82 05 00 01 	add  %l4, %g1, %g1                             
4001871c:	c2 08 60 01 	ldub  [ %g1 + 1 ], %g1                         
40018720:	80 88 60 07 	btst  7, %g1                                   
40018724:	12 80 00 07 	bne  40018740 <msdos_long_to_short+0x164>      
40018728:	90 10 00 15 	mov  %l5, %o0                                  
        (strchr("$%'-_@~`!(){}^#&", ch) != NULL))                     
4001872c:	40 00 15 3f 	call  4001dc28 <strchr>                        
40018730:	92 10 00 1b 	mov  %i3, %o1                                  
msdos_is_valid_name_char(const char ch)                               
{                                                                     
    if (strchr(" +,;=[]", ch) != NULL)                                
        return MSDOS_NAME_LONG;                                       
                                                                      
    if ((ch == '.') || isalnum((unsigned char)ch) ||                  
40018734:	80 a2 20 00 	cmp  %o0, 0                                    
40018738:	02 bf ff c3 	be  40018644 <msdos_long_to_short+0x68>        <== NEVER TAKEN
4001873c:	01 00 00 00 	nop                                            
#endif                                                                
                                                                      
        if ((type == MSDOS_NAME_INVALID) || (type == MSDOS_NAME_LONG))
            return type;                                              
                                                                      
        if (dot_at >= 0)                                              
40018740:	80 a4 7f ff 	cmp  %l1, -1                                   
40018744:	02 80 00 27 	be  400187e0 <msdos_long_to_short+0x204>       
40018748:	82 27 40 11 	sub  %i5, %l1, %g1                             
        {                                                             
            if (is_dot || ((count - dot_at) > 3))                     
4001874c:	80 a0 60 03 	cmp  %g1, 3                                    
40018750:	34 bf ff e7 	bg,a   400186ec <msdos_long_to_short+0x110>    <== NEVER TAKEN
40018754:	b0 10 20 02 	mov  2, %i0                                    <== NOT EXECUTED
            }                                                         
        }                                                             
                                                                      
        if (is_dot)                                                   
            dot_at = count;                                           
        else if ((*name >= 'A') && (*name <= 'Z'))                    
40018758:	82 07 3f bf 	add  %i4, -65, %g1                             
4001875c:	82 08 60 ff 	and  %g1, 0xff, %g1                            
40018760:	80 a0 60 19 	cmp  %g1, 0x19                                 
40018764:	28 80 00 07 	bleu,a   40018780 <msdos_long_to_short+0x1a4>  
40018768:	a4 10 20 01 	mov  1, %l2                                    
            uppercase = true;                                         
        else if ((*name >= 'a') && (*name <= 'z'))                    
4001876c:	b8 07 3f 9f 	add  %i4, -97, %i4                             
40018770:	b8 0f 20 ff 	and  %i4, 0xff, %i4                            
40018774:	80 a7 20 19 	cmp  %i4, 0x19                                 
40018778:	28 80 00 02 	bleu,a   40018780 <msdos_long_to_short+0x1a4>  
4001877c:	a6 10 20 01 	mov  1, %l3                                    
            lowercase = true;                                         
                                                                      
        count++;                                                      
40018780:	ba 07 60 01 	inc  %i5                                       
    bool lowercase = false;                                           
    bool uppercase = false;                                           
    int  dot_at = -1;                                                 
    int  count = 0;                                                   
                                                                      
    while (*name && (count < name_len))                               
40018784:	f8 0c 00 1d 	ldub  [ %l0 + %i5 ], %i4                       
40018788:	85 2f 20 18 	sll  %i4, 0x18, %g2                            
4001878c:	80 a0 a0 00 	cmp  %g2, 0                                    
40018790:	02 80 00 04 	be  400187a0 <msdos_long_to_short+0x1c4>       
40018794:	80 a6 40 1d 	cmp  %i1, %i5                                  
40018798:	34 bf ff ce 	bg,a   400186d0 <msdos_long_to_short+0xf4>     
4001879c:	b7 38 a0 18 	sra  %g2, 0x18, %i3                            
400187a0:	a4 0c c0 12 	and  %l3, %l2, %l2                             
                                                                      
        count++;                                                      
        name++;                                                       
    }                                                                 
                                                                      
    if (lowercase && uppercase)                                       
400187a4:	80 8c a0 ff 	btst  0xff, %l2                                
400187a8:	12 bf ff d1 	bne  400186ec <msdos_long_to_short+0x110>      <== NEVER TAKEN
400187ac:	b0 10 20 02 	mov  2, %i0                                    
    }                                                                 
                                                                      
#if MSDOS_NAME_TYPE_PRINT                                             
    printf ("MSDOS_NAME_TYPE: SHORT[1]\n");                           
#endif                                                                
    return MSDOS_NAME_SHORT;                                          
400187b0:	b0 10 20 01 	mov  1, %i0                                    
        printf ("MSDOS_L2S: INVALID[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif                                                                
        return MSDOS_NAME_INVALID;                                    
    }                                                                 
                                                                      
    msdos_filename_unix2dos (lfn, lfn_len, sfn);                      
400187b4:	90 10 00 10 	mov  %l0, %o0                                  
400187b8:	92 10 00 19 	mov  %i1, %o1                                  
400187bc:	40 00 0b 8f 	call  4001b5f8 <msdos_filename_unix2dos>       
400187c0:	94 10 00 1a 	mov  %i2, %o2                                  
                                                                      
#if MSDOS_L2S_PRINT                                                   
    printf ("MSDOS_L2S: TYPE:%d lfn:'%s' SFN:'%s'\n", type, lfn, sfn);
#endif                                                                
    return type;                                                      
400187c4:	81 c7 e0 08 	ret                                            
400187c8:	81 e8 00 00 	restore                                        
     */                                                               
    for (i = 0; i < lfn_len; i++)                                     
        if ((lfn[i] != ' ') && (lfn[i] != '.'))                       
            break;                                                    
                                                                      
    if (i == lfn_len)                                                 
400187cc:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
400187d0:	12 bf ff f8 	bne  400187b0 <msdos_long_to_short+0x1d4>      <== NOT EXECUTED
400187d4:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
                                                                      
#if MSDOS_L2S_PRINT                                                   
    printf ("MSDOS_L2S: TYPE:%d lfn:'%s' SFN:'%s'\n", type, lfn, sfn);
#endif                                                                
    return type;                                                      
}                                                                     
400187d8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400187dc:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                return MSDOS_NAME_LONG;                               
            }                                                         
        }                                                             
        else                                                          
        {                                                             
            if (count == 8 && !is_dot)                                
400187e0:	80 a5 a0 00 	cmp  %l6, 0                                    
400187e4:	12 bf ff de 	bne  4001875c <msdos_long_to_short+0x180>      <== NEVER TAKEN
400187e8:	82 07 3f bf 	add  %i4, -65, %g1                             
400187ec:	80 a7 60 08 	cmp  %i5, 8                                    
400187f0:	12 bf ff dc 	bne  40018760 <msdos_long_to_short+0x184>      
400187f4:	82 08 60 ff 	and  %g1, 0xff, %g1                            
 */                                                                   
static msdos_name_type_t                                              
msdos_is_valid_name_char(const char ch)                               
{                                                                     
    if (strchr(" +,;=[]", ch) != NULL)                                
        return MSDOS_NAME_LONG;                                       
400187f8:	10 bf ff bd 	b  400186ec <msdos_long_to_short+0x110>        
400187fc:	b0 10 20 02 	mov  2, %i0                                    
#endif                                                                
                                                                      
        if ((type == MSDOS_NAME_INVALID) || (type == MSDOS_NAME_LONG))
            return type;                                              
                                                                      
        if (dot_at >= 0)                                              
40018800:	80 a4 7f ff 	cmp  %l1, -1                                   
40018804:	32 bf ff ba 	bne,a   400186ec <msdos_long_to_short+0x110>   
40018808:	b0 10 20 02 	mov  2, %i0                                    
4001880c:	10 bf ff dd 	b  40018780 <msdos_long_to_short+0x1a4>        
40018810:	a2 10 00 1d 	mov  %i5, %l1                                  
                                                                      

4000e9b0 <msdos_mknod>: const char *name, size_t namelen, mode_t mode, dev_t dev ) {
4000e9b0:	9d e3 bf a0 	save  %sp, -96, %sp                            
    msdos_node_type_t    type = 0;                                    
                                                                      
    /*                                                                
     *  Figure out what type of msdos node this is.                   
     */                                                               
    if (S_ISDIR(mode))                                                
4000e9b4:	03 00 00 3c 	sethi  %hi(0xf000), %g1                        
    const char *name,                                                 
    size_t namelen,                                                   
    mode_t mode,                                                      
    dev_t dev                                                         
)                                                                     
{                                                                     
4000e9b8:	b8 10 00 1b 	mov  %i3, %i4                                  
    msdos_node_type_t    type = 0;                                    
                                                                      
    /*                                                                
     *  Figure out what type of msdos node this is.                   
     */                                                               
    if (S_ISDIR(mode))                                                
4000e9bc:	82 0e c0 01 	and  %i3, %g1, %g1                             
4000e9c0:	05 00 00 10 	sethi  %hi(0x4000), %g2                        
    const char *name,                                                 
    size_t namelen,                                                   
    mode_t mode,                                                      
    dev_t dev                                                         
)                                                                     
{                                                                     
4000e9c4:	86 10 00 19 	mov  %i1, %g3                                  
    msdos_node_type_t    type = 0;                                    
                                                                      
    /*                                                                
     *  Figure out what type of msdos node this is.                   
     */                                                               
    if (S_ISDIR(mode))                                                
4000e9c8:	80 a0 40 02 	cmp  %g1, %g2                                  
4000e9cc:	02 80 00 09 	be  4000e9f0 <msdos_mknod+0x40>                
4000e9d0:	b6 10 00 1a 	mov  %i2, %i3                                  
    {                                                                 
       type = MSDOS_DIRECTORY;                                        
    }                                                                 
    else if (S_ISREG(mode))                                           
4000e9d4:	05 00 00 20 	sethi  %hi(0x8000), %g2                        
4000e9d8:	80 a0 40 02 	cmp  %g1, %g2                                  
4000e9dc:	12 80 00 09 	bne  4000ea00 <msdos_mknod+0x50>               <== NEVER TAKEN
4000e9e0:	b2 10 20 04 	mov  4, %i1                                    
    }                                                                 
    else                                                              
        rtems_set_errno_and_return_minus_one(EINVAL);                 
                                                                      
    /* Create an MSDOS node */                                        
    rc = msdos_creat_node(parentloc, type, name, namelen, mode, NULL);
4000e9e4:	b4 10 00 03 	mov  %g3, %i2                                  
4000e9e8:	40 00 25 9c 	call  40018058 <msdos_creat_node>              
4000e9ec:	9b e8 20 00 	restore  %g0, 0, %o5                           
    /*                                                                
     *  Figure out what type of msdos node this is.                   
     */                                                               
    if (S_ISDIR(mode))                                                
    {                                                                 
       type = MSDOS_DIRECTORY;                                        
4000e9f0:	b2 10 20 00 	clr  %i1                                       
    }                                                                 
    else                                                              
        rtems_set_errno_and_return_minus_one(EINVAL);                 
                                                                      
    /* Create an MSDOS node */                                        
    rc = msdos_creat_node(parentloc, type, name, namelen, mode, NULL);
4000e9f4:	b4 10 00 03 	mov  %g3, %i2                                  
4000e9f8:	40 00 25 98 	call  40018058 <msdos_creat_node>              
4000e9fc:	9b e8 20 00 	restore  %g0, 0, %o5                           
    else if (S_ISREG(mode))                                           
    {                                                                 
        type = MSDOS_REGULAR_FILE;                                    
    }                                                                 
    else                                                              
        rtems_set_errno_and_return_minus_one(EINVAL);                 
4000ea00:	40 00 36 64 	call  4001c390 <__errno>                       <== NOT EXECUTED
4000ea04:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4000ea08:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
4000ea0c:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
                                                                      
    /* Create an MSDOS node */                                        
    rc = msdos_creat_node(parentloc, type, name, namelen, mode, NULL);
                                                                      
    return rc;                                                        
}                                                                     
4000ea10:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000ea14:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4000ea24 <msdos_rename>: const rtems_filesystem_location_info_t *old_loc, const rtems_filesystem_location_info_t *new_parent_loc, const char *new_name, size_t new_namelen ) {
4000ea24:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
    int                rc = RC_OK;                                    
    fat_file_fd_t     *old_fat_fd  = old_loc->node_access;            
4000ea28:	fa 06 60 08 	ld  [ %i1 + 8 ], %i5                           <== NOT EXECUTED
                                                                      
    /*                                                                
     * create new directory entry as "hard link", copying relevant info from
     * existing file                                                  
     */                                                               
    rc = msdos_creat_node(new_parent_loc,                             
4000ea2c:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
4000ea30:	92 10 20 02 	mov  2, %o1                                    <== NOT EXECUTED
4000ea34:	94 10 00 1b 	mov  %i3, %o2                                  <== NOT EXECUTED
4000ea38:	96 10 00 1c 	mov  %i4, %o3                                  <== NOT EXECUTED
4000ea3c:	19 00 00 20 	sethi  %hi(0x8000), %o4                        <== NOT EXECUTED
4000ea40:	40 00 25 86 	call  40018058 <msdos_creat_node>              <== NOT EXECUTED
4000ea44:	9a 10 00 1d 	mov  %i5, %o5                                  <== NOT EXECUTED
                          MSDOS_HARD_LINK,new_name,new_namelen,S_IFREG,
                          old_fat_fd);                                
    if (rc != RC_OK)                                                  
4000ea48:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4000ea4c:	02 80 00 04 	be  4000ea5c <msdos_rename+0x38>               <== NOT EXECUTED
4000ea50:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
    rc = msdos_set_first_char4file_name(old_loc->mt_entry,            
                                        &old_fat_fd->dir_pos,         
                                        MSDOS_THIS_DIR_ENTRY_EMPTY);  
                                                                      
    return rc;                                                        
}                                                                     
4000ea54:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000ea58:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * mark file removed                                              
     */                                                               
    rc = msdos_set_first_char4file_name(old_loc->mt_entry,            
4000ea5c:	f0 06 60 14 	ld  [ %i1 + 0x14 ], %i0                        <== NOT EXECUTED
4000ea60:	b4 10 20 e5 	mov  0xe5, %i2                                 <== NOT EXECUTED
4000ea64:	40 00 28 15 	call  40018ab8 <msdos_set_first_char4file_name><== NOT EXECUTED
4000ea68:	93 ef 60 20 	restore  %i5, 0x20, %o1                        <== NOT EXECUTED
                                                                      

4000ea6c <msdos_rmnod>: #include "msdos.h" int msdos_rmnod(const rtems_filesystem_location_info_t *parent_pathloc, const rtems_filesystem_location_info_t *pathloc) {
4000ea6c:	9d e3 bf 98 	save  %sp, -104, %sp                           
    int                rc = RC_OK;                                    
    msdos_fs_info_t   *fs_info = pathloc->mt_entry->fs_info;          
    fat_file_fd_t     *fat_fd = pathloc->node_access;                 
4000ea70:	fa 06 60 08 	ld  [ %i1 + 8 ], %i5                           
int                                                                   
msdos_rmnod(const rtems_filesystem_location_info_t *parent_pathloc,   
            const rtems_filesystem_location_info_t *pathloc)          
{                                                                     
    int                rc = RC_OK;                                    
    msdos_fs_info_t   *fs_info = pathloc->mt_entry->fs_info;          
4000ea74:	d0 06 60 14 	ld  [ %i1 + 0x14 ], %o0                        
    fat_file_fd_t     *fat_fd = pathloc->node_access;                 
                                                                      
    if (fat_fd->fat_file_type == MSDOS_DIRECTORY)                     
4000ea78:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
4000ea7c:	80 a0 60 00 	cmp  %g1, 0                                    
4000ea80:	12 80 00 16 	bne  4000ead8 <msdos_rmnod+0x6c>               
4000ea84:	f8 02 20 08 	ld  [ %o0 + 8 ], %i4                           
    {                                                                 
        bool is_empty = false;                                        
4000ea88:	c0 2f bf ff 	clrb  [ %fp + -1 ]                             
                                                                      
        /*                                                            
         * You cannot remove a node that still has children           
         */                                                           
        rc = msdos_dir_is_empty(pathloc->mt_entry, fat_fd, &is_empty);
4000ea8c:	92 10 00 1d 	mov  %i5, %o1                                  
4000ea90:	40 00 28 76 	call  40018c68 <msdos_dir_is_empty>            
4000ea94:	94 07 bf ff 	add  %fp, -1, %o2                              
        if (rc != RC_OK)                                              
4000ea98:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4000ea9c:	12 80 00 0d 	bne  4000ead0 <msdos_rmnod+0x64>               <== NEVER TAKEN
4000eaa0:	c2 0f bf ff 	ldub  [ %fp + -1 ], %g1                        
        {                                                             
            return rc;                                                
        }                                                             
                                                                      
        if (!is_empty)                                                
4000eaa4:	80 a0 60 00 	cmp  %g1, 0                                    
4000eaa8:	02 80 00 16 	be  4000eb00 <msdos_rmnod+0x94>                
4000eaac:	01 00 00 00 	nop                                            
                                                                      
        /*                                                            
         * We deny attempts to delete open directory (if directory is current
         * directory we assume it is open one)                        
         */                                                           
        if (fat_fd->links_num > 1)                                    
4000eab0:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
4000eab4:	80 a0 60 01 	cmp  %g1, 1                                    
4000eab8:	28 80 00 08 	bleu,a   4000ead8 <msdos_rmnod+0x6c>           <== ALWAYS TAKEN
4000eabc:	d0 06 60 14 	ld  [ %i1 + 0x14 ], %o0                        
        {                                                             
            rtems_set_errno_and_return_minus_one(EBUSY);              
4000eac0:	40 00 36 34 	call  4001c390 <__errno>                       <== NOT EXECUTED
4000eac4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4000eac8:	82 10 20 10 	mov  0x10, %g1                                 <== NOT EXECUTED
4000eacc:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4000ead0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000ead4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
         * not used - mount() not implemenetd yet.                    
         */                                                           
    }                                                                 
                                                                      
    /* mark file removed */                                           
    rc = msdos_set_first_char4file_name(pathloc->mt_entry, &fat_fd->dir_pos,
4000ead8:	92 07 60 20 	add  %i5, 0x20, %o1                            
4000eadc:	40 00 27 f7 	call  40018ab8 <msdos_set_first_char4file_name>
4000eae0:	94 10 20 e5 	mov  0xe5, %o2                                 
                                        MSDOS_THIS_DIR_ENTRY_EMPTY);  
    if (rc != RC_OK)                                                  
4000eae4:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4000eae8:	12 bf ff fa 	bne  4000ead0 <msdos_rmnod+0x64>               <== NEVER TAKEN
4000eaec:	90 10 00 1c 	mov  %i4, %o0                                  
    {                                                                 
        return rc;                                                    
    }                                                                 
                                                                      
    fat_file_mark_removed(&fs_info->fat, fat_fd);                     
4000eaf0:	40 00 11 79 	call  400130d4 <fat_file_mark_removed>         
4000eaf4:	92 10 00 1d 	mov  %i5, %o1                                  
                                                                      
    return rc;                                                        
}                                                                     
4000eaf8:	81 c7 e0 08 	ret                                            
4000eafc:	81 e8 00 00 	restore                                        
            return rc;                                                
        }                                                             
                                                                      
        if (!is_empty)                                                
        {                                                             
            rtems_set_errno_and_return_minus_one(ENOTEMPTY);          
4000eb00:	40 00 36 24 	call  4001c390 <__errno>                       
4000eb04:	b0 10 3f ff 	mov  -1, %i0                                   
4000eb08:	82 10 20 5a 	mov  0x5a, %g1                                 
4000eb0c:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4000eb10:	81 c7 e0 08 	ret                                            
4000eb14:	81 e8 00 00 	restore                                        
                                                                      

40018814 <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 ) {
40018814:	9d e3 bf 98 	save  %sp, -104, %sp                           
    uint16_t         time_val;                                        
    uint16_t         date;                                            
    uint32_t         sec = 0;                                         
    uint32_t         byte = 0;                                        
                                                                      
    msdos_date_unix2dos(fat_fd->mtime, &date, &time_val);             
40018818:	d0 06 60 40 	ld  [ %i1 + 0x40 ], %o0                        
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    fat_file_fd_t                        *fat_fd                      
    )                                                                 
{                                                                     
    ssize_t          ret1 = 0, ret2 = 0, ret3 = 0;                    
    msdos_fs_info_t *fs_info = mt_entry->fs_info;                     
4001881c:	fa 06 20 08 	ld  [ %i0 + 8 ], %i5                           
    uint16_t         time_val;                                        
    uint16_t         date;                                            
    uint32_t         sec = 0;                                         
    uint32_t         byte = 0;                                        
                                                                      
    msdos_date_unix2dos(fat_fd->mtime, &date, &time_val);             
40018820:	92 07 bf fe 	add  %fp, -2, %o1                              
40018824:	40 00 0a c9 	call  4001b348 <msdos_date_unix2dos>           
40018828:	94 07 bf fc 	add  %fp, -4, %o2                              
                                                                      
    /*                                                                
     * calculate input for fat_sector_write: convert (cluster num, offset) to
     * (sector num, new offset)                                       
     */                                                               
    sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
4001882c:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
fat_cluster_num_to_sector_num(                                        
    const fat_fs_info_t *fs_info,                                     
    uint32_t             cln                                          
    )                                                                 
{                                                                     
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
40018830:	80 a0 60 00 	cmp  %g1, 0                                    
40018834:	32 80 00 07 	bne,a   40018850 <msdos_set_dir_wrt_time_and_date+0x3c>
40018838:	c6 0f 60 05 	ldub  [ %i5 + 5 ], %g3                         
4001883c:	c4 0f 60 0e 	ldub  [ %i5 + 0xe ], %g2                       
40018840:	80 88 a0 03 	btst  3, %g2                                   
40018844:	32 80 00 07 	bne,a   40018860 <msdos_set_dir_wrt_time_and_date+0x4c><== ALWAYS TAKEN
40018848:	f6 07 60 20 	ld  [ %i5 + 0x20 ], %i3                        
        return fs_info->vol.rdir_loc;                                 
                                                                      
    return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +        
4001884c:	c6 0f 60 05 	ldub  [ %i5 + 5 ], %g3                         <== NOT EXECUTED
40018850:	c4 07 60 34 	ld  [ %i5 + 0x34 ], %g2                        
40018854:	b6 00 7f fe 	add  %g1, -2, %i3                              
40018858:	b7 2e c0 03 	sll  %i3, %g3, %i3                             
4001885c:	b6 06 c0 02 	add  %i3, %g2, %i3                             
    sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);  
40018860:	c4 06 60 24 	ld  [ %i1 + 0x24 ], %g2                        
    /* byte points to start of 32bytes structure */                   
    byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);    
40018864:	f8 17 40 00 	lduh  [ %i5 ], %i4                             
                                                                      
    time_val = CT_LE_W(time_val);                                     
40018868:	c2 17 bf fc 	lduh  [ %fp + -4 ], %g1                        
    /*                                                                
     * calculate input for fat_sector_write: convert (cluster num, offset) to
     * (sector num, new offset)                                       
     */                                                               
    sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
    sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);  
4001886c:	c6 0f 60 02 	ldub  [ %i5 + 2 ], %g3                         
    /* 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);                                     
40018870:	83 28 60 10 	sll  %g1, 0x10, %g1                            
    /*                                                                
     * calculate input for fat_sector_write: convert (cluster num, offset) to
     * (sector num, new offset)                                       
     */                                                               
    sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
    sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);  
40018874:	87 30 80 03 	srl  %g2, %g3, %g3                             
    /* byte points to start of 32bytes structure */                   
    byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);    
40018878:	b8 07 3f ff 	add  %i4, -1, %i4                              
4001887c:	b8 0f 00 02 	and  %i4, %g2, %i4                             
                                                                      
    time_val = CT_LE_W(time_val);                                     
40018880:	85 30 60 08 	srl  %g1, 8, %g2                               
40018884:	83 30 60 18 	srl  %g1, 0x18, %g1                            
40018888:	82 10 80 01 	or  %g2, %g1, %g1                              
    /*                                                                
     * calculate input for fat_sector_write: convert (cluster num, offset) to
     * (sector num, new offset)                                       
     */                                                               
    sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
    sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);  
4001888c:	b6 06 c0 03 	add  %i3, %g3, %i3                             
    /* 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_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
40018890:	94 07 20 16 	add  %i4, 0x16, %o2                            
40018894:	92 10 00 1b 	mov  %i3, %o1                                  
40018898:	96 10 20 02 	mov  2, %o3                                    
4001889c:	98 07 bf fc 	add  %fp, -4, %o4                              
    sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
    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);                                     
400188a0:	c2 37 bf fc 	sth  %g1, [ %fp + -4 ]                         
    ret1 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
400188a4:	7f ff eb 2d 	call  40013558 <fat_sector_write>              
400188a8:	90 10 00 1d 	mov  %i5, %o0                                  
                            2, (char *)(&time_val));                  
    date = CT_LE_W(date);                                             
400188ac:	c2 17 bf fe 	lduh  [ %fp + -2 ], %g1                        
    ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
400188b0:	94 07 20 18 	add  %i4, 0x18, %o2                            
    byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);    
                                                                      
    time_val = CT_LE_W(time_val);                                     
    ret1 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
                            2, (char *)(&time_val));                  
    date = CT_LE_W(date);                                             
400188b4:	83 28 60 10 	sll  %g1, 0x10, %g1                            
400188b8:	85 30 60 08 	srl  %g1, 8, %g2                               
400188bc:	83 30 60 18 	srl  %g1, 0x18, %g1                            
400188c0:	82 10 80 01 	or  %g2, %g1, %g1                              
    ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
400188c4:	96 10 20 02 	mov  2, %o3                                    
400188c8:	98 07 bf fe 	add  %fp, -2, %o4                              
    byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);    
                                                                      
    time_val = CT_LE_W(time_val);                                     
    ret1 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
                            2, (char *)(&time_val));                  
    date = CT_LE_W(date);                                             
400188cc:	c2 37 bf fe 	sth  %g1, [ %fp + -2 ]                         
    ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
400188d0:	92 10 00 1b 	mov  %i3, %o1                                  
    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_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
400188d4:	b2 10 00 08 	mov  %o0, %i1                                  
                            2, (char *)(&time_val));                  
    date = CT_LE_W(date);                                             
    ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
400188d8:	7f ff eb 20 	call  40013558 <fat_sector_write>              
400188dc:	90 10 00 1d 	mov  %i5, %o0                                  
                            2, (char *)(&date));                      
    ret3 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_ADATE_OFFSET,
400188e0:	92 10 00 1b 	mov  %i3, %o1                                  
                                                                      
    time_val = CT_LE_W(time_val);                                     
    ret1 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
                            2, (char *)(&time_val));                  
    date = CT_LE_W(date);                                             
    ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
400188e4:	b4 10 00 08 	mov  %o0, %i2                                  
                            2, (char *)(&date));                      
    ret3 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_ADATE_OFFSET,
400188e8:	94 07 20 12 	add  %i4, 0x12, %o2                            
400188ec:	90 10 00 1d 	mov  %i5, %o0                                  
400188f0:	96 10 20 02 	mov  2, %o3                                    
400188f4:	7f ff eb 19 	call  40013558 <fat_sector_write>              
400188f8:	98 07 bf fe 	add  %fp, -2, %o4                              
                            2, (char *)(&date));                      
                                                                      
    if ( (ret1 < 0) || (ret2 < 0) || (ret3 < 0) )                     
400188fc:	80 a6 a0 00 	cmp  %i2, 0                                    
40018900:	06 80 00 08 	bl  40018920 <msdos_set_dir_wrt_time_and_date+0x10c><== NEVER TAKEN
40018904:	80 a6 60 00 	cmp  %i1, 0                                    
40018908:	06 80 00 06 	bl  40018920 <msdos_set_dir_wrt_time_and_date+0x10c><== NEVER TAKEN
4001890c:	80 a2 20 00 	cmp  %o0, 0                                    
40018910:	06 80 00 04 	bl  40018920 <msdos_set_dir_wrt_time_and_date+0x10c><== NEVER TAKEN
40018914:	01 00 00 00 	nop                                            
        return -1;                                                    
                                                                      
    return RC_OK;                                                     
}                                                                     
40018918:	81 c7 e0 08 	ret                                            
4001891c:	91 e8 20 00 	restore  %g0, 0, %o0                           
                            2, (char *)(&date));                      
    ret3 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_ADATE_OFFSET,
                            2, (char *)(&date));                      
                                                                      
    if ( (ret1 < 0) || (ret2 < 0) || (ret3 < 0) )                     
        return -1;                                                    
40018920:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40018924:	91 e8 3f ff 	restore  %g0, -1, %o0                          <== NOT EXECUTED
                                                                      

40018a14 <msdos_set_file_size>: int msdos_set_file_size( rtems_filesystem_mount_table_entry_t *mt_entry, fat_file_fd_t *fat_fd ) {
40018a14:	9d e3 bf 98 	save  %sp, -104, %sp                           
    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(&fs_info->fat, fat_fd->dir_pos.sname.cln);
40018a18:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
fat_cluster_num_to_sector_num(                                        
    const fat_fs_info_t *fs_info,                                     
    uint32_t             cln                                          
    )                                                                 
{                                                                     
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
40018a1c:	80 a0 60 00 	cmp  %g1, 0                                    
40018a20:	12 80 00 06 	bne  40018a38 <msdos_set_file_size+0x24>       
40018a24:	d0 06 20 08 	ld  [ %i0 + 8 ], %o0                           
40018a28:	c4 0a 20 0e 	ldub  [ %o0 + 0xe ], %g2                       
40018a2c:	80 88 a0 03 	btst  3, %g2                                   
40018a30:	32 80 00 07 	bne,a   40018a4c <msdos_set_file_size+0x38>    <== ALWAYS TAKEN
40018a34:	d2 02 20 20 	ld  [ %o0 + 0x20 ], %o1                        
        return fs_info->vol.rdir_loc;                                 
                                                                      
    return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +        
40018a38:	c6 0a 20 05 	ldub  [ %o0 + 5 ], %g3                         
40018a3c:	c4 02 20 34 	ld  [ %o0 + 0x34 ], %g2                        
40018a40:	92 00 7f fe 	add  %g1, -2, %o1                              
40018a44:	93 2a 40 03 	sll  %o1, %g3, %o1                             
40018a48:	92 02 40 02 	add  %o1, %g2, %o1                             
    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));  
40018a4c:	c6 12 00 00 	lduh  [ %o0 ], %g3                             
                                                                      
    le_new_length = CT_LE_L((fat_fd->fat_file_size));                 
40018a50:	c2 06 60 18 	ld  [ %i1 + 0x18 ], %g1                        
    uint32_t         le_new_length = 0;                               
    uint32_t         sec = 0;                                         
    uint32_t         byte = 0;                                        
                                                                      
    sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
    sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);  
40018a54:	c4 06 60 24 	ld  [ %i1 + 0x24 ], %g2                        
40018a58:	c8 0a 20 02 	ldub  [ %o0 + 2 ], %g4                         
    byte = (fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));  
40018a5c:	86 00 ff ff 	add  %g3, -1, %g3                              
    uint32_t         le_new_length = 0;                               
    uint32_t         sec = 0;                                         
    uint32_t         byte = 0;                                        
                                                                      
    sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
    sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);  
40018a60:	89 30 80 04 	srl  %g2, %g4, %g4                             
    byte = (fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));  
40018a64:	94 08 c0 02 	and  %g3, %g2, %o2                             
40018a68:	b9 28 60 18 	sll  %g1, 0x18, %i4                            
  uint32_t value                                                      
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
40018a6c:	87 30 60 18 	srl  %g1, 0x18, %g3                            
  byte3 = (value >> 16) & 0xff;                                       
  byte2 = (value >> 8)  & 0xff;                                       
40018a70:	bb 30 60 08 	srl  %g1, 8, %i5                               
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
40018a74:	86 17 00 03 	or  %i4, %g3, %g3                              
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
  byte3 = (value >> 16) & 0xff;                                       
  byte2 = (value >> 8)  & 0xff;                                       
40018a78:	ba 0f 60 ff 	and  %i5, 0xff, %i5                            
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
  byte3 = (value >> 16) & 0xff;                                       
40018a7c:	83 30 60 10 	srl  %g1, 0x10, %g1                            
  byte2 = (value >> 8)  & 0xff;                                       
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
40018a80:	bb 2f 60 10 	sll  %i5, 0x10, %i5                            
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
  byte3 = (value >> 16) & 0xff;                                       
40018a84:	82 08 60 ff 	and  %g1, 0xff, %g1                            
  byte2 = (value >> 8)  & 0xff;                                       
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
40018a88:	86 10 c0 1d 	or  %g3, %i5, %g3                              
40018a8c:	83 28 60 08 	sll  %g1, 8, %g1                               
40018a90:	86 10 c0 01 	or  %g3, %g1, %g3                              
                                                                      
    le_new_length = CT_LE_L((fat_fd->fat_file_size));                 
    ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_SIZE_OFFSET, 4,
40018a94:	92 02 40 04 	add  %o1, %g4, %o1                             
                                                                      
    sec = fat_cluster_num_to_sector_num(&fs_info->fat, 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));  
                                                                      
    le_new_length = CT_LE_L((fat_fd->fat_file_size));                 
40018a98:	c6 27 bf fc 	st  %g3, [ %fp + -4 ]                          
    ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_SIZE_OFFSET, 4,
40018a9c:	94 02 a0 1c 	add  %o2, 0x1c, %o2                            
40018aa0:	96 10 20 04 	mov  4, %o3                                    
40018aa4:	7f ff ea ad 	call  40013558 <fat_sector_write>              
40018aa8:	98 07 bf fc 	add  %fp, -4, %o4                              
                           (char *)(&le_new_length));                 
    if ( ret < 0 )                                                    
        return -1;                                                    
                                                                      
    return RC_OK;                                                     
}                                                                     
40018aac:	b1 3a 20 1f 	sra  %o0, 0x1f, %i0                            
40018ab0:	81 c7 e0 08 	ret                                            
40018ab4:	81 e8 00 00 	restore                                        
                                                                      

40018ab8 <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 ) {
40018ab8:	9d e3 bf 90 	save  %sp, -112, %sp                           
    ssize_t          ret;                                             
    msdos_fs_info_t *fs_info = mt_entry->fs_info;                     
40018abc:	fa 06 20 08 	ld  [ %i0 + 8 ], %i5                           
    uint32_t         dir_block_size;                                  
    fat_pos_t        start = dir_pos->lname;                          
    fat_pos_t        end = dir_pos->sname;                            
40018ac0:	f8 06 40 00 	ld  [ %i1 ], %i4                               
    )                                                                 
{                                                                     
    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;                          
40018ac4:	c8 06 60 08 	ld  [ %i1 + 8 ], %g4                           
40018ac8:	c6 06 60 0c 	ld  [ %i1 + 0xc ], %g3                         
    fat_pos_t        end = dir_pos->sname;                            
40018acc:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
                                                                      
    if ((end.cln == fs_info->fat.vol.rdir_cl) &&                      
40018ad0:	c4 07 60 3c 	ld  [ %i5 + 0x3c ], %g2                        
msdos_set_first_char4file_name(                                       
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    fat_dir_pos_t                        *dir_pos,                    
    unsigned char                         fchar                       
    )                                                                 
{                                                                     
40018ad4:	f4 2f a0 4c 	stb  %i2, [ %fp + 0x4c ]                       
    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;                          
40018ad8:	c8 27 bf f0 	st  %g4, [ %fp + -16 ]                         
40018adc:	c6 27 bf f4 	st  %g3, [ %fp + -12 ]                         
    fat_pos_t        end = dir_pos->sname;                            
40018ae0:	f8 27 bf f8 	st  %i4, [ %fp + -8 ]                          
                                                                      
    if ((end.cln == fs_info->fat.vol.rdir_cl) &&                      
40018ae4:	80 a7 00 02 	cmp  %i4, %g2                                  
40018ae8:	02 80 00 56 	be  40018c40 <msdos_set_first_char4file_name+0x188><== ALWAYS TAKEN
40018aec:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
        (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))            
      dir_block_size = fs_info->fat.vol.rdir_size;                    
    else                                                              
      dir_block_size = fs_info->fat.vol.bpc;                          
                                                                      
    if (dir_pos->lname.cln == FAT_FILE_SHORT_NAME)                    
40018af0:	c4 06 60 08 	ld  [ %i1 + 8 ], %g2                           <== NOT EXECUTED
40018af4:	80 a0 bf ff 	cmp  %g2, -1                                   <== NOT EXECUTED
40018af8:	02 80 00 59 	be  40018c5c <msdos_set_first_char4file_name+0x1a4><== NOT EXECUTED
40018afc:	f6 17 60 06 	lduh  [ %i5 + 6 ], %i3                         <== NOT EXECUTED
40018b00:	c2 07 bf f4 	ld  [ %fp + -12 ], %g1                         
40018b04:	c4 0f 60 02 	ldub  [ %i5 + 2 ], %g2                         
40018b08:	d4 17 40 00 	lduh  [ %i5 ], %o2                             
40018b0c:	10 80 00 1d 	b  40018b80 <msdos_set_first_char4file_name+0xc8>
40018b10:	d2 07 bf f0 	ld  [ %fp + -16 ], %o1                         
fat_cluster_num_to_sector_num(                                        
    const fat_fs_info_t *fs_info,                                     
    uint32_t             cln                                          
    )                                                                 
{                                                                     
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
40018b14:	80 88 e0 03 	btst  3, %g3                                   
40018b18:	22 80 00 1e 	be,a   40018b90 <msdos_set_first_char4file_name+0xd8><== NEVER TAKEN
40018b1c:	c8 0f 60 05 	ldub  [ %i5 + 5 ], %g4                         <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
40018b20:	d2 07 60 20 	ld  [ %i5 + 0x20 ], %o1                        
     * interface.                                                     
     */                                                               
    while (true)                                                      
    {                                                                 
      uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
                      (start.ofs >> fs_info->fat.vol.sec_log2));      
40018b24:	85 30 40 02 	srl  %g1, %g2, %g2                             
      uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));       
40018b28:	95 2a a0 10 	sll  %o2, 0x10, %o2                            
                                                                      
      ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
40018b2c:	90 10 00 1d 	mov  %i5, %o0                                  
     */                                                               
    while (true)                                                      
    {                                                                 
      uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
                      (start.ofs >> fs_info->fat.vol.sec_log2));      
      uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));       
40018b30:	95 32 a0 10 	srl  %o2, 0x10, %o2                            
                                                                      
      ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
40018b34:	92 02 40 02 	add  %o1, %g2, %o1                             
     */                                                               
    while (true)                                                      
    {                                                                 
      uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
                      (start.ofs >> fs_info->fat.vol.sec_log2));      
      uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));       
40018b38:	94 02 bf ff 	add  %o2, -1, %o2                              
                                                                      
      ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
40018b3c:	96 10 20 01 	mov  1, %o3                                    
40018b40:	94 08 40 0a 	and  %g1, %o2, %o2                             
40018b44:	7f ff ea 85 	call  40013558 <fat_sector_write>              
40018b48:	98 07 a0 4c 	add  %fp, 0x4c, %o4                            
                             1, &fchar);                              
      if (ret < 0)                                                    
40018b4c:	80 a2 20 00 	cmp  %o0, 0                                    
40018b50:	06 80 00 22 	bl  40018bd8 <msdos_set_first_char4file_name+0x120><== NEVER TAKEN
40018b54:	90 10 3f ff 	mov  -1, %o0                                   
        return -1;                                                    
                                                                      
      if ((start.cln == end.cln) && (start.ofs == end.ofs))           
40018b58:	d2 07 bf f0 	ld  [ %fp + -16 ], %o1                         
40018b5c:	80 a7 00 09 	cmp  %i4, %o1                                  
40018b60:	02 80 00 20 	be  40018be0 <msdos_set_first_char4file_name+0x128><== ALWAYS TAKEN
40018b64:	c2 07 bf f4 	ld  [ %fp + -12 ], %g1                         
        break;                                                        
                                                                      
      start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;                 
40018b68:	82 00 60 20 	add  %g1, 0x20, %g1                            <== NOT EXECUTED
      if (start.ofs >= dir_block_size)                                
40018b6c:	80 a6 c0 01 	cmp  %i3, %g1                                  
40018b70:	08 80 00 23 	bleu  40018bfc <msdos_set_first_char4file_name+0x144><== NEVER TAKEN
40018b74:	c2 27 bf f4 	st  %g1, [ %fp + -12 ]                         
40018b78:	c4 0f 60 02 	ldub  [ %i5 + 2 ], %g2                         
40018b7c:	d4 17 40 00 	lduh  [ %i5 ], %o2                             
fat_cluster_num_to_sector_num(                                        
    const fat_fs_info_t *fs_info,                                     
    uint32_t             cln                                          
    )                                                                 
{                                                                     
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
40018b80:	80 a2 60 00 	cmp  %o1, 0                                    
40018b84:	22 bf ff e4 	be,a   40018b14 <msdos_set_first_char4file_name+0x5c><== ALWAYS TAKEN
40018b88:	c6 0f 60 0e 	ldub  [ %i5 + 0xe ], %g3                       
        return fs_info->vol.rdir_loc;                                 
                                                                      
    return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +        
40018b8c:	c8 0f 60 05 	ldub  [ %i5 + 5 ], %g4                         <== NOT EXECUTED
40018b90:	c6 07 60 34 	ld  [ %i5 + 0x34 ], %g3                        <== NOT EXECUTED
     * interface.                                                     
     */                                                               
    while (true)                                                      
    {                                                                 
      uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
                      (start.ofs >> fs_info->fat.vol.sec_log2));      
40018b94:	85 30 40 02 	srl  %g1, %g2, %g2                             <== NOT EXECUTED
40018b98:	92 02 7f fe 	add  %o1, -2, %o1                              <== NOT EXECUTED
      uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));       
40018b9c:	95 2a a0 10 	sll  %o2, 0x10, %o2                            <== NOT EXECUTED
40018ba0:	93 2a 40 04 	sll  %o1, %g4, %o1                             <== NOT EXECUTED
                                                                      
      ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
40018ba4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40018ba8:	92 02 40 03 	add  %o1, %g3, %o1                             <== NOT EXECUTED
     */                                                               
    while (true)                                                      
    {                                                                 
      uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
                      (start.ofs >> fs_info->fat.vol.sec_log2));      
      uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));       
40018bac:	95 32 a0 10 	srl  %o2, 0x10, %o2                            <== NOT EXECUTED
                                                                      
      ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
40018bb0:	92 02 40 02 	add  %o1, %g2, %o1                             <== NOT EXECUTED
     */                                                               
    while (true)                                                      
    {                                                                 
      uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
                      (start.ofs >> fs_info->fat.vol.sec_log2));      
      uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));       
40018bb4:	94 02 bf ff 	add  %o2, -1, %o2                              <== NOT EXECUTED
                                                                      
      ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
40018bb8:	96 10 20 01 	mov  1, %o3                                    <== NOT EXECUTED
40018bbc:	94 08 40 0a 	and  %g1, %o2, %o2                             <== NOT EXECUTED
40018bc0:	7f ff ea 66 	call  40013558 <fat_sector_write>              <== NOT EXECUTED
40018bc4:	98 07 a0 4c 	add  %fp, 0x4c, %o4                            <== NOT EXECUTED
                             1, &fchar);                              
      if (ret < 0)                                                    
40018bc8:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40018bcc:	16 bf ff e4 	bge  40018b5c <msdos_set_first_char4file_name+0xa4><== NOT EXECUTED
40018bd0:	d2 07 bf f0 	ld  [ %fp + -16 ], %o1                         <== NOT EXECUTED
        return -1;                                                    
40018bd4:	90 10 3f ff 	mov  -1, %o0                                   <== NOT EXECUTED
        start.ofs = 0;                                                
      }                                                               
    }                                                                 
                                                                      
    return  RC_OK;                                                    
}                                                                     
40018bd8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40018bdc:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
      ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
                             1, &fchar);                              
      if (ret < 0)                                                    
        return -1;                                                    
                                                                      
      if ((start.cln == end.cln) && (start.ofs == end.ofs))           
40018be0:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
40018be4:	80 a0 40 02 	cmp  %g1, %g2                                  
40018be8:	32 bf ff e1 	bne,a   40018b6c <msdos_set_first_char4file_name+0xb4>
40018bec:	82 00 60 20 	add  %g1, 0x20, %g1                            
          return rc;                                                  
        start.ofs = 0;                                                
      }                                                               
    }                                                                 
                                                                      
    return  RC_OK;                                                    
40018bf0:	90 10 20 00 	clr  %o0                                       
}                                                                     
40018bf4:	81 c7 e0 08 	ret                                            
40018bf8:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      
      start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;                 
      if (start.ofs >= dir_block_size)                                
      {                                                               
        int rc;                                                       
        if ((end.cln == fs_info->fat.vol.rdir_cl) &&                  
40018bfc:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        <== NOT EXECUTED
40018c00:	80 a7 00 01 	cmp  %i4, %g1                                  <== NOT EXECUTED
40018c04:	12 80 00 06 	bne  40018c1c <msdos_set_first_char4file_name+0x164><== NOT EXECUTED
40018c08:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
            (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))        
40018c0c:	c2 0f 60 0e 	ldub  [ %i5 + 0xe ], %g1                       <== NOT EXECUTED
                                                                      
      start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;                 
      if (start.ofs >= dir_block_size)                                
      {                                                               
        int rc;                                                       
        if ((end.cln == fs_info->fat.vol.rdir_cl) &&                  
40018c10:	80 88 60 03 	btst  3, %g1                                   <== NOT EXECUTED
40018c14:	32 bf ff f8 	bne,a   40018bf4 <msdos_set_first_char4file_name+0x13c><== NOT EXECUTED
40018c18:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
            (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))        
          break;                                                      
        rc = fat_get_fat_cluster(&fs_info->fat, start.cln, &start.cln);
40018c1c:	40 00 05 48 	call  4001a13c <fat_get_fat_cluster>           <== NOT EXECUTED
40018c20:	94 07 bf f0 	add  %fp, -16, %o2                             <== NOT EXECUTED
        if ( rc != RC_OK )                                            
40018c24:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40018c28:	12 bf ff ec 	bne  40018bd8 <msdos_set_first_char4file_name+0x120><== NOT EXECUTED
40018c2c:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
          return rc;                                                  
        start.ofs = 0;                                                
40018c30:	c0 27 bf f4 	clr  [ %fp + -12 ]                             <== NOT EXECUTED
40018c34:	d4 17 40 00 	lduh  [ %i5 ], %o2                             <== NOT EXECUTED
40018c38:	10 bf ff b5 	b  40018b0c <msdos_set_first_char4file_name+0x54><== NOT EXECUTED
40018c3c:	c4 0f 60 02 	ldub  [ %i5 + 2 ], %g2                         <== 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)))            
40018c40:	c4 0f 60 0e 	ldub  [ %i5 + 0xe ], %g2                       
    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;                            
                                                                      
    if ((end.cln == fs_info->fat.vol.rdir_cl) &&                      
40018c44:	80 88 a0 03 	btst  3, %g2                                   
40018c48:	02 bf ff ab 	be  40018af4 <msdos_set_first_char4file_name+0x3c><== NEVER TAKEN
40018c4c:	c4 06 60 08 	ld  [ %i1 + 8 ], %g2                           
        (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))            
      dir_block_size = fs_info->fat.vol.rdir_size;                    
    else                                                              
      dir_block_size = fs_info->fat.vol.bpc;                          
                                                                      
    if (dir_pos->lname.cln == FAT_FILE_SHORT_NAME)                    
40018c50:	80 a0 bf ff 	cmp  %g2, -1                                   
40018c54:	12 bf ff ab 	bne  40018b00 <msdos_set_first_char4file_name+0x48>
40018c58:	f6 07 60 2c 	ld  [ %i5 + 0x2c ], %i3                        
      start = dir_pos->sname;                                         
40018c5c:	f8 27 bf f0 	st  %i4, [ %fp + -16 ]                         
40018c60:	10 bf ff a8 	b  40018b00 <msdos_set_first_char4file_name+0x48>
40018c64:	c2 27 bf f4 	st  %g1, [ %fp + -12 ]                         
                                                                      

40018928 <msdos_set_first_cluster_num>: int msdos_set_first_cluster_num( rtems_filesystem_mount_table_entry_t *mt_entry, fat_file_fd_t *fat_fd ) {
40018928:	9d e3 bf 98 	save  %sp, -104, %sp                           
                                                                      
    /*                                                                
     * calculate input for fat_sector_write: convert (cluster num, offset) to
     * (sector num, new offset)                                       
     */                                                               
    sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
4001892c:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
{                                                                     
    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;                                    
40018930:	c0 37 bf fe 	clrh  [ %fp + -2 ]                             
    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;                     
40018934:	fa 06 20 08 	ld  [ %i0 + 8 ], %i5                           
fat_cluster_num_to_sector_num(                                        
    const fat_fs_info_t *fs_info,                                     
    uint32_t             cln                                          
    )                                                                 
{                                                                     
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
40018938:	80 a0 60 00 	cmp  %g1, 0                                    
4001893c:	12 80 00 06 	bne  40018954 <msdos_set_first_cluster_num+0x2c>
40018940:	f8 06 60 1c 	ld  [ %i1 + 0x1c ], %i4                        
40018944:	c4 0f 60 0e 	ldub  [ %i5 + 0xe ], %g2                       
40018948:	80 88 a0 03 	btst  3, %g2                                   
4001894c:	32 80 00 07 	bne,a   40018968 <msdos_set_first_cluster_num+0x40><== ALWAYS TAKEN
40018950:	f4 07 60 20 	ld  [ %i5 + 0x20 ], %i2                        
        return fs_info->vol.rdir_loc;                                 
                                                                      
    return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +        
40018954:	c6 0f 60 05 	ldub  [ %i5 + 5 ], %g3                         
40018958:	c4 07 60 34 	ld  [ %i5 + 0x34 ], %g2                        
4001895c:	b4 00 7f fe 	add  %g1, -2, %i2                              
40018960:	b5 2e 80 03 	sll  %i2, %g3, %i2                             
40018964:	b4 06 80 02 	add  %i2, %g2, %i2                             
    /*                                                                
     * calculate input for fat_sector_write: convert (cluster num, offset) to
     * (sector num, new offset)                                       
     */                                                               
    sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
    sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);  
40018968:	c2 06 60 24 	ld  [ %i1 + 0x24 ], %g1                        
4001896c:	c4 0f 60 02 	ldub  [ %i5 + 2 ], %g2                         
    /* byte from points to start of 32bytes structure */              
    byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);    
40018970:	f6 17 40 00 	lduh  [ %i5 ], %i3                             
    /*                                                                
     * calculate input for fat_sector_write: convert (cluster num, offset) to
     * (sector num, new offset)                                       
     */                                                               
    sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
    sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);  
40018974:	85 30 40 02 	srl  %g1, %g2, %g2                             
    /* byte from points to start of 32bytes structure */              
    byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);    
40018978:	b6 06 ff ff 	add  %i3, -1, %i3                              
    /*                                                                
     * calculate input for fat_sector_write: convert (cluster num, offset) to
     * (sector num, new offset)                                       
     */                                                               
    sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
    sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);  
4001897c:	b4 06 80 02 	add  %i2, %g2, %i2                             
    /* byte from points to start of 32bytes structure */              
    byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);    
40018980:	b6 0e c0 01 	and  %i3, %g1, %i3                             
                                                                      
    le_cl_low = CT_LE_W((uint16_t  )(new_cln & 0x0000FFFF));          
40018984:	85 2f 20 10 	sll  %i4, 0x10, %g2                            
                                                                      
    rc = fat_sync(&fs_info->fat);                                     
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
    return rc;                                                        
}                                                                     
40018988:	33 00 00 3f 	sethi  %hi(0xfc00), %i1                        
    sec = fat_cluster_num_to_sector_num(&fs_info->fat, 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));          
4001898c:	85 30 a0 18 	srl  %g2, 0x18, %g2                            
                                                                      
    rc = fat_sync(&fs_info->fat);                                     
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
    return rc;                                                        
}                                                                     
40018990:	b2 16 63 ff 	or  %i1, 0x3ff, %i1                            
40018994:	82 0f 00 19 	and  %i4, %i1, %g1                             
    sec = fat_cluster_num_to_sector_num(&fs_info->fat, 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));          
40018998:	83 28 60 08 	sll  %g1, 8, %g1                               
4001899c:	82 10 40 02 	or  %g1, %g2, %g1                              
    ret1 = fat_sector_write(&fs_info->fat, sec,                       
400189a0:	94 06 e0 1a 	add  %i3, 0x1a, %o2                            
400189a4:	92 10 00 1a 	mov  %i2, %o1                                  
400189a8:	96 10 20 02 	mov  2, %o3                                    
400189ac:	98 07 bf fc 	add  %fp, -4, %o4                              
    sec = fat_cluster_num_to_sector_num(&fs_info->fat, 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));          
400189b0:	c2 37 bf fc 	sth  %g1, [ %fp + -4 ]                         
    ret1 = fat_sector_write(&fs_info->fat, sec,                       
400189b4:	7f ff ea e9 	call  40013558 <fat_sector_write>              
400189b8:	90 10 00 1d 	mov  %i5, %o0                                  
                            byte + MSDOS_FIRST_CLUSTER_LOW_OFFSET, 2, 
                            (char *)(&le_cl_low));                    
    le_cl_hi = CT_LE_W((uint16_t  )((new_cln & 0xFFFF0000) >> 16));   
400189bc:	b9 37 20 10 	srl  %i4, 0x10, %i4                            
    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_sector_write(&fs_info->fat, sec,                       
400189c0:	a0 10 00 08 	mov  %o0, %l0                                  
                                                                      
    rc = fat_sync(&fs_info->fat);                                     
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
    return rc;                                                        
}                                                                     
400189c4:	b2 0f 00 19 	and  %i4, %i1, %i1                             
    le_cl_low = CT_LE_W((uint16_t  )(new_cln & 0x0000FFFF));          
    ret1 = fat_sector_write(&fs_info->fat, sec,                       
                            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_sector_write(&fs_info->fat, sec,                       
400189c8:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
    le_cl_low = CT_LE_W((uint16_t  )(new_cln & 0x0000FFFF));          
    ret1 = fat_sector_write(&fs_info->fat, sec,                       
                            byte + MSDOS_FIRST_CLUSTER_LOW_OFFSET, 2, 
                            (char *)(&le_cl_low));                    
    le_cl_hi = CT_LE_W((uint16_t  )((new_cln & 0xFFFF0000) >> 16));   
400189cc:	b9 37 20 08 	srl  %i4, 8, %i4                               
400189d0:	b3 2e 60 08 	sll  %i1, 8, %i1                               
    ret2 = fat_sector_write(&fs_info->fat, sec,                       
400189d4:	92 10 00 1a 	mov  %i2, %o1                                  
                                                                      
    le_cl_low = CT_LE_W((uint16_t  )(new_cln & 0x0000FFFF));          
    ret1 = fat_sector_write(&fs_info->fat, sec,                       
                            byte + MSDOS_FIRST_CLUSTER_LOW_OFFSET, 2, 
                            (char *)(&le_cl_low));                    
    le_cl_hi = CT_LE_W((uint16_t  )((new_cln & 0xFFFF0000) >> 16));   
400189d8:	b8 16 40 1c 	or  %i1, %i4, %i4                              
    ret2 = fat_sector_write(&fs_info->fat, sec,                       
400189dc:	94 06 e0 14 	add  %i3, 0x14, %o2                            
                                                                      
    le_cl_low = CT_LE_W((uint16_t  )(new_cln & 0x0000FFFF));          
    ret1 = fat_sector_write(&fs_info->fat, sec,                       
                            byte + MSDOS_FIRST_CLUSTER_LOW_OFFSET, 2, 
                            (char *)(&le_cl_low));                    
    le_cl_hi = CT_LE_W((uint16_t  )((new_cln & 0xFFFF0000) >> 16));   
400189e0:	f8 37 bf fe 	sth  %i4, [ %fp + -2 ]                         
    ret2 = fat_sector_write(&fs_info->fat, sec,                       
400189e4:	96 10 20 02 	mov  2, %o3                                    
400189e8:	7f ff ea dc 	call  40013558 <fat_sector_write>              
400189ec:	98 07 bf fe 	add  %fp, -2, %o4                              
                            byte + MSDOS_FIRST_CLUSTER_HI_OFFSET, 2,  
                            (char *)(&le_cl_hi));                     
    if ( (ret1 < 0) || (ret2 < 0) )                                   
400189f0:	80 a2 20 00 	cmp  %o0, 0                                    
400189f4:	06 80 00 06 	bl  40018a0c <msdos_set_first_cluster_num+0xe4><== NEVER TAKEN
400189f8:	80 a4 20 00 	cmp  %l0, 0                                    
400189fc:	06 80 00 04 	bl  40018a0c <msdos_set_first_cluster_num+0xe4><== NEVER TAKEN
40018a00:	b0 10 20 00 	clr  %i0                                       
        return -1;                                                    
                                                                      
    return RC_OK;                                                     
}                                                                     
40018a04:	81 c7 e0 08 	ret                                            
40018a08:	81 e8 00 00 	restore                                        
40018a0c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40018a10:	91 e8 3f ff 	restore  %g0, -1, %o0                          <== NOT EXECUTED
                                                                      

4000d5c4 <msdos_set_sectors_per_cluster_from_request>: static int msdos_set_sectors_per_cluster_from_request( const msdos_format_request_param_t *rqdata, msdos_format_param_t *fmt_params ) {
4000d5c4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int      ret_val = -1;                                              
  uint32_t onebit;                                                    
                                                                      
  if ( rqdata != NULL && rqdata->sectors_per_cluster > 0 ) {          
4000d5c8:	80 a6 20 00 	cmp  %i0, 0                                    
4000d5cc:	22 80 00 07 	be,a   4000d5e8 <msdos_set_sectors_per_cluster_from_request+0x24>
4000d5d0:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
4000d5d4:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
4000d5d8:	80 a0 60 00 	cmp  %g1, 0                                    
4000d5dc:	22 80 00 03 	be,a   4000d5e8 <msdos_set_sectors_per_cluster_from_request+0x24>
4000d5e0:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
    fmt_params->sectors_per_cluster = rqdata->sectors_per_cluster;    
4000d5e4:	c2 26 60 0c 	st  %g1, [ %i1 + 0xc ]                         
                                                                      
static int                                                            
msdos_set_sectors_per_cluster_from_request(                           
  const msdos_format_request_param_t *rqdata,                         
  msdos_format_param_t               *fmt_params )                    
{                                                                     
4000d5e8:	b8 10 20 08 	mov  8, %i4                                    
4000d5ec:	ba 10 20 80 	mov  0x80, %i5                                 
   * 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 ) {                
4000d5f0:	80 a0 40 1d 	cmp  %g1, %i5                                  
4000d5f4:	2a 80 00 0b 	bcs,a   4000d620 <msdos_set_sectors_per_cluster_from_request+0x5c>
4000d5f8:	b8 87 3f ff 	addcc  %i4, -1, %i4                            
      fmt_params->sectors_per_cluster = onebit;                       
      if (   fmt_params->sectors_per_cluster                          
          <= 32768L / fmt_params->bytes_per_sector ) {                
4000d5fc:	d2 06 40 00 	ld  [ %i1 ], %o1                               
   * 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 ) {                
      fmt_params->sectors_per_cluster = onebit;                       
4000d600:	fa 26 60 0c 	st  %i5, [ %i1 + 0xc ]                         
      if (   fmt_params->sectors_per_cluster                          
          <= 32768L / fmt_params->bytes_per_sector ) {                
4000d604:	7f ff d4 1c 	call  40002674 <.udiv>                         
4000d608:	11 00 00 20 	sethi  %hi(0x8000), %o0                        
   * 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 ) {                
      fmt_params->sectors_per_cluster = onebit;                       
      if (   fmt_params->sectors_per_cluster                          
4000d60c:	80 a2 00 1d 	cmp  %o0, %i5                                  
4000d610:	0a 80 00 04 	bcs  4000d620 <msdos_set_sectors_per_cluster_from_request+0x5c><== NEVER TAKEN
4000d614:	b8 87 3f ff 	addcc  %i4, -1, %i4                            
          <= 32768L / fmt_params->bytes_per_sector ) {                
        /* value is small enough so this value is ok */               
        onebit = 1;                                                   
        ret_val = 0;                                                  
4000d618:	81 c7 e0 08 	ret                                            
4000d61c:	91 e8 20 00 	restore  %g0, 0, %o0                           
   * 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 ) {           
4000d620:	02 80 00 04 	be  4000d630 <msdos_set_sectors_per_cluster_from_request+0x6c><== NEVER TAKEN
4000d624:	bb 37 60 01 	srl  %i5, 1, %i5                               
4000d628:	10 bf ff f2 	b  4000d5f0 <msdos_set_sectors_per_cluster_from_request+0x2c>
4000d62c:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if (ret_val != 0) {                                                 
    errno = EINVAL;                                                   
4000d630:	40 00 3b 58 	call  4001c390 <__errno>                       <== NOT EXECUTED
4000d634:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4000d638:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
4000d63c:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  return ret_val;                                                     
}                                                                     
4000d640:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000d644:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40019fdc <msdos_sync>: return MSDOS_NAME_NOT_FOUND_ERR; } int msdos_sync(rtems_libio_t *iop) {
40019fdc:	9d e3 bf a0 	save  %sp, -96, %sp                            
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
40019fe0:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
40019fe4:	92 10 20 00 	clr  %o1                                       
int                                                                   
msdos_sync(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;     
40019fe8:	fa 00 60 08 	ld  [ %g1 + 8 ], %i5                           
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
40019fec:	94 10 20 00 	clr  %o2                                       
40019ff0:	7f ff bd 02 	call  400093f8 <rtems_semaphore_obtain>        
40019ff4:	d0 07 60 9c 	ld  [ %i5 + 0x9c ], %o0                        
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
40019ff8:	80 a2 20 00 	cmp  %o0, 0                                    
40019ffc:	12 80 00 09 	bne  4001a020 <msdos_sync+0x44>                <== NEVER TAKEN
4001a000:	01 00 00 00 	nop                                            
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    rc = fat_sync(&fs_info->fat);                                     
4001a004:	7f ff e8 48 	call  40014124 <fat_sync>                      
4001a008:	90 10 00 1d 	mov  %i5, %o0                                  
4001a00c:	b0 10 00 08 	mov  %o0, %i0                                  
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
4001a010:	7f ff bd 49 	call  40009534 <rtems_semaphore_release>       
4001a014:	d0 07 60 9c 	ld  [ %i5 + 0x9c ], %o0                        
    return rc;                                                        
}                                                                     
4001a018:	81 c7 e0 08 	ret                                            
4001a01c:	81 e8 00 00 	restore                                        
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
                                                                      
    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);                    
4001a020:	40 00 08 dc 	call  4001c390 <__errno>                       <== NOT EXECUTED
4001a024:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4001a028:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
4001a02c:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4001a030:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001a034:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4000e77c <msdos_unlock>: rtems_fatal_error_occurred(0xdeadbeef); } } void msdos_unlock(const rtems_filesystem_mount_table_entry_t *mt_entry) {
4000e77c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  msdos_fs_info_t *fs_info = mt_entry->fs_info;                       
  rtems_status_code sc = rtems_semaphore_release(fs_info->vol_sema);  
4000e780:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
4000e784:	7f ff eb 6c 	call  40009534 <rtems_semaphore_release>       
4000e788:	d0 00 60 9c 	ld  [ %g1 + 0x9c ], %o0                        
  if (sc != RTEMS_SUCCESSFUL) {                                       
4000e78c:	80 a2 20 00 	cmp  %o0, 0                                    
4000e790:	12 80 00 04 	bne  4000e7a0 <msdos_unlock+0x24>              <== NEVER TAKEN
4000e794:	11 37 ab 6f 	sethi  %hi(0xdeadbc00), %o0                    
4000e798:	81 c7 e0 08 	ret                                            
4000e79c:	81 e8 00 00 	restore                                        
    rtems_fatal_error_occurred(0xdeadbeef);                           
4000e7a0:	7f ff ec f7 	call  40009b7c <rtems_fatal_error_occurred>    <== NOT EXECUTED
4000e7a4:	90 12 22 ef 	or  %o0, 0x2ef, %o0                            <== NOT EXECUTED
                                                                      

40003b94 <newlib_delete_hook>: void newlib_delete_hook( rtems_tcb *current_task, rtems_tcb *deleted_task ) {
40003b94:	9d e3 bf a0 	save  %sp, -96, %sp                            
  /*                                                                  
   * The reentrancy structure was allocated by newlib using malloc()  
   */                                                                 
                                                                      
  if (current_task == deleted_task) {                                 
    ptr = _REENT;                                                     
40003b98:	03 10 00 79 	sethi  %hi(0x4001e400), %g1                    
                                                                      
  /*                                                                  
   * The reentrancy structure was allocated by newlib using malloc()  
   */                                                                 
                                                                      
  if (current_task == deleted_task) {                                 
40003b9c:	80 a6 00 19 	cmp  %i0, %i1                                  
40003ba0:	02 80 00 03 	be  40003bac <newlib_delete_hook+0x18>         
40003ba4:	fa 00 61 68 	ld  [ %g1 + 0x168 ], %i5                       
    ptr = _REENT;                                                     
  } else {                                                            
    ptr = deleted_task->libc_reent;                                   
40003ba8:	fa 06 61 48 	ld  [ %i1 + 0x148 ], %i5                       
  }                                                                   
                                                                      
  if (ptr && ptr != _global_impure_ptr) {                             
40003bac:	80 a7 60 00 	cmp  %i5, 0                                    
40003bb0:	02 80 00 0b 	be  40003bdc <newlib_delete_hook+0x48>         <== NEVER TAKEN
40003bb4:	03 10 00 76 	sethi  %hi(0x4001d800), %g1                    
40003bb8:	c2 00 60 b0 	ld  [ %g1 + 0xb0 ], %g1	! 4001d8b0 <_global_impure_ptr>
40003bbc:	80 a7 40 01 	cmp  %i5, %g1                                  
40003bc0:	02 80 00 07 	be  40003bdc <newlib_delete_hook+0x48>         
40003bc4:	13 10 00 0e 	sethi  %hi(0x40003800), %o1                    
    _reclaim_reent(ptr);                                              
*/                                                                    
    /*                                                                
     *  Just in case there are some buffers lying around.             
     */                                                               
    _fwalk(ptr, newlib_free_buffers);                                 
40003bc8:	90 10 00 1d 	mov  %i5, %o0                                  
40003bcc:	40 00 30 ea 	call  4000ff74 <_fwalk>                        
40003bd0:	92 12 61 84 	or  %o1, 0x184, %o1                            
#if REENT_MALLOCED                                                    
    free(ptr);                                                        
#else                                                                 
    _Workspace_Free(ptr);                                             
40003bd4:	40 00 1d 16 	call  4000b02c <_Workspace_Free>               
40003bd8:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  /*                                                                  
   * Require the switch back to another task to install its own       
   */                                                                 
                                                                      
  if ( current_task == deleted_task ) {                               
40003bdc:	80 a6 00 19 	cmp  %i0, %i1                                  
40003be0:	12 80 00 04 	bne  40003bf0 <newlib_delete_hook+0x5c>        
40003be4:	c0 26 61 48 	clr  [ %i1 + 0x148 ]                           
    _REENT = 0;                                                       
40003be8:	03 10 00 79 	sethi  %hi(0x4001e400), %g1                    
40003bec:	c0 20 61 68 	clr  [ %g1 + 0x168 ]	! 4001e568 <_impure_ptr>  
40003bf0:	81 c7 e0 08 	ret                                            
40003bf4:	81 e8 00 00 	restore                                        
                                                                      

40003984 <newlib_free_buffers>: * task. */ int newlib_free_buffers( FILE *fp ) {
40003984:	9d e3 bf a0 	save  %sp, -96, %sp                            
  switch ( fileno(fp) ) {                                             
40003988:	40 00 30 80 	call  4000fb88 <fileno>                        
4000398c:	90 10 00 18 	mov  %i0, %o0                                  
40003990:	80 a2 20 02 	cmp  %o0, 2                                    
40003994:	28 80 00 06 	bleu,a   400039ac <newlib_free_buffers+0x28>   <== ALWAYS TAKEN
40003998:	c2 16 20 0c 	lduh  [ %i0 + 0xc ], %g1                       
        fp->_flags &= ~__SMBF;                                        
        fp->_bf._base = fp->_p = (unsigned char *) NULL;              
      }                                                               
      break;                                                          
    default:                                                          
     fclose(fp);                                                      
4000399c:	40 00 2f bb 	call  4000f888 <fclose>                        <== NOT EXECUTED
400039a0:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
  }                                                                   
  return 0;                                                           
}                                                                     
400039a4:	81 c7 e0 08 	ret                                            
400039a8:	91 e8 20 00 	restore  %g0, 0, %o0                           
{                                                                     
  switch ( fileno(fp) ) {                                             
    case 0:                                                           
    case 1:                                                           
    case 2:                                                           
      if (fp->_flags & __SMBF) {                                      
400039ac:	80 88 60 80 	btst  0x80, %g1                                
400039b0:	02 bf ff fd 	be  400039a4 <newlib_free_buffers+0x20>        <== ALWAYS TAKEN
400039b4:	01 00 00 00 	nop                                            
        free( fp->_bf._base );                                        
400039b8:	7f ff fd 9c 	call  40003028 <free>                          <== NOT EXECUTED
400039bc:	d0 06 20 10 	ld  [ %i0 + 0x10 ], %o0                        <== NOT EXECUTED
        fp->_flags &= ~__SMBF;                                        
400039c0:	c2 16 20 0c 	lduh  [ %i0 + 0xc ], %g1                       <== NOT EXECUTED
        fp->_bf._base = fp->_p = (unsigned char *) NULL;              
400039c4:	c0 26 00 00 	clr  [ %i0 ]                                   <== NOT EXECUTED
    case 0:                                                           
    case 1:                                                           
    case 2:                                                           
      if (fp->_flags & __SMBF) {                                      
        free( fp->_bf._base );                                        
        fp->_flags &= ~__SMBF;                                        
400039c8:	82 08 7f 7f 	and  %g1, -129, %g1                            <== NOT EXECUTED
        fp->_bf._base = fp->_p = (unsigned char *) NULL;              
400039cc:	c0 26 20 10 	clr  [ %i0 + 0x10 ]                            <== NOT EXECUTED
    case 0:                                                           
    case 1:                                                           
    case 2:                                                           
      if (fp->_flags & __SMBF) {                                      
        free( fp->_bf._base );                                        
        fp->_flags &= ~__SMBF;                                        
400039d0:	c2 36 20 0c 	sth  %g1, [ %i0 + 0xc ]                        <== NOT EXECUTED
      break;                                                          
    default:                                                          
     fclose(fp);                                                      
  }                                                                   
  return 0;                                                           
}                                                                     
400039d4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400039d8:	91 e8 20 00 	restore  %g0, 0, %o0                           <== NOT EXECUTED
                                                                      

4000202c <notify>: } void notify (s) char *s; {
4000202c:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
    printf ("%s test appears to be inconsistent...\n", s);            
40002030:	11 10 00 9e 	sethi  %hi(0x40027800), %o0                    <== NOT EXECUTED
40002034:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
40002038:	90 12 21 b8 	or  %o0, 0x1b8, %o0                            <== NOT EXECUTED
4000203c:	40 00 6c 49 	call  4001d160 <printf>                        <== NOT EXECUTED
40002040:	31 10 00 9e 	sethi  %hi(0x40027800), %i0                    <== NOT EXECUTED
    printf ("   PLEASE NOTIFY KARPINKSI!\n");                         
40002044:	40 00 6c 88 	call  4001d264 <puts>                          <== NOT EXECUTED
40002048:	91 ee 21 e0 	restore  %i0, 0x1e0, %o0                       <== NOT EXECUTED
                                                                      

40006828 <null_op_fsmount_me>: rtems_filesystem_mount_table_entry_t *mt_entry, const void *data ) { return -1; }
40006828:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
4000682c:	90 10 3f ff 	mov  -1, %o0                                   <== NOT EXECUTED
                                                                      

40006838 <null_op_fsunmount_me>: static void null_op_fsunmount_me( rtems_filesystem_mount_table_entry_t *mt_entry ) {
40006838:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
                                                                      

40006800 <null_op_link>: const char *name, size_t namelen ) { return -1; }
40006800:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
40006804:	90 10 3f ff 	mov  -1, %o0                                   <== NOT EXECUTED
                                                                      

40006820 <null_op_mount>: static int null_op_mount( rtems_filesystem_mount_table_entry_t *mt_entry ) { return -1; }
40006820:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
40006824:	90 10 3f ff 	mov  -1, %o0                                   <== NOT EXECUTED
                                                                      

40006850 <null_op_readlink>: char *buf, size_t bufsize ) { return -1; }
40006850:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
40006854:	90 10 3f ff 	mov  -1, %o0                                   <== NOT EXECUTED
                                                                      

40006858 <null_op_rename>: const char *name, size_t namelen ) { return -1; }
40006858:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
4000685c:	90 10 3f ff 	mov  -1, %o0                                   <== NOT EXECUTED
                                                                      

400067f8 <null_op_rmnod>: const rtems_filesystem_location_info_t *parentloc, const rtems_filesystem_location_info_t *loc ) { return -1; }
400067f8:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
400067fc:	90 10 3f ff 	mov  -1, %o0                                   <== NOT EXECUTED
                                                                      

4000586c <oproc>: /* * Handle output processing */ static void oproc (unsigned char c, struct rtems_termios_tty *tty) {
4000586c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int  i;                                                             
                                                                      
  if (tty->termios.c_oflag & OPOST) {                                 
40005870:	c2 06 60 34 	ld  [ %i1 + 0x34 ], %g1                        
40005874:	80 88 60 01 	btst  1, %g1                                   
40005878:	02 80 00 21 	be  400058fc <oproc+0x90>                      <== NEVER TAKEN
4000587c:	f0 2f a0 44 	stb  %i0, [ %fp + 0x44 ]                       
    switch (c) {                                                      
40005880:	80 a6 20 09 	cmp  %i0, 9                                    
40005884:	22 80 00 3d 	be,a   40005978 <oproc+0x10c>                  
40005888:	c6 06 60 28 	ld  [ %i1 + 0x28 ], %g3                        
4000588c:	08 80 00 22 	bleu  40005914 <oproc+0xa8>                    <== NEVER TAKEN
40005890:	80 a6 20 08 	cmp  %i0, 8                                    
40005894:	80 a6 20 0a 	cmp  %i0, 0xa                                  
40005898:	02 80 00 2b 	be  40005944 <oproc+0xd8>                      
4000589c:	80 a6 20 0d 	cmp  %i0, 0xd                                  
400058a0:	02 80 00 45 	be  400059b4 <oproc+0x148>                     <== NEVER TAKEN
400058a4:	80 88 60 10 	btst  0x10, %g1                                
      if (tty->column > 0)                                            
        tty->column--;                                                
      break;                                                          
                                                                      
    default:                                                          
      if (tty->termios.c_oflag & OLCUC)                               
400058a8:	80 88 60 02 	btst  2, %g1                                   
        c = toupper(c);                                               
400058ac:	03 10 00 79 	sethi  %hi(0x4001e400), %g1                    
      if (tty->column > 0)                                            
        tty->column--;                                                
      break;                                                          
                                                                      
    default:                                                          
      if (tty->termios.c_oflag & OLCUC)                               
400058b0:	02 80 00 0b 	be  400058dc <oproc+0x70>                      <== ALWAYS TAKEN
400058b4:	c2 00 61 60 	ld  [ %g1 + 0x160 ], %g1	! 4001e560 <__ctype_ptr__>
        c = toupper(c);                                               
400058b8:	84 10 00 18 	mov  %i0, %g2                                  <== NOT EXECUTED
400058bc:	b0 00 40 18 	add  %g1, %i0, %i0                             <== NOT EXECUTED
400058c0:	c6 0e 20 01 	ldub  [ %i0 + 1 ], %g3                         <== NOT EXECUTED
400058c4:	86 08 e0 03 	and  %g3, 3, %g3                               <== NOT EXECUTED
400058c8:	80 a0 e0 02 	cmp  %g3, 2                                    <== NOT EXECUTED
400058cc:	22 80 00 02 	be,a   400058d4 <oproc+0x68>                   <== NOT EXECUTED
400058d0:	84 00 bf e0 	add  %g2, -32, %g2                             <== NOT EXECUTED
400058d4:	c4 2f a0 44 	stb  %g2, [ %fp + 0x44 ]                       <== NOT EXECUTED
400058d8:	b0 08 a0 ff 	and  %g2, 0xff, %i0                            <== NOT EXECUTED
      if (!iscntrl(c))                                                
400058dc:	b0 00 40 18 	add  %g1, %i0, %i0                             
400058e0:	c2 0e 20 01 	ldub  [ %i0 + 1 ], %g1                         
400058e4:	80 88 60 20 	btst  0x20, %g1                                
400058e8:	12 80 00 06 	bne  40005900 <oproc+0x94>                     <== NEVER TAKEN
400058ec:	90 07 a0 44 	add  %fp, 0x44, %o0                            
        tty->column++;                                                
400058f0:	c2 06 60 28 	ld  [ %i1 + 0x28 ], %g1                        
400058f4:	82 00 60 01 	inc  %g1                                       
400058f8:	c2 26 60 28 	st  %g1, [ %i1 + 0x28 ]                        
      break;                                                          
    }                                                                 
  }                                                                   
  rtems_termios_puts (&c, 1, tty);                                    
400058fc:	90 07 a0 44 	add  %fp, 0x44, %o0                            
40005900:	92 10 20 01 	mov  1, %o1                                    
40005904:	7f ff ff 8a 	call  4000572c <rtems_termios_puts>            
40005908:	94 10 00 19 	mov  %i1, %o2                                  
4000590c:	81 c7 e0 08 	ret                                            
40005910:	81 e8 00 00 	restore                                        
oproc (unsigned char c, struct rtems_termios_tty *tty)                
{                                                                     
  int  i;                                                             
                                                                      
  if (tty->termios.c_oflag & OPOST) {                                 
    switch (c) {                                                      
40005914:	12 bf ff e6 	bne  400058ac <oproc+0x40>                     <== NOT EXECUTED
40005918:	80 88 60 02 	btst  2, %g1                                   <== NOT EXECUTED
      }                                                               
      tty->column += i;                                               
      break;                                                          
                                                                      
    case '\b':                                                        
      if (tty->column > 0)                                            
4000591c:	c2 06 60 28 	ld  [ %i1 + 0x28 ], %g1                        <== NOT EXECUTED
40005920:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40005924:	04 bf ff f6 	ble  400058fc <oproc+0x90>                     <== NOT EXECUTED
40005928:	82 00 7f ff 	add  %g1, -1, %g1                              <== NOT EXECUTED
      if (!iscntrl(c))                                                
        tty->column++;                                                
      break;                                                          
    }                                                                 
  }                                                                   
  rtems_termios_puts (&c, 1, tty);                                    
4000592c:	90 07 a0 44 	add  %fp, 0x44, %o0                            <== NOT EXECUTED
      tty->column += i;                                               
      break;                                                          
                                                                      
    case '\b':                                                        
      if (tty->column > 0)                                            
        tty->column--;                                                
40005930:	c2 26 60 28 	st  %g1, [ %i1 + 0x28 ]                        <== NOT EXECUTED
      if (!iscntrl(c))                                                
        tty->column++;                                                
      break;                                                          
    }                                                                 
  }                                                                   
  rtems_termios_puts (&c, 1, tty);                                    
40005934:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
40005938:	7f ff ff 7d 	call  4000572c <rtems_termios_puts>            <== NOT EXECUTED
4000593c:	94 10 00 19 	mov  %i1, %o2                                  <== NOT EXECUTED
40005940:	30 80 00 1b 	b,a   400059ac <oproc+0x140>                   <== NOT EXECUTED
  int  i;                                                             
                                                                      
  if (tty->termios.c_oflag & OPOST) {                                 
    switch (c) {                                                      
    case '\n':                                                        
      if (tty->termios.c_oflag & ONLRET)                              
40005944:	80 88 60 20 	btst  0x20, %g1                                
40005948:	32 80 00 02 	bne,a   40005950 <oproc+0xe4>                  <== NEVER TAKEN
4000594c:	c0 26 60 28 	clr  [ %i1 + 0x28 ]                            <== NOT EXECUTED
        tty->column = 0;                                              
      if (tty->termios.c_oflag & ONLCR) {                             
40005950:	80 88 60 04 	btst  4, %g1                                   
40005954:	22 bf ff eb 	be,a   40005900 <oproc+0x94>                   <== NEVER TAKEN
40005958:	90 07 a0 44 	add  %fp, 0x44, %o0                            <== NOT EXECUTED
        rtems_termios_puts ("\r", 1, tty);                            
4000595c:	92 10 20 01 	mov  1, %o1                                    
40005960:	11 10 00 73 	sethi  %hi(0x4001cc00), %o0                    
40005964:	94 10 00 19 	mov  %i1, %o2                                  
40005968:	7f ff ff 71 	call  4000572c <rtems_termios_puts>            
4000596c:	90 12 23 40 	or  %o0, 0x340, %o0                            
        tty->column = 0;                                              
40005970:	10 bf ff e3 	b  400058fc <oproc+0x90>                       
40005974:	c0 26 60 28 	clr  [ %i1 + 0x28 ]                            
      }                                                               
      tty->column = 0;                                                
      break;                                                          
                                                                      
    case '\t':                                                        
      i = 8 - (tty->column & 7);                                      
40005978:	92 10 20 08 	mov  8, %o1                                    
4000597c:	88 08 e0 07 	and  %g3, 7, %g4                               
40005980:	92 22 40 04 	sub  %o1, %g4, %o1                             
      if ((tty->termios.c_oflag & TABDLY) == XTABS) {                 
        tty->column += i;                                             
40005984:	86 00 c0 09 	add  %g3, %o1, %g3                             
      tty->column = 0;                                                
      break;                                                          
                                                                      
    case '\t':                                                        
      i = 8 - (tty->column & 7);                                      
      if ((tty->termios.c_oflag & TABDLY) == XTABS) {                 
40005988:	05 00 00 06 	sethi  %hi(0x1800), %g2                        
4000598c:	82 08 40 02 	and  %g1, %g2, %g1                             
40005990:	80 a0 40 02 	cmp  %g1, %g2                                  
40005994:	12 bf ff da 	bne  400058fc <oproc+0x90>                     <== NEVER TAKEN
40005998:	c6 26 60 28 	st  %g3, [ %i1 + 0x28 ]                        
        tty->column += i;                                             
        rtems_termios_puts ( "        ",  i, tty);                    
4000599c:	11 10 00 73 	sethi  %hi(0x4001cc00), %o0                    
400059a0:	94 10 00 19 	mov  %i1, %o2                                  
400059a4:	7f ff ff 62 	call  4000572c <rtems_termios_puts>            
400059a8:	90 12 23 48 	or  %o0, 0x348, %o0                            
        return;                                                       
400059ac:	81 c7 e0 08 	ret                                            
400059b0:	81 e8 00 00 	restore                                        
        tty->column = 0;                                              
      }                                                               
      break;                                                          
                                                                      
    case '\r':                                                        
      if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))       
400059b4:	02 80 00 06 	be  400059cc <oproc+0x160>                     <== NOT EXECUTED
400059b8:	80 88 60 08 	btst  8, %g1                                   <== NOT EXECUTED
400059bc:	c4 06 60 28 	ld  [ %i1 + 0x28 ], %g2                        <== NOT EXECUTED
400059c0:	80 a0 a0 00 	cmp  %g2, 0                                    <== NOT EXECUTED
400059c4:	02 bf ff d2 	be  4000590c <oproc+0xa0>                      <== NOT EXECUTED
400059c8:	80 88 60 08 	btst  8, %g1                                   <== NOT EXECUTED
        return;                                                       
      if (tty->termios.c_oflag & OCRNL) {                             
400059cc:	22 bf ff cc 	be,a   400058fc <oproc+0x90>                   <== NOT EXECUTED
400059d0:	c0 26 60 28 	clr  [ %i1 + 0x28 ]                            <== NOT EXECUTED
        c = '\n';                                                     
400059d4:	84 10 20 0a 	mov  0xa, %g2                                  <== NOT EXECUTED
        if (tty->termios.c_oflag & ONLRET)                            
400059d8:	80 88 60 20 	btst  0x20, %g1                                <== NOT EXECUTED
400059dc:	02 bf ff c8 	be  400058fc <oproc+0x90>                      <== NOT EXECUTED
400059e0:	c4 2f a0 44 	stb  %g2, [ %fp + 0x44 ]                       <== NOT EXECUTED
          tty->column = 0;                                            
        break;                                                        
      }                                                               
      tty->column = 0;                                                
      break;                                                          
400059e4:	10 bf ff c6 	b  400058fc <oproc+0x90>                       <== NOT EXECUTED
400059e8:	c0 26 60 28 	clr  [ %i1 + 0x28 ]                            <== NOT EXECUTED
                                                                      

40004464 <partition_free>: * RETURNS: * N/A */ static void partition_free(rtems_part_desc_t *part_desc) {
40004464:	9d e3 bf a0 	save  %sp, -96, %sp                            
    int part_num;                                                     
                                                                      
    if (part_desc == NULL)                                            
40004468:	80 a6 20 00 	cmp  %i0, 0                                    
4000446c:	02 80 00 11 	be  400044b0 <partition_free+0x4c>             
40004470:	01 00 00 00 	nop                                            
 *      true if partition type is extended, false otherwise           
 */                                                                   
static bool                                                           
is_extended(uint8_t type)                                             
{                                                                     
    return ((type == EXTENDED_PARTITION) || (type == LINUX_EXTENDED));
40004474:	c2 0e 20 01 	ldub  [ %i0 + 1 ], %g1                         
    int part_num;                                                     
                                                                      
    if (part_desc == NULL)                                            
        return;                                                       
                                                                      
    if (is_extended(part_desc->sys_type))                             
40004478:	82 08 60 7f 	and  %g1, 0x7f, %g1                            
4000447c:	80 a0 60 05 	cmp  %g1, 5                                    
40004480:	12 80 00 0a 	bne  400044a8 <partition_free+0x44>            <== ALWAYS TAKEN
40004484:	01 00 00 00 	nop                                            
40004488:	ba 10 20 00 	clr  %i5	! 0 <PROM_START>                      <== NOT EXECUTED
 *                                                                    
 * RETURNS:                                                           
 *      N/A                                                           
 */                                                                   
static void                                                           
partition_free(rtems_part_desc_t *part_desc)                          
4000448c:	82 06 00 1d 	add  %i0, %i5, %g1                             <== NOT EXECUTED
    {                                                                 
        for (part_num = 0;                                            
             part_num < RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER; 
             part_num++)                                              
        {                                                             
            partition_free(part_desc->sub_part[part_num]);            
40004490:	d0 00 60 18 	ld  [ %g1 + 0x18 ], %o0                        <== NOT EXECUTED
40004494:	7f ff ff f4 	call  40004464 <partition_free>                <== NOT EXECUTED
40004498:	ba 07 60 04 	add  %i5, 4, %i5                               <== NOT EXECUTED
    if (part_desc == NULL)                                            
        return;                                                       
                                                                      
    if (is_extended(part_desc->sys_type))                             
    {                                                                 
        for (part_num = 0;                                            
4000449c:	80 a7 60 10 	cmp  %i5, 0x10                                 <== NOT EXECUTED
400044a0:	12 bf ff fc 	bne  40004490 <partition_free+0x2c>            <== NOT EXECUTED
400044a4:	82 06 00 1d 	add  %i0, %i5, %g1                             <== NOT EXECUTED
        {                                                             
            partition_free(part_desc->sub_part[part_num]);            
        }                                                             
    }                                                                 
                                                                      
    free(part_desc);                                                  
400044a8:	40 00 03 b4 	call  40005378 <free>                          
400044ac:	81 e8 00 00 	restore                                        
400044b0:	81 c7 e0 08 	ret                                            
400044b4:	81 e8 00 00 	restore                                        
                                                                      

400047fc <partition_table_get>: * RTEMS_SUCCESSFUL if success, * RTEMS_INTERNAL_ERROR otherwise */ static rtems_status_code partition_table_get(const char *dev_name, rtems_disk_desc_t *disk_desc) {
400047fc:	9d e3 bf 50 	save  %sp, -176, %sp                           
    struct stat         dev_stat;                                     
    rtems_status_code   rc;                                           
    int                 fd;                                           
                                                                      
    fd = open(dev_name, O_RDONLY);                                    
40004800:	92 10 20 00 	clr  %o1                                       
40004804:	90 10 00 18 	mov  %i0, %o0                                  
40004808:	40 00 06 8e 	call  40006240 <open>                          
4000480c:	b8 10 00 18 	mov  %i0, %i4                                  
    if (fd < 0)                                                       
    {                                                                 
        return RTEMS_INTERNAL_ERROR;                                  
40004810:	b0 10 20 19 	mov  0x19, %i0                                 
    struct stat         dev_stat;                                     
    rtems_status_code   rc;                                           
    int                 fd;                                           
                                                                      
    fd = open(dev_name, O_RDONLY);                                    
    if (fd < 0)                                                       
40004814:	80 a2 20 00 	cmp  %o0, 0                                    
40004818:	06 80 00 09 	bl  4000483c <partition_table_get+0x40>        <== NEVER TAKEN
4000481c:	ba 10 00 08 	mov  %o0, %i5                                  
    {                                                                 
        return RTEMS_INTERNAL_ERROR;                                  
    }                                                                 
                                                                      
    rc = fstat(fd, &dev_stat);                                        
40004820:	40 00 03 00 	call  40005420 <fstat>                         
40004824:	92 07 bf b8 	add  %fp, -72, %o1                             
    if (rc != RTEMS_SUCCESSFUL)                                       
40004828:	80 a2 20 00 	cmp  %o0, 0                                    
4000482c:	02 80 00 06 	be  40004844 <partition_table_get+0x48>        <== ALWAYS TAKEN
40004830:	90 06 60 08 	add  %i1, 8, %o0                               
    disk_desc->sector_size = (dev_stat.st_blksize) ? dev_stat.st_blksize :
                                              RTEMS_IDE_SECTOR_SIZE;  
                                                                      
    rc = read_mbr(fd, disk_desc);                                     
                                                                      
    close(fd);                                                        
40004834:	40 00 02 af 	call  400052f0 <close>                         
40004838:	90 10 00 1d 	mov  %i5, %o0                                  
4000483c:	81 c7 e0 08 	ret                                            
40004840:	81 e8 00 00 	restore                                        
    {                                                                 
        close(fd);                                                    
        return RTEMS_INTERNAL_ERROR;                                  
    }                                                                 
                                                                      
    strncpy (disk_desc->dev_name, dev_name, 15);                      
40004844:	92 10 00 1c 	mov  %i4, %o1                                  
40004848:	40 00 47 b9 	call  4001672c <strncpy>                       
4000484c:	94 10 20 0f 	mov  0xf, %o2                                  
    disk_desc->dev = dev_stat.st_rdev;                                
40004850:	c4 1f bf d0 	ldd  [ %fp + -48 ], %g2                        
    disk_desc->sector_size = (dev_stat.st_blksize) ? dev_stat.st_blksize :
40004854:	c8 07 bf f8 	ld  [ %fp + -8 ], %g4                          
        close(fd);                                                    
        return RTEMS_INTERNAL_ERROR;                                  
    }                                                                 
                                                                      
    strncpy (disk_desc->dev_name, dev_name, 15);                      
    disk_desc->dev = dev_stat.st_rdev;                                
40004858:	c4 3e 40 00 	std  %g2, [ %i1 ]                              
    disk_desc->sector_size = (dev_stat.st_blksize) ? dev_stat.st_blksize :
4000485c:	80 a1 20 00 	cmp  %g4, 0                                    
40004860:	02 80 00 03 	be  4000486c <partition_table_get+0x70>        <== ALWAYS TAKEN
40004864:	82 10 22 00 	mov  0x200, %g1                                
40004868:	82 10 00 04 	mov  %g4, %g1                                  <== NOT EXECUTED
4000486c:	c2 26 60 18 	st  %g1, [ %i1 + 0x18 ]                        
 */                                                                   
static rtems_status_code                                              
read_mbr(int fd, rtems_disk_desc_t *disk_desc)                        
{                                                                     
    int                  part_num;                                    
    rtems_sector_data_t *sector = NULL;                               
40004870:	c0 27 bf b0 	clr  [ %fp + -80 ]                             
    {                                                                 
        return RTEMS_INTERNAL_ERROR;                                  
    }                                                                 
                                                                      
    off = sector_num * RTEMS_IDE_SECTOR_SIZE;                         
    new_off = lseek(fd, off, SEEK_SET);                               
40004874:	90 10 00 1d 	mov  %i5, %o0                                  
40004878:	92 10 20 00 	clr  %o1                                       
4000487c:	94 10 20 00 	clr  %o2                                       
40004880:	96 10 20 00 	clr  %o3                                       
40004884:	40 00 03 e1 	call  40005808 <lseek>                         
40004888:	b0 10 20 1b 	mov  0x1b, %i0                                 
    if (new_off != off) {                                             
4000488c:	80 92 00 09 	orcc  %o0, %o1, %g0                            
40004890:	02 80 00 09 	be  400048b4 <partition_table_get+0xb8>        <== ALWAYS TAKEN
40004894:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
    /* get MBR sector */                                              
    rc = get_sector(fd, 0, §or);                                  
    if (rc != RTEMS_SUCCESSFUL)                                       
    {                                                                 
        if (sector)                                                   
40004898:	d0 07 bf b0 	ld  [ %fp + -80 ], %o0                         <== NOT EXECUTED
4000489c:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
400048a0:	02 bf ff e5 	be  40004834 <partition_table_get+0x38>        <== NOT EXECUTED
400048a4:	01 00 00 00 	nop                                            <== NOT EXECUTED
         part_num++)                                                  
    {                                                                 
        rc = data_to_part_desc(data, &part_desc);                     
        if (rc != RTEMS_SUCCESSFUL)                                   
        {                                                             
            free(sector);                                             
400048a8:	40 00 02 b4 	call  40005378 <free>                          <== NOT EXECUTED
400048ac:	01 00 00 00 	nop                                            <== NOT EXECUTED
400048b0:	30 bf ff e1 	b,a   40004834 <partition_table_get+0x38>      <== NOT EXECUTED
400048b4:	92 10 20 00 	clr  %o1	! 0 <PROM_START>                      
400048b8:	7f ff ff 0b 	call  400044e4 <get_sector.part.0>             
400048bc:	94 07 bf b0 	add  %fp, -80, %o2                             
    uint8_t             *data;                                        
    rtems_status_code    rc;                                          
                                                                      
    /* get MBR sector */                                              
    rc = get_sector(fd, 0, §or);                                  
    if (rc != RTEMS_SUCCESSFUL)                                       
400048c0:	b0 92 20 00 	orcc  %o0, 0, %i0                              
400048c4:	12 bf ff f5 	bne  40004898 <partition_table_get+0x9c>       <== NEVER TAKEN
400048c8:	d0 07 bf b0 	ld  [ %fp + -80 ], %o0                         
static bool                                                           
msdos_signature_check (rtems_sector_data_t *sector)                   
{                                                                     
    uint8_t *p = sector->data + RTEMS_IDE_PARTITION_MSDOS_SIGNATURE_OFFSET;
                                                                      
    return ((p[0] == RTEMS_IDE_PARTITION_MSDOS_SIGNATURE_DATA1) &&    
400048cc:	c2 0a 22 02 	ldub  [ %o0 + 0x202 ], %g1                     
400048d0:	80 a0 60 55 	cmp  %g1, 0x55                                 
400048d4:	22 80 00 05 	be,a   400048e8 <partition_table_get+0xec>     <== ALWAYS TAKEN
400048d8:	c2 0a 22 03 	ldub  [ %o0 + 0x203 ], %g1                     
    }                                                                 
                                                                      
    /* check if the partition table structure is MS-DOS style */      
    if (!msdos_signature_check(sector))                               
    {                                                                 
        free(sector);                                                 
400048dc:	40 00 02 a7 	call  40005378 <free>                          <== NOT EXECUTED
400048e0:	b0 10 20 19 	mov  0x19, %i0                                 <== NOT EXECUTED
400048e4:	30 bf ff d4 	b,a   40004834 <partition_table_get+0x38>      <== NOT EXECUTED
static bool                                                           
msdos_signature_check (rtems_sector_data_t *sector)                   
{                                                                     
    uint8_t *p = sector->data + RTEMS_IDE_PARTITION_MSDOS_SIGNATURE_OFFSET;
                                                                      
    return ((p[0] == RTEMS_IDE_PARTITION_MSDOS_SIGNATURE_DATA1) &&    
400048e8:	80 a0 60 aa 	cmp  %g1, 0xaa                                 
400048ec:	12 bf ff fc 	bne  400048dc <partition_table_get+0xe0>       <== NEVER TAKEN
400048f0:	b4 02 21 c2 	add  %o0, 0x1c2, %i2                           
400048f4:	b6 10 00 19 	mov  %i1, %i3                                  
        return RTEMS_INTERNAL_ERROR;                                  
    }                                                                 
                                                                      
    /* read and process 4 primary partition descriptors */            
                                                                      
    data = sector->data + RTEMS_IDE_PARTITION_TABLE_OFFSET;           
400048f8:	a0 10 00 19 	mov  %i1, %l0                                  
400048fc:	b8 10 20 01 	mov  1, %i4                                    
40004900:	90 10 00 1a 	mov  %i2, %o0                                  
40004904:	7f ff ff 0f 	call  40004540 <data_to_part_desc.part.1>      
40004908:	92 07 bf b4 	add  %fp, -76, %o1                             
    for (part_num = 0;                                                
         part_num < RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;     
         part_num++)                                                  
    {                                                                 
        rc = data_to_part_desc(data, &part_desc);                     
        if (rc != RTEMS_SUCCESSFUL)                                   
4000490c:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40004910:	12 80 00 2b 	bne  400049bc <partition_table_get+0x1c0>      <== NEVER TAKEN
40004914:	c2 07 bf b4 	ld  [ %fp + -76 ], %g1                         
        {                                                             
            free(sector);                                             
            return rc;                                                
        }                                                             
                                                                      
        if (part_desc != NULL)                                        
40004918:	80 a0 60 00 	cmp  %g1, 0                                    
4000491c:	22 80 00 0a 	be,a   40004944 <partition_table_get+0x148>    <== NEVER TAKEN
40004920:	c0 24 20 28 	clr  [ %l0 + 0x28 ]                            <== NOT EXECUTED
        {                                                             
            part_desc->log_id = part_num + 1;                         
            part_desc->disk_desc = disk_desc;                         
            part_desc->end = part_desc->start + part_desc->size - 1;  
40004924:	c6 00 60 04 	ld  [ %g1 + 4 ], %g3                           
40004928:	c4 00 60 08 	ld  [ %g1 + 8 ], %g2                           
            return rc;                                                
        }                                                             
                                                                      
        if (part_desc != NULL)                                        
        {                                                             
            part_desc->log_id = part_num + 1;                         
4000492c:	f8 28 60 02 	stb  %i4, [ %g1 + 2 ]                          
            part_desc->disk_desc = disk_desc;                         
40004930:	f2 20 60 10 	st  %i1, [ %g1 + 0x10 ]                        
            part_desc->end = part_desc->start + part_desc->size - 1;  
40004934:	84 00 c0 02 	add  %g3, %g2, %g2                             
40004938:	84 00 bf ff 	add  %g2, -1, %g2                              
4000493c:	c4 20 60 0c 	st  %g2, [ %g1 + 0xc ]                         
            disk_desc->partitions[part_num] = part_desc;              
40004940:	c2 24 20 28 	st  %g1, [ %l0 + 0x28 ]                        
40004944:	b8 07 20 01 	inc  %i4                                       
        else                                                          
        {                                                             
            disk_desc->partitions[part_num] = NULL;                   
        }                                                             
                                                                      
        data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;                  
40004948:	b4 06 a0 10 	add  %i2, 0x10, %i2                            
                                                                      
    /* read and process 4 primary partition descriptors */            
                                                                      
    data = sector->data + RTEMS_IDE_PARTITION_TABLE_OFFSET;           
                                                                      
    for (part_num = 0;                                                
4000494c:	82 0f 20 ff 	and  %i4, 0xff, %g1                            
40004950:	80 a0 60 05 	cmp  %g1, 5                                    
40004954:	12 bf ff eb 	bne  40004900 <partition_table_get+0x104>      
40004958:	a0 04 20 04 	add  %l0, 4, %l0                               
        }                                                             
                                                                      
        data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;                  
    }                                                                 
                                                                      
    free(sector);                                                     
4000495c:	d0 07 bf b0 	ld  [ %fp + -80 ], %o0                         
40004960:	40 00 02 86 	call  40005378 <free>                          
40004964:	b8 10 20 04 	mov  4, %i4                                    
                                                                      
    disk_desc->last_log_id = RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
40004968:	82 10 20 04 	mov  4, %g1                                    
4000496c:	c2 26 60 24 	st  %g1, [ %i1 + 0x24 ]                        
       but we are to process each primary partition */                
    for (part_num = 0;                                                
         part_num < RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;     
         part_num++)                                                  
    {                                                                 
        part_desc = disk_desc->partitions[part_num];                  
40004970:	d4 06 e0 28 	ld  [ %i3 + 0x28 ], %o2                        
        if (part_desc != NULL && is_extended(part_desc->sys_type))    
40004974:	80 a2 a0 00 	cmp  %o2, 0                                    
40004978:	02 80 00 07 	be  40004994 <partition_table_get+0x198>       <== NEVER TAKEN
4000497c:	d4 27 bf b4 	st  %o2, [ %fp + -76 ]                         
 *      true if partition type is extended, false otherwise           
 */                                                                   
static bool                                                           
is_extended(uint8_t type)                                             
{                                                                     
    return ((type == EXTENDED_PARTITION) || (type == LINUX_EXTENDED));
40004980:	c2 0a a0 01 	ldub  [ %o2 + 1 ], %g1                         
    for (part_num = 0;                                                
         part_num < RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;     
         part_num++)                                                  
    {                                                                 
        part_desc = disk_desc->partitions[part_num];                  
        if (part_desc != NULL && is_extended(part_desc->sys_type))    
40004984:	82 08 60 7f 	and  %g1, 0x7f, %g1                            
40004988:	80 a0 60 05 	cmp  %g1, 5                                    
4000498c:	22 80 00 06 	be,a   400049a4 <partition_table_get+0x1a8>    
40004990:	d2 02 a0 04 	ld  [ %o2 + 4 ], %o1                           
                                                                      
    disk_desc->last_log_id = RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
                                                                      
    /* There cannot be more than one extended partition,              
       but we are to process each primary partition */                
    for (part_num = 0;                                                
40004994:	b8 87 3f ff 	addcc  %i4, -1, %i4                            
40004998:	12 bf ff f6 	bne  40004970 <partition_table_get+0x174>      
4000499c:	b6 06 e0 04 	add  %i3, 4, %i3                               
400049a0:	30 bf ff a5 	b,a   40004834 <partition_table_get+0x38>      
         part_num++)                                                  
    {                                                                 
        part_desc = disk_desc->partitions[part_num];                  
        if (part_desc != NULL && is_extended(part_desc->sys_type))    
        {                                                             
            read_extended_partition(fd, part_desc->start, part_desc); 
400049a4:	7f ff ff 34 	call  40004674 <read_extended_partition>       
400049a8:	90 10 00 1d 	mov  %i5, %o0                                  
            free(part_desc);                                          
400049ac:	40 00 02 73 	call  40005378 <free>                          
400049b0:	d0 07 bf b4 	ld  [ %fp + -76 ], %o0                         
            disk_desc->partitions[part_num] = NULL;                   
400049b4:	10 bf ff f8 	b  40004994 <partition_table_get+0x198>        
400049b8:	c0 26 e0 28 	clr  [ %i3 + 0x28 ]                            
         part_num++)                                                  
    {                                                                 
        rc = data_to_part_desc(data, &part_desc);                     
        if (rc != RTEMS_SUCCESSFUL)                                   
        {                                                             
            free(sector);                                             
400049bc:	40 00 02 6f 	call  40005378 <free>                          <== NOT EXECUTED
400049c0:	d0 07 bf b0 	ld  [ %fp + -80 ], %o0                         <== NOT EXECUTED
400049c4:	30 bf ff 9c 	b,a   40004834 <partition_table_get+0x38>      <== NOT EXECUTED
                                                                      

40004548 <pathconf>: */ long pathconf( const char *path, int name ) {
40004548:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int status;                                                         
  int fd;                                                             
                                                                      
  fd = open( path, O_RDONLY );                                        
4000454c:	92 10 20 00 	clr  %o1                                       
40004550:	7f ff ff 6d 	call  40004304 <open>                          
40004554:	90 10 00 18 	mov  %i0, %o0                                  
  if ( fd == -1 )                                                     
40004558:	80 a2 3f ff 	cmp  %o0, -1                                   
4000455c:	02 80 00 09 	be  40004580 <pathconf+0x38>                   <== ALWAYS TAKEN
40004560:	ba 10 00 08 	mov  %o0, %i5                                  
    return -1;                                                        
                                                                      
  status = fpathconf( fd, name );                                     
40004564:	40 00 15 3b 	call  40009a50 <fpathconf>                     <== NOT EXECUTED
40004568:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
4000456c:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
                                                                      
  (void) close( fd );                                                 
40004570:	40 00 15 0a 	call  40009998 <close>                         <== NOT EXECUTED
40004574:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
                                                                      
  return status;                                                      
40004578:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000457c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
}                                                                     
40004580:	81 c7 e0 08 	ret                                            
40004584:	91 e8 3f ff 	restore  %g0, -1, %o0                          
                                                                      

4000cd60 <pipe_create>: static uint16_t rtems_pipe_no = 0; int pipe_create( int filsdes[2] ) {
4000cd60:	9d e3 bf 90 	save  %sp, -112, %sp                           
  rtems_libio_t *iop;                                                 
  int err = 0;                                                        
                                                                      
  if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)          
4000cd64:	92 10 21 ff 	mov  0x1ff, %o1                                
4000cd68:	11 10 00 7b 	sethi  %hi(0x4001ec00), %o0                    
4000cd6c:	40 00 05 93 	call  4000e3b8 <rtems_mkdir>                   
4000cd70:	90 12 20 c8 	or  %o0, 0xc8, %o0	! 4001ecc8 <_CPU_Trap_slot_template+0x10>
4000cd74:	80 a2 20 00 	cmp  %o0, 0                                    
4000cd78:	12 80 00 49 	bne  4000ce9c <pipe_create+0x13c>              
4000cd7c:	03 10 00 7f 	sethi  %hi(0x4001fc00), %g1                    
    return -1;                                                        
                                                                      
  /* /tmp/.fifoXXXX */                                                
  char fifopath[15];                                                  
  memcpy(fifopath, "/tmp/.fifo", 10);                                 
  sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);                   
4000cd80:	d4 10 62 58 	lduh  [ %g1 + 0x258 ], %o2	! 4001fe58 <rtems_pipe_no>
  if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)          
    return -1;                                                        
                                                                      
  /* /tmp/.fifoXXXX */                                                
  char fifopath[15];                                                  
  memcpy(fifopath, "/tmp/.fifo", 10);                                 
4000cd84:	05 0b dd 1b 	sethi  %hi(0x2f746c00), %g2                    
  sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);                   
4000cd88:	88 02 a0 01 	add  %o2, 1, %g4                               
  if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)          
    return -1;                                                        
                                                                      
  /* /tmp/.fifoXXXX */                                                
  char fifopath[15];                                                  
  memcpy(fifopath, "/tmp/.fifo", 10);                                 
4000cd8c:	84 10 a1 70 	or  %g2, 0x170, %g2                            
  sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);                   
4000cd90:	c8 30 62 58 	sth  %g4, [ %g1 + 0x258 ]                      
  if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)          
    return -1;                                                        
                                                                      
  /* /tmp/.fifoXXXX */                                                
  char fifopath[15];                                                  
  memcpy(fifopath, "/tmp/.fifo", 10);                                 
4000cd94:	07 0b cb 99 	sethi  %hi(0x2f2e6400), %g3                    
4000cd98:	03 00 00 19 	sethi  %hi(0x6400), %g1                        
4000cd9c:	86 10 e2 69 	or  %g3, 0x269, %g3                            
4000cda0:	82 10 62 6f 	or  %g1, 0x26f, %g1                            
4000cda4:	c4 3f bf f0 	std  %g2, [ %fp + -16 ]                        
4000cda8:	c2 37 bf f8 	sth  %g1, [ %fp + -8 ]                         
  sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);                   
4000cdac:	95 2a a0 10 	sll  %o2, 0x10, %o2                            
4000cdb0:	90 07 bf fa 	add  %fp, -6, %o0                              
4000cdb4:	95 32 a0 10 	srl  %o2, 0x10, %o2                            
4000cdb8:	13 10 00 7b 	sethi  %hi(0x4001ec00), %o1                    
4000cdbc:	40 00 12 f8 	call  4001199c <sprintf>                       
4000cdc0:	92 12 60 d0 	or  %o1, 0xd0, %o1	! 4001ecd0 <_CPU_Trap_slot_template+0x18>
                                                                      
  /* Try creating FIFO file until find an available file name */      
  while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {                    
4000cdc4:	90 07 bf f0 	add  %fp, -16, %o0                             
4000cdc8:	40 00 04 c8 	call  4000e0e8 <mkfifo>                        
4000cdcc:	92 10 21 80 	mov  0x180, %o1                                
4000cdd0:	80 a2 20 00 	cmp  %o0, 0                                    
4000cdd4:	12 80 00 39 	bne  4000ceb8 <pipe_create+0x158>              <== NEVER TAKEN
4000cdd8:	90 07 bf f0 	add  %fp, -16, %o0                             
    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);                 
4000cddc:	7f ff dd d0 	call  4000451c <open>                          
4000cde0:	13 00 00 10 	sethi  %hi(0x4000), %o1                        
  if (filsdes[0] < 0) {                                               
4000cde4:	80 a2 20 00 	cmp  %o0, 0                                    
4000cde8:	06 80 00 20 	bl  4000ce68 <pipe_create+0x108>               
4000cdec:	d0 26 00 00 	st  %o0, [ %i0 ]                               
     the file node will be deleted after it is closed by all. */      
    unlink(fifopath);                                                 
  }                                                                   
  else {                                                              
  /* Reset open file to blocking mode */                              
    iop = rtems_libio_iop(filsdes[0]);                                
4000cdf0:	03 10 00 7d 	sethi  %hi(0x4001f400), %g1                    
4000cdf4:	c4 00 62 54 	ld  [ %g1 + 0x254 ], %g2	! 4001f654 <rtems_libio_number_iops>
4000cdf8:	80 a2 00 02 	cmp  %o0, %g2                                  
4000cdfc:	0a 80 00 14 	bcs  4000ce4c <pipe_create+0xec>               <== ALWAYS TAKEN
4000ce00:	82 10 20 00 	clr  %g1                                       
    iop->flags &= ~LIBIO_FLAGS_NO_DELAY;                              
4000ce04:	c4 00 60 10 	ld  [ %g1 + 0x10 ], %g2                        
                                                                      
    filsdes[1] = open(fifopath, O_WRONLY);                            
4000ce08:	90 07 bf f0 	add  %fp, -16, %o0                             
    unlink(fifopath);                                                 
  }                                                                   
  else {                                                              
  /* Reset open file to blocking mode */                              
    iop = rtems_libio_iop(filsdes[0]);                                
    iop->flags &= ~LIBIO_FLAGS_NO_DELAY;                              
4000ce0c:	84 08 bf fe 	and  %g2, -2, %g2                              
                                                                      
    filsdes[1] = open(fifopath, O_WRONLY);                            
4000ce10:	92 10 20 01 	mov  1, %o1                                    
4000ce14:	7f ff dd c2 	call  4000451c <open>                          
4000ce18:	c4 20 60 10 	st  %g2, [ %g1 + 0x10 ]                        
4000ce1c:	d0 26 20 04 	st  %o0, [ %i0 + 4 ]                           
                                                                      
    if (filsdes[1] < 0) {                                             
4000ce20:	80 a2 20 00 	cmp  %o0, 0                                    
4000ce24:	06 80 00 18 	bl  4000ce84 <pipe_create+0x124>               
4000ce28:	ba 10 20 00 	clr  %i5                                       
    err = errno;                                                      
    close(filsdes[0]);                                                
    }                                                                 
  unlink(fifopath);                                                   
4000ce2c:	7f ff e9 c4 	call  4000753c <unlink>                        
4000ce30:	90 07 bf f0 	add  %fp, -16, %o0                             
  }                                                                   
  if(err != 0)                                                        
    rtems_set_errno_and_return_minus_one(err);                        
  return 0;                                                           
4000ce34:	b0 10 20 00 	clr  %i0                                       
    err = errno;                                                      
    close(filsdes[0]);                                                
    }                                                                 
  unlink(fifopath);                                                   
  }                                                                   
  if(err != 0)                                                        
4000ce38:	80 a7 60 00 	cmp  %i5, 0                                    
4000ce3c:	12 80 00 1a 	bne  4000cea4 <pipe_create+0x144>              
4000ce40:	01 00 00 00 	nop                                            
    rtems_set_errno_and_return_minus_one(err);                        
  return 0;                                                           
}                                                                     
4000ce44:	81 c7 e0 08 	ret                                            
4000ce48:	81 e8 00 00 	restore                                        
     the file node will be deleted after it is closed by all. */      
    unlink(fifopath);                                                 
  }                                                                   
  else {                                                              
  /* Reset open file to blocking mode */                              
    iop = rtems_libio_iop(filsdes[0]);                                
4000ce4c:	03 10 00 7f 	sethi  %hi(0x4001fc00), %g1                    
4000ce50:	c2 00 63 d4 	ld  [ %g1 + 0x3d4 ], %g1	! 4001ffd4 <rtems_libio_iops>
4000ce54:	85 2a 20 03 	sll  %o0, 3, %g2                               
4000ce58:	91 2a 20 06 	sll  %o0, 6, %o0                               
4000ce5c:	90 22 00 02 	sub  %o0, %g2, %o0                             
4000ce60:	10 bf ff e9 	b  4000ce04 <pipe_create+0xa4>                 
4000ce64:	82 00 40 08 	add  %g1, %o0, %g1                             
  }                                                                   
                                                                      
  /* Non-blocking open to avoid waiting for writers */                
  filsdes[0] = open(fifopath, O_RDONLY | O_NONBLOCK);                 
  if (filsdes[0] < 0) {                                               
    err = errno;                                                      
4000ce68:	40 00 0f fb 	call  40010e54 <__errno>                       
4000ce6c:	b0 10 20 00 	clr  %i0                                       
4000ce70:	fa 02 00 00 	ld  [ %o0 ], %i5                               
    /* 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);                                                 
4000ce74:	7f ff e9 b2 	call  4000753c <unlink>                        
4000ce78:	90 07 bf f0 	add  %fp, -16, %o0                             
    err = errno;                                                      
    close(filsdes[0]);                                                
    }                                                                 
  unlink(fifopath);                                                   
  }                                                                   
  if(err != 0)                                                        
4000ce7c:	10 bf ff f0 	b  4000ce3c <pipe_create+0xdc>                 
4000ce80:	80 a7 60 00 	cmp  %i5, 0                                    
    iop->flags &= ~LIBIO_FLAGS_NO_DELAY;                              
                                                                      
    filsdes[1] = open(fifopath, O_WRONLY);                            
                                                                      
    if (filsdes[1] < 0) {                                             
    err = errno;                                                      
4000ce84:	40 00 0f f4 	call  40010e54 <__errno>                       
4000ce88:	01 00 00 00 	nop                                            
4000ce8c:	fa 02 00 00 	ld  [ %o0 ], %i5                               
    close(filsdes[0]);                                                
4000ce90:	7f ff da 41 	call  40003794 <close>                         
4000ce94:	d0 06 00 00 	ld  [ %i0 ], %o0                               
4000ce98:	30 bf ff e5 	b,a   4000ce2c <pipe_create+0xcc>              
  unlink(fifopath);                                                   
  }                                                                   
  if(err != 0)                                                        
    rtems_set_errno_and_return_minus_one(err);                        
  return 0;                                                           
}                                                                     
4000ce9c:	81 c7 e0 08 	ret                                            
4000cea0:	91 e8 3f ff 	restore  %g0, -1, %o0                          
    close(filsdes[0]);                                                
    }                                                                 
  unlink(fifopath);                                                   
  }                                                                   
  if(err != 0)                                                        
    rtems_set_errno_and_return_minus_one(err);                        
4000cea4:	40 00 0f ec 	call  40010e54 <__errno>                       
4000cea8:	b0 10 3f ff 	mov  -1, %i0                                   
4000ceac:	fa 22 00 00 	st  %i5, [ %o0 ]                               
4000ceb0:	81 c7 e0 08 	ret                                            
4000ceb4:	81 e8 00 00 	restore                                        
  memcpy(fifopath, "/tmp/.fifo", 10);                                 
  sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);                   
                                                                      
  /* Try creating FIFO file until find an available file name */      
  while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {                    
    if (errno != EEXIST){                                             
4000ceb8:	40 00 0f e7 	call  40010e54 <__errno>                       <== NOT EXECUTED
4000cebc:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4000cec0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000cec4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4000e378 <pipe_ioctl>: pipe_control_t *pipe, ioctl_command_t cmd, void *buffer, rtems_libio_t *iop ) {
4000e378:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if (cmd == FIONREAD) {                                              
4000e37c:	03 10 01 19 	sethi  %hi(0x40046400), %g1                    
4000e380:	82 10 62 7f 	or  %g1, 0x27f, %g1	! 4004667f <__end+0x21faf> 
4000e384:	80 a6 40 01 	cmp  %i1, %g1                                  
4000e388:	12 80 00 11 	bne  4000e3cc <pipe_ioctl+0x54>                
4000e38c:	80 a6 a0 00 	cmp  %i2, 0                                    
    if (buffer == NULL)                                               
4000e390:	02 80 00 13 	be  4000e3dc <pipe_ioctl+0x64>                 
4000e394:	92 10 20 00 	clr  %o1                                       
      return -EFAULT;                                                 
                                                                      
    if (! PIPE_LOCK(pipe))                                            
4000e398:	d0 06 20 28 	ld  [ %i0 + 0x28 ], %o0                        
4000e39c:	7f ff e9 ba 	call  40008a84 <rtems_semaphore_obtain>        
4000e3a0:	94 10 20 00 	clr  %o2                                       
4000e3a4:	80 a2 20 00 	cmp  %o0, 0                                    
4000e3a8:	12 80 00 0b 	bne  4000e3d4 <pipe_ioctl+0x5c>                <== NEVER TAKEN
4000e3ac:	01 00 00 00 	nop                                            
      return -EINTR;                                                  
                                                                      
    /* Return length of pipe */                                       
    *(unsigned int *)buffer = pipe->Length;                           
4000e3b0:	c2 06 20 0c 	ld  [ %i0 + 0xc ], %g1                         
    PIPE_UNLOCK(pipe);                                                
4000e3b4:	d0 06 20 28 	ld  [ %i0 + 0x28 ], %o0                        
                                                                      
    if (! PIPE_LOCK(pipe))                                            
      return -EINTR;                                                  
                                                                      
    /* Return length of pipe */                                       
    *(unsigned int *)buffer = pipe->Length;                           
4000e3b8:	c2 26 80 00 	st  %g1, [ %i2 ]                               
    PIPE_UNLOCK(pipe);                                                
4000e3bc:	7f ff ea 01 	call  40008bc0 <rtems_semaphore_release>       
4000e3c0:	b0 10 20 00 	clr  %i0                                       
    return 0;                                                         
4000e3c4:	81 c7 e0 08 	ret                                            
4000e3c8:	81 e8 00 00 	restore                                        
  }                                                                   
                                                                      
  return -EINVAL;                                                     
4000e3cc:	81 c7 e0 08 	ret                                            
4000e3d0:	91 e8 3f ea 	restore  %g0, -22, %o0                         
}                                                                     
4000e3d4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000e3d8:	91 e8 3f fc 	restore  %g0, -4, %o0                          <== NOT EXECUTED
  rtems_libio_t   *iop                                                
)                                                                     
{                                                                     
  if (cmd == FIONREAD) {                                              
    if (buffer == NULL)                                               
      return -EFAULT;                                                 
4000e3dc:	81 c7 e0 08 	ret                                            
4000e3e0:	91 e8 3f f2 	restore  %g0, -14, %o0                         
                                                                      

4000dfb4 <pipe_read>: pipe_control_t *pipe, void *buffer, size_t count, rtems_libio_t *iop ) {
4000dfb4:	9d e3 bf 98 	save  %sp, -104, %sp                           
  int chunk, chunk1, read = 0, ret = 0;                               
                                                                      
  if (! PIPE_LOCK(pipe))                                              
4000dfb8:	d0 06 20 28 	ld  [ %i0 + 0x28 ], %o0                        
4000dfbc:	92 10 20 00 	clr  %o1                                       
4000dfc0:	94 10 20 00 	clr  %o2                                       
4000dfc4:	7f ff ea b0 	call  40008a84 <rtems_semaphore_obtain>        
4000dfc8:	ba 10 00 18 	mov  %i0, %i5                                  
4000dfcc:	80 a2 20 00 	cmp  %o0, 0                                    
4000dfd0:	12 80 00 60 	bne  4000e150 <pipe_read+0x19c>                <== NEVER TAKEN
4000dfd4:	a0 10 20 00 	clr  %l0                                       
    return -EINTR;                                                    
                                                                      
  while (read < count) {                                              
4000dfd8:	80 a6 a0 00 	cmp  %i2, 0                                    
4000dfdc:	02 80 00 53 	be  4000e128 <pipe_read+0x174>                 <== NEVER TAKEN
4000dfe0:	b0 10 20 00 	clr  %i0                                       
    while (PIPE_EMPTY(pipe)) {                                        
4000dfe4:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
4000dfe8:	80 a0 60 00 	cmp  %g1, 0                                    
4000dfec:	12 80 00 29 	bne  4000e090 <pipe_read+0xdc>                 
4000dff0:	84 26 80 10 	sub  %i2, %l0, %g2                             
      /* Not an error */                                              
      if (pipe->Writers == 0)                                         
4000dff4:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
4000dff8:	80 a0 60 00 	cmp  %g1, 0                                    
4000dffc:	02 80 00 1c 	be  4000e06c <pipe_read+0xb8>                  
4000e000:	b8 10 20 00 	clr  %i4                                       
        goto out_locked;                                              
                                                                      
      if (LIBIO_NODELAY(iop)) {                                       
4000e004:	c2 06 e0 10 	ld  [ %i3 + 0x10 ], %g1                        
4000e008:	80 88 60 01 	btst  1, %g1                                   
4000e00c:	32 80 00 18 	bne,a   4000e06c <pipe_read+0xb8>              
4000e010:	b8 10 3f f5 	mov  -11, %i4                                  
        ret = -EAGAIN;                                                
        goto out_locked;                                              
      }                                                               
                                                                      
      /* Wait until pipe is no more empty or no writer exists */      
      pipe->waitingReaders ++;                                        
4000e014:	c2 07 60 18 	ld  [ %i5 + 0x18 ], %g1                        
      PIPE_UNLOCK(pipe);                                              
4000e018:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
        ret = -EAGAIN;                                                
        goto out_locked;                                              
      }                                                               
                                                                      
      /* Wait until pipe is no more empty or no writer exists */      
      pipe->waitingReaders ++;                                        
4000e01c:	82 00 60 01 	inc  %g1                                       
      PIPE_UNLOCK(pipe);                                              
4000e020:	7f ff ea e8 	call  40008bc0 <rtems_semaphore_release>       
4000e024:	c2 27 60 18 	st  %g1, [ %i5 + 0x18 ]                        
      if (! PIPE_READWAIT(pipe))                                      
4000e028:	d0 07 60 2c 	ld  [ %i5 + 0x2c ], %o0                        
4000e02c:	40 00 05 98 	call  4000f68c <rtems_barrier_wait>            
4000e030:	92 10 20 00 	clr  %o1                                       
4000e034:	80 a0 00 08 	cmp  %g0, %o0                                  
        ret = -EINTR;                                                 
      if (! PIPE_LOCK(pipe)) {                                        
4000e038:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
      }                                                               
                                                                      
      /* Wait until pipe is no more empty or no writer exists */      
      pipe->waitingReaders ++;                                        
      PIPE_UNLOCK(pipe);                                              
      if (! PIPE_READWAIT(pipe))                                      
4000e03c:	b8 60 20 00 	subx  %g0, 0, %i4                              
        ret = -EINTR;                                                 
      if (! PIPE_LOCK(pipe)) {                                        
4000e040:	92 10 20 00 	clr  %o1                                       
4000e044:	94 10 20 00 	clr  %o2                                       
4000e048:	7f ff ea 8f 	call  40008a84 <rtems_semaphore_obtain>        
4000e04c:	b8 0f 3f fc 	and  %i4, -4, %i4                              
4000e050:	80 a2 20 00 	cmp  %o0, 0                                    
4000e054:	12 80 00 37 	bne  4000e130 <pipe_read+0x17c>                <== NEVER TAKEN
4000e058:	80 a7 20 00 	cmp  %i4, 0                                    
        /* WARN waitingReaders not restored! */                       
        ret = -EINTR;                                                 
        goto out_nolock;                                              
      }                                                               
      pipe->waitingReaders --;                                        
4000e05c:	c2 07 60 18 	ld  [ %i5 + 0x18 ], %g1                        
4000e060:	82 00 7f ff 	add  %g1, -1, %g1                              
      if (ret != 0)                                                   
4000e064:	02 bf ff e0 	be  4000dfe4 <pipe_read+0x30>                  <== ALWAYS TAKEN
4000e068:	c2 27 60 18 	st  %g1, [ %i5 + 0x18 ]                        
      PIPE_WAKEUPWRITERS(pipe);                                       
    read += chunk;                                                    
  }                                                                   
                                                                      
out_locked:                                                           
  PIPE_UNLOCK(pipe);                                                  
4000e06c:	7f ff ea d5 	call  40008bc0 <rtems_semaphore_release>       
4000e070:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
                                                                      
out_nolock:                                                           
  if (read > 0)                                                       
4000e074:	80 a6 20 00 	cmp  %i0, 0                                    
4000e078:	04 80 00 04 	ble  4000e088 <pipe_read+0xd4>                 
4000e07c:	01 00 00 00 	nop                                            
    return read;                                                      
  return ret;                                                         
}                                                                     
4000e080:	81 c7 e0 08 	ret                                            
4000e084:	81 e8 00 00 	restore                                        
4000e088:	81 c7 e0 08 	ret                                            
4000e08c:	91 e8 00 1c 	restore  %g0, %i4, %o0                         
      if (ret != 0)                                                   
        goto out_locked;                                              
    }                                                                 
                                                                      
    /* Read chunk bytes */                                            
    chunk = MIN(count - read,  pipe->Length);                         
4000e090:	80 a0 40 02 	cmp  %g1, %g2                                  
4000e094:	08 80 00 03 	bleu  4000e0a0 <pipe_read+0xec>                
4000e098:	b8 10 00 01 	mov  %g1, %i4                                  
4000e09c:	b8 10 00 02 	mov  %g2, %i4                                  
    chunk1 = pipe->Size - pipe->Start;                                
4000e0a0:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
4000e0a4:	e2 07 60 04 	ld  [ %i5 + 4 ], %l1                           
4000e0a8:	a2 24 40 01 	sub  %l1, %g1, %l1                             
    if (chunk > chunk1) {                                             
4000e0ac:	80 a7 00 11 	cmp  %i4, %l1                                  
4000e0b0:	04 80 00 22 	ble  4000e138 <pipe_read+0x184>                
4000e0b4:	d2 07 40 00 	ld  [ %i5 ], %o1                               
      memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);      
4000e0b8:	94 10 00 11 	mov  %l1, %o2                                  
4000e0bc:	92 02 40 01 	add  %o1, %g1, %o1                             
4000e0c0:	40 00 11 51 	call  40012604 <memcpy>                        
4000e0c4:	90 06 40 10 	add  %i1, %l0, %o0                             
      memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);   
4000e0c8:	d2 07 40 00 	ld  [ %i5 ], %o1                               
4000e0cc:	90 04 00 11 	add  %l0, %l1, %o0                             
4000e0d0:	94 27 00 11 	sub  %i4, %l1, %o2                             
4000e0d4:	40 00 11 4c 	call  40012604 <memcpy>                        
4000e0d8:	90 06 40 08 	add  %i1, %o0, %o0                             
    }                                                                 
    else                                                              
      memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);       
                                                                      
    pipe->Start += chunk;                                             
4000e0dc:	d0 07 60 08 	ld  [ %i5 + 8 ], %o0                           
    pipe->Start %= pipe->Size;                                        
4000e0e0:	d2 07 60 04 	ld  [ %i5 + 4 ], %o1                           
4000e0e4:	40 00 40 4f 	call  4001e220 <.urem>                         
4000e0e8:	90 07 00 08 	add  %i4, %o0, %o0                             
    pipe->Length -= chunk;                                            
4000e0ec:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
    }                                                                 
    else                                                              
      memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);       
                                                                      
    pipe->Start += chunk;                                             
    pipe->Start %= pipe->Size;                                        
4000e0f0:	d0 27 60 08 	st  %o0, [ %i5 + 8 ]                           
    pipe->Length -= chunk;                                            
4000e0f4:	82 20 40 1c 	sub  %g1, %i4, %g1                             
    /* For buffering optimization */                                  
    if (PIPE_EMPTY(pipe))                                             
4000e0f8:	80 a0 60 00 	cmp  %g1, 0                                    
4000e0fc:	12 80 00 03 	bne  4000e108 <pipe_read+0x154>                
4000e100:	c2 27 60 0c 	st  %g1, [ %i5 + 0xc ]                         
      pipe->Start = 0;                                                
4000e104:	c0 27 60 08 	clr  [ %i5 + 8 ]                               
                                                                      
    if (pipe->waitingWriters > 0)                                     
4000e108:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
4000e10c:	80 a0 60 00 	cmp  %g1, 0                                    
4000e110:	32 80 00 12 	bne,a   4000e158 <pipe_read+0x1a4>             
4000e114:	d0 07 60 30 	ld  [ %i5 + 0x30 ], %o0                        
      PIPE_WAKEUPWRITERS(pipe);                                       
    read += chunk;                                                    
4000e118:	b0 06 00 1c 	add  %i0, %i4, %i0                             
  int chunk, chunk1, read = 0, ret = 0;                               
                                                                      
  if (! PIPE_LOCK(pipe))                                              
    return -EINTR;                                                    
                                                                      
  while (read < count) {                                              
4000e11c:	80 a6 00 1a 	cmp  %i0, %i2                                  
4000e120:	0a bf ff b1 	bcs  4000dfe4 <pipe_read+0x30>                 <== NEVER TAKEN
4000e124:	a0 10 00 18 	mov  %i0, %l0                                  
    while (PIPE_EMPTY(pipe)) {                                        
      /* Not an error */                                              
      if (pipe->Writers == 0)                                         
4000e128:	10 bf ff d1 	b  4000e06c <pipe_read+0xb8>                   
4000e12c:	b8 10 20 00 	clr  %i4                                       
      PIPE_UNLOCK(pipe);                                              
      if (! PIPE_READWAIT(pipe))                                      
        ret = -EINTR;                                                 
      if (! PIPE_LOCK(pipe)) {                                        
        /* WARN waitingReaders not restored! */                       
        ret = -EINTR;                                                 
4000e130:	10 bf ff d1 	b  4000e074 <pipe_read+0xc0>                   <== NOT EXECUTED
4000e134:	b8 10 3f fc 	mov  -4, %i4                                   <== NOT EXECUTED
    if (chunk > chunk1) {                                             
      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);       
4000e138:	90 06 40 10 	add  %i1, %l0, %o0                             
4000e13c:	92 02 40 01 	add  %o1, %g1, %o1                             
4000e140:	40 00 11 31 	call  40012604 <memcpy>                        
4000e144:	94 10 00 1c 	mov  %i4, %o2                                  
                                                                      
    pipe->Start += chunk;                                             
4000e148:	10 bf ff e6 	b  4000e0e0 <pipe_read+0x12c>                  
4000e14c:	d0 07 60 08 	ld  [ %i5 + 8 ], %o0                           
)                                                                     
{                                                                     
  int chunk, chunk1, read = 0, ret = 0;                               
                                                                      
  if (! PIPE_LOCK(pipe))                                              
    return -EINTR;                                                    
4000e150:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000e154:	91 e8 3f fc 	restore  %g0, -4, %o0                          <== NOT EXECUTED
    /* For buffering optimization */                                  
    if (PIPE_EMPTY(pipe))                                             
      pipe->Start = 0;                                                
                                                                      
    if (pipe->waitingWriters > 0)                                     
      PIPE_WAKEUPWRITERS(pipe);                                       
4000e158:	40 00 05 35 	call  4000f62c <rtems_barrier_release>         
4000e15c:	92 07 bf fc 	add  %fp, -4, %o1                              
    read += chunk;                                                    
4000e160:	10 bf ff ef 	b  4000e11c <pipe_read+0x168>                  
4000e164:	b0 06 00 1c 	add  %i0, %i4, %i0                             
                                                                      

4000da04 <pipe_release>: void pipe_release( pipe_control_t **pipep, rtems_libio_t *iop ) {
4000da04:	9d e3 bf 98 	save  %sp, -104, %sp                           
    /* WARN pipe not released! */                                     
    if (!PIPE_LOCK(pipe))                                             
      rtems_fatal_error_occurred(0xdeadbeef);                         
  #endif                                                              
                                                                      
  mode = LIBIO_ACCMODE(iop);                                          
4000da08:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1                        
void pipe_release(                                                    
  pipe_control_t **pipep,                                             
  rtems_libio_t *iop                                                  
)                                                                     
{                                                                     
  pipe_control_t *pipe = *pipep;                                      
4000da0c:	fa 06 00 00 	ld  [ %i0 ], %i5                               
    if (!PIPE_LOCK(pipe))                                             
      rtems_fatal_error_occurred(0xdeadbeef);                         
  #endif                                                              
                                                                      
  mode = LIBIO_ACCMODE(iop);                                          
  if (mode & LIBIO_FLAGS_READ)                                        
4000da10:	80 88 60 02 	btst  2, %g1                                   
4000da14:	02 80 00 05 	be  4000da28 <pipe_release+0x24>               
4000da18:	b8 08 60 06 	and  %g1, 6, %i4                               
     pipe->Readers --;                                                
4000da1c:	c4 07 60 10 	ld  [ %i5 + 0x10 ], %g2                        
4000da20:	84 00 bf ff 	add  %g2, -1, %g2                              
4000da24:	c4 27 60 10 	st  %g2, [ %i5 + 0x10 ]                        
  if (mode & LIBIO_FLAGS_WRITE)                                       
4000da28:	80 88 60 04 	btst  4, %g1                                   
4000da2c:	02 80 00 05 	be  4000da40 <pipe_release+0x3c>               
4000da30:	01 00 00 00 	nop                                            
     pipe->Writers --;                                                
4000da34:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
4000da38:	82 00 7f ff 	add  %g1, -1, %g1                              
4000da3c:	c2 27 60 14 	st  %g1, [ %i5 + 0x14 ]                        
                                                                      
  PIPE_UNLOCK(pipe);                                                  
4000da40:	7f ff ec 60 	call  40008bc0 <rtems_semaphore_release>       
4000da44:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
                                                                      
  if (pipe->Readers == 0 && pipe->Writers == 0) {                     
4000da48:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
4000da4c:	80 a0 60 00 	cmp  %g1, 0                                    
4000da50:	02 80 00 0f 	be  4000da8c <pipe_release+0x88>               
4000da54:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
    *pipep = NULL;                                                    
  }                                                                   
  else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)           
    /* Notify waiting Writers that all their partners left */         
    PIPE_WAKEUPWRITERS(pipe);                                         
  else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)            
4000da58:	80 a0 60 00 	cmp  %g1, 0                                    
4000da5c:	12 80 00 07 	bne  4000da78 <pipe_release+0x74>              <== NEVER TAKEN
4000da60:	80 a7 20 02 	cmp  %i4, 2                                    
4000da64:	02 80 00 06 	be  4000da7c <pipe_release+0x78>               <== NEVER TAKEN
4000da68:	03 10 00 8e 	sethi  %hi(0x40023800), %g1                    
    PIPE_WAKEUPREADERS(pipe);                                         
4000da6c:	d0 07 60 2c 	ld  [ %i5 + 0x2c ], %o0                        
4000da70:	40 00 06 ef 	call  4000f62c <rtems_barrier_release>         
4000da74:	92 07 bf fc 	add  %fp, -4, %o1                              
#ifdef RTEMS_DEBUG                                                    
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  sc =                                                                
#endif                                                                
   rtems_semaphore_release(pipe_semaphore);                           
4000da78:	03 10 00 8e 	sethi  %hi(0x40023800), %g1                    
4000da7c:	7f ff ec 51 	call  40008bc0 <rtems_semaphore_release>       
4000da80:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0	! 40023898 <pipe_semaphore>
4000da84:	81 c7 e0 08 	ret                                            
4000da88:	81 e8 00 00 	restore                                        
  if (mode & LIBIO_FLAGS_WRITE)                                       
     pipe->Writers --;                                                
                                                                      
  PIPE_UNLOCK(pipe);                                                  
                                                                      
  if (pipe->Readers == 0 && pipe->Writers == 0) {                     
4000da8c:	80 a0 60 00 	cmp  %g1, 0                                    
4000da90:	02 80 00 0c 	be  4000dac0 <pipe_release+0xbc>               
4000da94:	80 a7 20 04 	cmp  %i4, 4                                    
      delfile = TRUE;                                                 
#endif                                                                
    pipe_free(pipe);                                                  
    *pipep = NULL;                                                    
  }                                                                   
  else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)           
4000da98:	02 bf ff f9 	be  4000da7c <pipe_release+0x78>               <== NEVER TAKEN
4000da9c:	03 10 00 8e 	sethi  %hi(0x40023800), %g1                    
    /* Notify waiting Writers that all their partners left */         
    PIPE_WAKEUPWRITERS(pipe);                                         
4000daa0:	d0 07 60 30 	ld  [ %i5 + 0x30 ], %o0                        
4000daa4:	40 00 06 e2 	call  4000f62c <rtems_barrier_release>         
4000daa8:	92 07 bf fc 	add  %fp, -4, %o1                              
#ifdef RTEMS_DEBUG                                                    
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  sc =                                                                
#endif                                                                
   rtems_semaphore_release(pipe_semaphore);                           
4000daac:	03 10 00 8e 	sethi  %hi(0x40023800), %g1                    
4000dab0:	7f ff ec 44 	call  40008bc0 <rtems_semaphore_release>       
4000dab4:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0	! 40023898 <pipe_semaphore>
4000dab8:	81 c7 e0 08 	ret                                            
4000dabc:	81 e8 00 00 	restore                                        
/* Called with pipe_semaphore held. */                                
static inline void pipe_free(                                         
  pipe_control_t *pipe                                                
)                                                                     
{                                                                     
  rtems_barrier_delete(pipe->readBarrier);                            
4000dac0:	40 00 06 b2 	call  4000f588 <rtems_barrier_delete>          
4000dac4:	d0 07 60 2c 	ld  [ %i5 + 0x2c ], %o0                        
  rtems_barrier_delete(pipe->writeBarrier);                           
4000dac8:	40 00 06 b0 	call  4000f588 <rtems_barrier_delete>          
4000dacc:	d0 07 60 30 	ld  [ %i5 + 0x30 ], %o0                        
  rtems_semaphore_delete(pipe->Semaphore);                            
4000dad0:	7f ff eb b6 	call  400089a8 <rtems_semaphore_delete>        
4000dad4:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
  free(pipe->Buffer);                                                 
4000dad8:	7f ff d9 8a 	call  40004100 <free>                          
4000dadc:	d0 07 40 00 	ld  [ %i5 ], %o0                               
  free(pipe);                                                         
4000dae0:	7f ff d9 88 	call  40004100 <free>                          
4000dae4:	90 10 00 1d 	mov  %i5, %o0                                  
#ifdef RTEMS_DEBUG                                                    
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  sc =                                                                
#endif                                                                
   rtems_semaphore_release(pipe_semaphore);                           
4000dae8:	03 10 00 8e 	sethi  %hi(0x40023800), %g1                    
4000daec:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0	! 40023898 <pipe_semaphore>
4000daf0:	7f ff ec 34 	call  40008bc0 <rtems_semaphore_release>       
4000daf4:	c0 26 00 00 	clr  [ %i0 ]                                   
4000daf8:	81 c7 e0 08 	ret                                            
4000dafc:	81 e8 00 00 	restore                                        
                                                                      

4000e168 <pipe_write>: pipe_control_t *pipe, const void *buffer, size_t count, rtems_libio_t *iop ) {
4000e168:	9d e3 bf 98 	save  %sp, -104, %sp                           
4000e16c:	ba 10 00 18 	mov  %i0, %i5                                  
  int chunk, chunk1, written = 0, ret = 0;                            
                                                                      
  /* Write nothing */                                                 
  if (count == 0)                                                     
4000e170:	80 a6 a0 00 	cmp  %i2, 0                                    
4000e174:	12 80 00 04 	bne  4000e184 <pipe_write+0x1c>                <== ALWAYS TAKEN
4000e178:	b0 10 20 00 	clr  %i0                                       
#endif                                                                
                                                                      
  if (written > 0)                                                    
    return written;                                                   
  return ret;                                                         
}                                                                     
4000e17c:	81 c7 e0 08 	ret                                            
4000e180:	81 e8 00 00 	restore                                        
                                                                      
  /* Write nothing */                                                 
  if (count == 0)                                                     
    return 0;                                                         
                                                                      
  if (! PIPE_LOCK(pipe))                                              
4000e184:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
4000e188:	92 10 20 00 	clr  %o1                                       
4000e18c:	7f ff ea 3e 	call  40008a84 <rtems_semaphore_obtain>        
4000e190:	94 10 20 00 	clr  %o2                                       
4000e194:	80 a2 20 00 	cmp  %o0, 0                                    
4000e198:	12 80 00 6c 	bne  4000e348 <pipe_write+0x1e0>               <== NEVER TAKEN
4000e19c:	01 00 00 00 	nop                                            
    return -EINTR;                                                    
                                                                      
  if (pipe->Readers == 0) {                                           
4000e1a0:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
4000e1a4:	80 a0 60 00 	cmp  %g1, 0                                    
4000e1a8:	22 80 00 54 	be,a   4000e2f8 <pipe_write+0x190>             
4000e1ac:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
    ret = -EPIPE;                                                     
    goto out_locked;                                                  
  }                                                                   
                                                                      
  /* Write of PIPE_BUF bytes or less shall not be interleaved */      
  chunk = count <= pipe->Size ? count : 1;                            
4000e1b0:	f8 07 60 04 	ld  [ %i5 + 4 ], %i4                           
4000e1b4:	80 a6 80 1c 	cmp  %i2, %i4                                  
4000e1b8:	08 80 00 5b 	bleu  4000e324 <pipe_write+0x1bc>              <== ALWAYS TAKEN
4000e1bc:	a0 10 20 01 	mov  1, %l0                                    
4000e1c0:	a2 10 20 00 	clr  %l1                                       
4000e1c4:	b0 10 20 00 	clr  %i0                                       
                                                                      
  while (written < count) {                                           
    while (PIPE_SPACE(pipe) < chunk) {                                
4000e1c8:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
4000e1cc:	84 27 00 01 	sub  %i4, %g1, %g2                             
4000e1d0:	80 a0 80 10 	cmp  %g2, %l0                                  
4000e1d4:	1a 80 00 27 	bcc  4000e270 <pipe_write+0x108>               
4000e1d8:	86 26 80 11 	sub  %i2, %l1, %g3                             
      if (LIBIO_NODELAY(iop)) {                                       
4000e1dc:	c2 06 e0 10 	ld  [ %i3 + 0x10 ], %g1                        
4000e1e0:	80 88 60 01 	btst  1, %g1                                   
4000e1e4:	32 80 00 53 	bne,a   4000e330 <pipe_write+0x1c8>            
4000e1e8:	b8 10 3f f5 	mov  -11, %i4                                  
        ret = -EAGAIN;                                                
        goto out_locked;                                              
      }                                                               
                                                                      
      /* Wait until there is chunk bytes space or no reader exists */ 
      pipe->waitingWriters ++;                                        
4000e1ec:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
      PIPE_UNLOCK(pipe);                                              
4000e1f0:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
        ret = -EAGAIN;                                                
        goto out_locked;                                              
      }                                                               
                                                                      
      /* Wait until there is chunk bytes space or no reader exists */ 
      pipe->waitingWriters ++;                                        
4000e1f4:	82 00 60 01 	inc  %g1                                       
      PIPE_UNLOCK(pipe);                                              
4000e1f8:	7f ff ea 72 	call  40008bc0 <rtems_semaphore_release>       
4000e1fc:	c2 27 60 1c 	st  %g1, [ %i5 + 0x1c ]                        
      if (! PIPE_WRITEWAIT(pipe))                                     
4000e200:	d0 07 60 30 	ld  [ %i5 + 0x30 ], %o0                        
4000e204:	40 00 05 22 	call  4000f68c <rtems_barrier_wait>            
4000e208:	92 10 20 00 	clr  %o1                                       
4000e20c:	80 a0 00 08 	cmp  %g0, %o0                                  
        ret = -EINTR;                                                 
      if (! PIPE_LOCK(pipe)) {                                        
4000e210:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
      }                                                               
                                                                      
      /* Wait until there is chunk bytes space or no reader exists */ 
      pipe->waitingWriters ++;                                        
      PIPE_UNLOCK(pipe);                                              
      if (! PIPE_WRITEWAIT(pipe))                                     
4000e214:	b8 60 20 00 	subx  %g0, 0, %i4                              
        ret = -EINTR;                                                 
      if (! PIPE_LOCK(pipe)) {                                        
4000e218:	92 10 20 00 	clr  %o1                                       
4000e21c:	94 10 20 00 	clr  %o2                                       
4000e220:	7f ff ea 19 	call  40008a84 <rtems_semaphore_obtain>        
4000e224:	b8 0f 3f fc 	and  %i4, -4, %i4                              
4000e228:	80 a2 20 00 	cmp  %o0, 0                                    
4000e22c:	12 80 00 45 	bne  4000e340 <pipe_write+0x1d8>               <== NEVER TAKEN
4000e230:	80 a7 20 00 	cmp  %i4, 0                                    
        /* WARN waitingWriters not restored! */                       
        ret = -EINTR;                                                 
        goto out_nolock;                                              
      }                                                               
      pipe->waitingWriters --;                                        
4000e234:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
4000e238:	82 00 7f ff 	add  %g1, -1, %g1                              
      if (ret != 0)                                                   
4000e23c:	12 80 00 3d 	bne  4000e330 <pipe_write+0x1c8>               <== NEVER TAKEN
4000e240:	c2 27 60 1c 	st  %g1, [ %i5 + 0x1c ]                        
        goto out_locked;                                              
                                                                      
      if (pipe->Readers == 0) {                                       
4000e244:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
4000e248:	80 a0 60 00 	cmp  %g1, 0                                    
4000e24c:	22 80 00 2b 	be,a   4000e2f8 <pipe_write+0x190>             <== NEVER TAKEN
4000e250:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        <== NOT EXECUTED
4000e254:	f8 07 60 04 	ld  [ %i5 + 4 ], %i4                           
                                                                      
  /* 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) {                                
4000e258:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
4000e25c:	84 27 00 01 	sub  %i4, %g1, %g2                             
4000e260:	80 a0 80 10 	cmp  %g2, %l0                                  
4000e264:	2a bf ff df 	bcs,a   4000e1e0 <pipe_write+0x78>             <== NEVER TAKEN
4000e268:	c2 06 e0 10 	ld  [ %i3 + 0x10 ], %g1                        <== NOT EXECUTED
        ret = -EPIPE;                                                 
        goto out_locked;                                              
      }                                                               
    }                                                                 
                                                                      
    chunk = MIN(count - written, PIPE_SPACE(pipe));                   
4000e26c:	86 26 80 11 	sub  %i2, %l1, %g3                             
4000e270:	80 a0 80 03 	cmp  %g2, %g3                                  
4000e274:	08 80 00 03 	bleu  4000e280 <pipe_write+0x118>              
4000e278:	a0 10 00 02 	mov  %g2, %l0                                  
4000e27c:	a0 10 00 03 	mov  %g3, %l0                                  
    chunk1 = pipe->Size - PIPE_WSTART(pipe);                          
4000e280:	d0 07 60 08 	ld  [ %i5 + 8 ], %o0                           
4000e284:	92 10 00 1c 	mov  %i4, %o1                                  
4000e288:	40 00 3f e6 	call  4001e220 <.urem>                         
4000e28c:	90 00 40 08 	add  %g1, %o0, %o0                             
    if (chunk > chunk1) {                                             
      memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
4000e290:	c2 07 40 00 	ld  [ %i5 ], %g1                               
        goto out_locked;                                              
      }                                                               
    }                                                                 
                                                                      
    chunk = MIN(count - written, PIPE_SPACE(pipe));                   
    chunk1 = pipe->Size - PIPE_WSTART(pipe);                          
4000e294:	b8 27 00 08 	sub  %i4, %o0, %i4                             
    if (chunk > chunk1) {                                             
4000e298:	80 a4 00 1c 	cmp  %l0, %i4                                  
4000e29c:	04 80 00 2d 	ble  4000e350 <pipe_write+0x1e8>               
4000e2a0:	92 06 40 11 	add  %i1, %l1, %o1                             
      memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
4000e2a4:	94 10 00 1c 	mov  %i4, %o2                                  
4000e2a8:	40 00 10 d7 	call  40012604 <memcpy>                        
4000e2ac:	90 00 40 08 	add  %g1, %o0, %o0                             
      memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
4000e2b0:	d0 07 40 00 	ld  [ %i5 ], %o0                               
4000e2b4:	92 07 00 11 	add  %i4, %l1, %o1                             
4000e2b8:	94 24 00 1c 	sub  %l0, %i4, %o2                             
4000e2bc:	40 00 10 d2 	call  40012604 <memcpy>                        
4000e2c0:	92 06 40 09 	add  %i1, %o1, %o1                             
    }                                                                 
    else                                                              
      memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
                                                                      
    pipe->Length += chunk;                                            
4000e2c4:	c4 07 60 0c 	ld  [ %i5 + 0xc ], %g2                         
    if (pipe->waitingReaders > 0)                                     
4000e2c8:	c2 07 60 18 	ld  [ %i5 + 0x18 ], %g1                        
      memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
    }                                                                 
    else                                                              
      memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
                                                                      
    pipe->Length += chunk;                                            
4000e2cc:	84 00 80 10 	add  %g2, %l0, %g2                             
    if (pipe->waitingReaders > 0)                                     
4000e2d0:	80 a0 60 00 	cmp  %g1, 0                                    
4000e2d4:	12 80 00 24 	bne  4000e364 <pipe_write+0x1fc>               
4000e2d8:	c4 27 60 0c 	st  %g2, [ %i5 + 0xc ]                         
      PIPE_WAKEUPREADERS(pipe);                                       
    written += chunk;                                                 
4000e2dc:	b0 06 00 10 	add  %i0, %l0, %i0                             
  }                                                                   
                                                                      
  /* Write of PIPE_BUF bytes or less shall not be interleaved */      
  chunk = count <= pipe->Size ? count : 1;                            
                                                                      
  while (written < count) {                                           
4000e2e0:	80 a6 80 18 	cmp  %i2, %i0                                  
4000e2e4:	08 80 00 12 	bleu  4000e32c <pipe_write+0x1c4>              <== ALWAYS TAKEN
4000e2e8:	a2 10 00 18 	mov  %i0, %l1                                  
4000e2ec:	f8 07 60 04 	ld  [ %i5 + 4 ], %i4                           <== NOT EXECUTED
    pipe->Length += chunk;                                            
    if (pipe->waitingReaders > 0)                                     
      PIPE_WAKEUPREADERS(pipe);                                       
    written += chunk;                                                 
    /* Write of more than PIPE_BUF bytes can be interleaved */        
    chunk = 1;                                                        
4000e2f0:	10 bf ff b6 	b  4000e1c8 <pipe_write+0x60>                  <== NOT EXECUTED
4000e2f4:	a0 10 20 01 	mov  1, %l0                                    <== NOT EXECUTED
  }                                                                   
                                                                      
out_locked:                                                           
  PIPE_UNLOCK(pipe);                                                  
4000e2f8:	7f ff ea 32 	call  40008bc0 <rtems_semaphore_release>       
4000e2fc:	b8 10 3f e0 	mov  -32, %i4                                  
                                                                      
out_nolock:                                                           
#ifdef RTEMS_POSIX_API                                                
  /* Signal SIGPIPE */                                                
  if (ret == -EPIPE)                                                  
    kill(getpid(), SIGPIPE);                                          
4000e300:	40 00 01 19 	call  4000e764 <getpid>                        
4000e304:	01 00 00 00 	nop                                            
4000e308:	40 00 02 98 	call  4000ed68 <kill>                          
4000e30c:	92 10 20 0d 	mov  0xd, %o1	! d <PROM_START+0xd>             
#endif                                                                
                                                                      
  if (written > 0)                                                    
4000e310:	80 a6 20 00 	cmp  %i0, 0                                    
4000e314:	14 bf ff 9a 	bg  4000e17c <pipe_write+0x14>                 
4000e318:	01 00 00 00 	nop                                            
4000e31c:	81 c7 e0 08 	ret                                            
4000e320:	91 e8 00 1c 	restore  %g0, %i4, %o0                         
    ret = -EPIPE;                                                     
    goto out_locked;                                                  
  }                                                                   
                                                                      
  /* Write of PIPE_BUF bytes or less shall not be interleaved */      
  chunk = count <= pipe->Size ? count : 1;                            
4000e324:	10 bf ff a7 	b  4000e1c0 <pipe_write+0x58>                  
4000e328:	a0 10 00 1a 	mov  %i2, %l0                                  
                                                                      
  while (written < count) {                                           
4000e32c:	b8 10 20 00 	clr  %i4                                       
    /* Write of more than PIPE_BUF bytes can be interleaved */        
    chunk = 1;                                                        
  }                                                                   
                                                                      
out_locked:                                                           
  PIPE_UNLOCK(pipe);                                                  
4000e330:	7f ff ea 24 	call  40008bc0 <rtems_semaphore_release>       
4000e334:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
  /* Signal SIGPIPE */                                                
  if (ret == -EPIPE)                                                  
    kill(getpid(), SIGPIPE);                                          
#endif                                                                
                                                                      
  if (written > 0)                                                    
4000e338:	10 bf ff f7 	b  4000e314 <pipe_write+0x1ac>                 
4000e33c:	80 a6 20 00 	cmp  %i0, 0                                    
      PIPE_UNLOCK(pipe);                                              
      if (! PIPE_WRITEWAIT(pipe))                                     
        ret = -EINTR;                                                 
      if (! PIPE_LOCK(pipe)) {                                        
        /* WARN waitingWriters not restored! */                       
        ret = -EINTR;                                                 
4000e340:	10 bf ff f4 	b  4000e310 <pipe_write+0x1a8>                 <== NOT EXECUTED
4000e344:	b8 10 3f fc 	mov  -4, %i4                                   <== NOT EXECUTED
  /* Write nothing */                                                 
  if (count == 0)                                                     
    return 0;                                                         
                                                                      
  if (! PIPE_LOCK(pipe))                                              
    return -EINTR;                                                    
4000e348:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000e34c:	91 e8 3f fc 	restore  %g0, -4, %o0                          <== NOT EXECUTED
    if (chunk > chunk1) {                                             
      memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
      memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
    }                                                                 
    else                                                              
      memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
4000e350:	90 00 40 08 	add  %g1, %o0, %o0                             
4000e354:	40 00 10 ac 	call  40012604 <memcpy>                        
4000e358:	94 10 00 10 	mov  %l0, %o2                                  
                                                                      
    pipe->Length += chunk;                                            
4000e35c:	10 bf ff db 	b  4000e2c8 <pipe_write+0x160>                 
4000e360:	c4 07 60 0c 	ld  [ %i5 + 0xc ], %g2                         
    if (pipe->waitingReaders > 0)                                     
      PIPE_WAKEUPREADERS(pipe);                                       
4000e364:	d0 07 60 2c 	ld  [ %i5 + 0x2c ], %o0                        
4000e368:	40 00 04 b1 	call  4000f62c <rtems_barrier_release>         
4000e36c:	92 07 bf fc 	add  %fp, -4, %o1                              
    written += chunk;                                                 
4000e370:	10 bf ff dc 	b  4000e2e0 <pipe_write+0x178>                 
4000e374:	b0 06 00 10 	add  %i0, %l0, %i0                             
                                                                      

400083ec <posix_memalign>: ) { /* * Update call statistics */ MSBUMP(memalign_calls, 1);
400083ec:	05 10 00 98 	sethi  %hi(0x40026000), %g2                    
400083f0:	84 10 a0 80 	or  %g2, 0x80, %g2	! 40026080 <rtems_malloc_statistics>
400083f4:	c6 00 a0 08 	ld  [ %g2 + 8 ], %g3                           
400083f8:	86 00 e0 01 	inc  %g3                                       
400083fc:	c6 20 a0 08 	st  %g3, [ %g2 + 8 ]                           
                                                                      
  if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
40008400:	84 02 7f ff 	add  %o1, -1, %g2                              
40008404:	80 88 80 09 	btst  %g2, %o1                                 
40008408:	02 80 00 04 	be  40008418 <posix_memalign+0x2c>             <== ALWAYS TAKEN
4000840c:	80 a2 60 03 	cmp  %o1, 3                                    
  /*                                                                  
   *  rtems_memalign does all of the error checking work EXCEPT       
   *  for adding restrictionso on the alignment.                      
   */                                                                 
  return rtems_memalign( pointer, alignment, size );                  
}                                                                     
40008410:	81 c3 e0 08 	retl                                           
40008414:	90 10 20 16 	mov  0x16, %o0                                 
  /*                                                                  
   *  Update call statistics                                          
   */                                                                 
  MSBUMP(memalign_calls, 1);                                          
                                                                      
  if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
40008418:	08 bf ff fe 	bleu  40008410 <posix_memalign+0x24>           
4000841c:	01 00 00 00 	nop                                            
                                                                      
  /*                                                                  
   *  rtems_memalign does all of the error checking work EXCEPT       
   *  for adding restrictionso on the alignment.                      
   */                                                                 
  return rtems_memalign( pointer, alignment, size );                  
40008420:	82 13 c0 00 	mov  %o7, %g1                                  
40008424:	40 00 00 89 	call  40008648 <rtems_memalign>                
40008428:	9e 10 40 00 	mov  %g1, %o7                                  
                                                                      

4000be40 <pthread_attr_setschedpolicy>: int pthread_attr_setschedpolicy( pthread_attr_t *attr, int policy ) {
4000be40:	82 10 00 08 	mov  %o0, %g1                                  
  if ( !attr || !attr->is_initialized )                               
4000be44:	80 a0 60 00 	cmp  %g1, 0                                    
4000be48:	02 80 00 06 	be  4000be60 <pthread_attr_setschedpolicy+0x20>
4000be4c:	90 10 20 16 	mov  0x16, %o0                                 
4000be50:	c4 00 40 00 	ld  [ %g1 ], %g2                               
4000be54:	80 a0 a0 00 	cmp  %g2, 0                                    
4000be58:	12 80 00 04 	bne  4000be68 <pthread_attr_setschedpolicy+0x28>
4000be5c:	80 a2 60 04 	cmp  %o1, 4                                    
      return 0;                                                       
                                                                      
    default:                                                          
      return ENOTSUP;                                                 
  }                                                                   
}                                                                     
4000be60:	81 c3 e0 08 	retl                                           
4000be64:	01 00 00 00 	nop                                            
)                                                                     
{                                                                     
  if ( !attr || !attr->is_initialized )                               
    return EINVAL;                                                    
                                                                      
  switch ( policy ) {                                                 
4000be68:	18 80 00 09 	bgu  4000be8c <pthread_attr_setschedpolicy+0x4c>
4000be6c:	84 10 20 01 	mov  1, %g2	! 1 <PROM_START+0x1>               
4000be70:	85 28 80 09 	sll  %g2, %o1, %g2                             
4000be74:	80 88 a0 17 	btst  0x17, %g2                                
4000be78:	02 80 00 05 	be  4000be8c <pthread_attr_setschedpolicy+0x4c><== NEVER TAKEN
4000be7c:	01 00 00 00 	nop                                            
    case SCHED_OTHER:                                                 
    case SCHED_FIFO:                                                  
    case SCHED_RR:                                                    
    case SCHED_SPORADIC:                                              
      attr->schedpolicy = policy;                                     
4000be80:	d2 20 60 14 	st  %o1, [ %g1 + 0x14 ]                        
      return 0;                                                       
4000be84:	81 c3 e0 08 	retl                                           
4000be88:	90 10 20 00 	clr  %o0                                       
                                                                      
    default:                                                          
      return ENOTSUP;                                                 
  }                                                                   
}                                                                     
4000be8c:	81 c3 e0 08 	retl                                           
4000be90:	90 10 20 86 	mov  0x86, %o0                                 
                                                                      

400072d4 <pthread_barrier_init>: int pthread_barrier_init( pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count ) {
400072d4:	9d e3 bf 90 	save  %sp, -112, %sp                           
  const pthread_barrierattr_t   *the_attr;                            
                                                                      
  /*                                                                  
   *  Error check parameters                                          
   */                                                                 
  if ( !barrier )                                                     
400072d8:	80 a6 20 00 	cmp  %i0, 0                                    
400072dc:	02 80 00 04 	be  400072ec <pthread_barrier_init+0x18>       
400072e0:	80 a6 a0 00 	cmp  %i2, 0                                    
    return EINVAL;                                                    
                                                                      
  if ( count == 0 )                                                   
400072e4:	12 80 00 04 	bne  400072f4 <pthread_barrier_init+0x20>      
400072e8:	80 a6 60 00 	cmp  %i1, 0                                    
   * Exit the critical section and return the user an operational barrier
   */                                                                 
  *barrier = the_barrier->Object.id;                                  
  _Thread_Enable_dispatch();                                          
  return 0;                                                           
}                                                                     
400072ec:	81 c7 e0 08 	ret                                            
400072f0:	91 e8 20 16 	restore  %g0, 0x16, %o0                        
    return EINVAL;                                                    
                                                                      
  /*                                                                  
   * If the user passed in NULL, use the default attributes           
   */                                                                 
  if ( attr ) {                                                       
400072f4:	02 80 00 23 	be  40007380 <pthread_barrier_init+0xac>       
400072f8:	90 07 bf f8 	add  %fp, -8, %o0                              
  }                                                                   
                                                                      
  /*                                                                  
   * Now start error checking the attributes that we are going to use 
   */                                                                 
  if ( !the_attr->is_initialized )                                    
400072fc:	c2 06 40 00 	ld  [ %i1 ], %g1                               
40007300:	80 a0 60 00 	cmp  %g1, 0                                    
40007304:	02 bf ff fa 	be  400072ec <pthread_barrier_init+0x18>       
40007308:	01 00 00 00 	nop                                            
    return EINVAL;                                                    
                                                                      
  switch ( the_attr->process_shared ) {                               
4000730c:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
40007310:	80 a0 60 00 	cmp  %g1, 0                                    
40007314:	12 bf ff f6 	bne  400072ec <pthread_barrier_init+0x18>      <== NEVER TAKEN
40007318:	03 10 00 60 	sethi  %hi(0x40018000), %g1                    
   *                                                                  
   * This rountine increments the thread dispatch level               
   */                                                                 
  RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
  {                                                                   
    uint32_t level = _Thread_Dispatch_disable_level;                  
4000731c:	c4 00 60 f0 	ld  [ %g1 + 0xf0 ], %g2	! 400180f0 <_Thread_Dispatch_disable_level>
  }                                                                   
                                                                      
  /*                                                                  
   * Convert from POSIX attributes to Core Barrier attributes         
   */                                                                 
  the_attributes.discipline    = CORE_BARRIER_AUTOMATIC_RELEASE;      
40007320:	c0 27 bf f0 	clr  [ %fp + -16 ]                             
                                                                      
    ++level;                                                          
40007324:	84 00 a0 01 	inc  %g2                                       
  the_attributes.maximum_count = count;                               
40007328:	f4 27 bf f4 	st  %i2, [ %fp + -12 ]                         
    _Thread_Dispatch_disable_level = level;                           
4000732c:	c4 20 60 f0 	st  %g2, [ %g1 + 0xf0 ]                        
 *  This function allocates a barrier control block from              
 *  the inactive chain of free barrier control blocks.                
 */                                                                   
RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Allocate( void )
{                                                                     
  return (POSIX_Barrier_Control *)                                    
40007330:	39 10 00 61 	sethi  %hi(0x40018400), %i4                    
40007334:	40 00 08 ee 	call  400096ec <_Objects_Allocate>             
40007338:	90 17 20 74 	or  %i4, 0x74, %o0	! 40018474 <_POSIX_Barrier_Information>
   */                                                                 
  _Thread_Disable_dispatch();             /* prevents deletion */     
                                                                      
  the_barrier = _POSIX_Barrier_Allocate();                            
                                                                      
  if ( !the_barrier ) {                                               
4000733c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40007340:	02 80 00 14 	be  40007390 <pthread_barrier_init+0xbc>       
40007344:	90 07 60 10 	add  %i5, 0x10, %o0                            
    _Thread_Enable_dispatch();                                        
    return EAGAIN;                                                    
  }                                                                   
                                                                      
  _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 
40007348:	40 00 06 37 	call  40008c24 <_CORE_barrier_Initialize>      
4000734c:	92 07 bf f0 	add  %fp, -16, %o1                             
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  uint32_t             name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
40007350:	c4 17 60 0a 	lduh  [ %i5 + 0xa ], %g2                       
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
40007354:	b8 17 20 74 	or  %i4, 0x74, %i4                             
40007358:	c6 07 20 1c 	ld  [ %i4 + 0x1c ], %g3                        
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  uint32_t             name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
4000735c:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
40007360:	85 28 a0 02 	sll  %g2, 2, %g2                               
40007364:	fa 20 c0 02 	st  %i5, [ %g3 + %g2 ]                         
    _Objects_Get_index( the_object->id ),                             
    the_object                                                        
  );                                                                  
                                                                      
  /* ASSERT: information->is_string == false */                       
  the_object->name.name_u32 = name;                                   
40007368:	c0 27 60 0c 	clr  [ %i5 + 0xc ]                             
  );                                                                  
                                                                      
  /*                                                                  
   * Exit the critical section and return the user an operational barrier
   */                                                                 
  *barrier = the_barrier->Object.id;                                  
4000736c:	c2 26 00 00 	st  %g1, [ %i0 ]                               
  _Thread_Enable_dispatch();                                          
40007370:	40 00 0d f4 	call  4000ab40 <_Thread_Enable_dispatch>       
40007374:	b0 10 20 00 	clr  %i0                                       
40007378:	81 c7 e0 08 	ret                                            
4000737c:	81 e8 00 00 	restore                                        
   * If the user passed in NULL, use the default attributes           
   */                                                                 
  if ( attr ) {                                                       
    the_attr = attr;                                                  
  } else {                                                            
    (void) pthread_barrierattr_init( &my_attr );                      
40007380:	7f ff ff 9c 	call  400071f0 <pthread_barrierattr_init>      
40007384:	b2 07 bf f8 	add  %fp, -8, %i1                              
  }                                                                   
                                                                      
  /*                                                                  
   * Now start error checking the attributes that we are going to use 
   */                                                                 
  if ( !the_attr->is_initialized )                                    
40007388:	10 bf ff de 	b  40007300 <pthread_barrier_init+0x2c>        
4000738c:	c2 06 40 00 	ld  [ %i1 ], %g1                               
  _Thread_Disable_dispatch();             /* prevents deletion */     
                                                                      
  the_barrier = _POSIX_Barrier_Allocate();                            
                                                                      
  if ( !the_barrier ) {                                               
    _Thread_Enable_dispatch();                                        
40007390:	40 00 0d ec 	call  4000ab40 <_Thread_Enable_dispatch>       
40007394:	b0 10 20 0b 	mov  0xb, %i0                                  
40007398:	81 c7 e0 08 	ret                                            
4000739c:	81 e8 00 00 	restore                                        
                                                                      

40006b68 <pthread_cleanup_push>: void pthread_cleanup_push( void (*routine)( void * ), void *arg ) {
40006b68:	9d e3 bf a0 	save  %sp, -96, %sp                            
  /*                                                                  
   *  The POSIX standard does not address what to do when the routine 
   *  is NULL.  It also does not address what happens when we cannot  
   *  allocate memory or anything else bad happens.                   
   */                                                                 
  if ( !routine )                                                     
40006b6c:	80 a6 20 00 	cmp  %i0, 0                                    
40006b70:	02 80 00 13 	be  40006bbc <pthread_cleanup_push+0x54>       
40006b74:	03 10 00 61 	sethi  %hi(0x40018400), %g1                    
   *                                                                  
   * This rountine increments the thread dispatch level               
   */                                                                 
  RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
  {                                                                   
    uint32_t level = _Thread_Dispatch_disable_level;                  
40006b78:	c4 00 62 10 	ld  [ %g1 + 0x210 ], %g2	! 40018610 <_Thread_Dispatch_disable_level>
                                                                      
    ++level;                                                          
40006b7c:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
40006b80:	c4 20 62 10 	st  %g2, [ %g1 + 0x210 ]                       
    return;                                                           
                                                                      
  _Thread_Disable_dispatch();                                         
  handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
40006b84:	40 00 12 bc 	call  4000b674 <_Workspace_Allocate>           
40006b88:	90 10 20 10 	mov  0x10, %o0                                 
                                                                      
  if ( handler ) {                                                    
40006b8c:	80 a2 20 00 	cmp  %o0, 0                                    
40006b90:	02 80 00 09 	be  40006bb4 <pthread_cleanup_push+0x4c>       <== NEVER TAKEN
40006b94:	03 10 00 62 	sethi  %hi(0x40018800), %g1                    
    thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
40006b98:	c2 00 63 30 	ld  [ %g1 + 0x330 ], %g1	! 40018b30 <_Per_CPU_Information+0x10>
    handler_stack = &thread_support->Cancellation_Handlers;           
                                                                      
    handler->routine = routine;                                       
    handler->arg = arg;                                               
                                                                      
    _Chain_Append( handler_stack, &handler->Node );                   
40006b9c:	92 10 00 08 	mov  %o0, %o1                                  
  handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
                                                                      
  if ( handler ) {                                                    
    thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
                                                                      
    handler_stack = &thread_support->Cancellation_Handlers;           
40006ba0:	c2 00 61 50 	ld  [ %g1 + 0x150 ], %g1                       
                                                                      
    handler->routine = routine;                                       
40006ba4:	f0 22 20 08 	st  %i0, [ %o0 + 8 ]                           
    handler->arg = arg;                                               
40006ba8:	f2 22 20 0c 	st  %i1, [ %o0 + 0xc ]                         
                                                                      
    _Chain_Append( handler_stack, &handler->Node );                   
40006bac:	40 00 06 67 	call  40008548 <_Chain_Append>                 
40006bb0:	90 00 60 e4 	add  %g1, 0xe4, %o0                            
  }                                                                   
  _Thread_Enable_dispatch();                                          
40006bb4:	40 00 0e 33 	call  4000a480 <_Thread_Enable_dispatch>       
40006bb8:	81 e8 00 00 	restore                                        
40006bbc:	81 c7 e0 08 	ret                                            
40006bc0:	81 e8 00 00 	restore                                        
                                                                      

40007b08 <pthread_cond_init>: */ int pthread_cond_init( pthread_cond_t *cond, const pthread_condattr_t *attr ) {
40007b08:	9d e3 bf a0 	save  %sp, -96, %sp                            
  POSIX_Condition_variables_Control   *the_cond;                      
  const pthread_condattr_t            *the_attr;                      
                                                                      
  if ( attr ) the_attr = attr;                                        
40007b0c:	80 a6 60 00 	cmp  %i1, 0                                    
40007b10:	22 80 00 27 	be,a   40007bac <pthread_cond_init+0xa4>       
40007b14:	33 10 00 5f 	sethi  %hi(0x40017c00), %i1                    
  else        the_attr = &_POSIX_Condition_variables_Default_attributes;
                                                                      
  /*                                                                  
   *  Be careful about attributes when global!!!                      
   */                                                                 
  if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )           
40007b18:	c4 06 60 04 	ld  [ %i1 + 4 ], %g2	! 40017c04 <rtems_filesystem_default_pathconf+0x20>
40007b1c:	80 a0 a0 01 	cmp  %g2, 1                                    
40007b20:	02 80 00 06 	be  40007b38 <pthread_cond_init+0x30>          <== NEVER TAKEN
40007b24:	82 10 20 16 	mov  0x16, %g1                                 
    return EINVAL;                                                    
                                                                      
  if ( !the_attr->is_initialized )                                    
40007b28:	c4 06 40 00 	ld  [ %i1 ], %g2                               
40007b2c:	80 a0 a0 00 	cmp  %g2, 0                                    
40007b30:	32 80 00 04 	bne,a   40007b40 <pthread_cond_init+0x38>      
40007b34:	03 10 00 64 	sethi  %hi(0x40019000), %g1                    
  *cond = the_cond->Object.id;                                        
                                                                      
  _Thread_Enable_dispatch();                                          
                                                                      
  return 0;                                                           
}                                                                     
40007b38:	81 c7 e0 08 	ret                                            
40007b3c:	91 e8 00 01 	restore  %g0, %g1, %o0                         
   *                                                                  
   * This rountine increments the thread dispatch level               
   */                                                                 
  RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
  {                                                                   
    uint32_t level = _Thread_Dispatch_disable_level;                  
40007b40:	c4 00 63 30 	ld  [ %g1 + 0x330 ], %g2                       
                                                                      
    ++level;                                                          
40007b44:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
40007b48:	c4 20 63 30 	st  %g2, [ %g1 + 0x330 ]                       
 */                                                                   
                                                                      
RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control                
  *_POSIX_Condition_variables_Allocate( void )                        
{                                                                     
  return (POSIX_Condition_variables_Control *)                        
40007b4c:	39 10 00 65 	sethi  %hi(0x40019400), %i4                    
40007b50:	40 00 0a 9e 	call  4000a5c8 <_Objects_Allocate>             
40007b54:	90 17 23 4c 	or  %i4, 0x34c, %o0	! 4001974c <_POSIX_Condition_variables_Information>
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  the_cond = _POSIX_Condition_variables_Allocate();                   
                                                                      
  if ( !the_cond ) {                                                  
40007b58:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40007b5c:	02 80 00 16 	be  40007bb4 <pthread_cond_init+0xac>          
40007b60:	90 07 60 18 	add  %i5, 0x18, %o0                            
    _Thread_Enable_dispatch();                                        
    return ENOMEM;                                                    
  }                                                                   
                                                                      
  the_cond->process_shared  = the_attr->process_shared;               
40007b64:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
                                                                      
  the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;               
                                                                      
  _Thread_queue_Initialize(                                           
40007b68:	92 10 20 00 	clr  %o1                                       
40007b6c:	15 04 00 02 	sethi  %hi(0x10000800), %o2                    
40007b70:	96 10 20 74 	mov  0x74, %o3                                 
  if ( !the_cond ) {                                                  
    _Thread_Enable_dispatch();                                        
    return ENOMEM;                                                    
  }                                                                   
                                                                      
  the_cond->process_shared  = the_attr->process_shared;               
40007b74:	c2 27 60 10 	st  %g1, [ %i5 + 0x10 ]                        
                                                                      
  the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;               
                                                                      
  _Thread_queue_Initialize(                                           
40007b78:	40 00 11 c8 	call  4000c298 <_Thread_queue_Initialize>      
40007b7c:	c0 27 60 14 	clr  [ %i5 + 0x14 ]                            
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  uint32_t             name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
40007b80:	c4 17 60 0a 	lduh  [ %i5 + 0xa ], %g2                       
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
40007b84:	b8 17 23 4c 	or  %i4, 0x34c, %i4                            
40007b88:	c6 07 20 1c 	ld  [ %i4 + 0x1c ], %g3                        
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  uint32_t             name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
40007b8c:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
40007b90:	85 28 a0 02 	sll  %g2, 2, %g2                               
40007b94:	fa 20 c0 02 	st  %i5, [ %g3 + %g2 ]                         
    _Objects_Get_index( the_object->id ),                             
    the_object                                                        
  );                                                                  
                                                                      
  /* ASSERT: information->is_string == false */                       
  the_object->name.name_u32 = name;                                   
40007b98:	c0 27 60 0c 	clr  [ %i5 + 0xc ]                             
    0                                                                 
  );                                                                  
                                                                      
  *cond = the_cond->Object.id;                                        
                                                                      
  _Thread_Enable_dispatch();                                          
40007b9c:	40 00 0f a0 	call  4000ba1c <_Thread_Enable_dispatch>       
40007ba0:	c2 26 00 00 	st  %g1, [ %i0 ]                               
                                                                      
  return 0;                                                           
40007ba4:	10 bf ff e5 	b  40007b38 <pthread_cond_init+0x30>           
40007ba8:	82 10 20 00 	clr  %g1                                       
{                                                                     
  POSIX_Condition_variables_Control   *the_cond;                      
  const pthread_condattr_t            *the_attr;                      
                                                                      
  if ( attr ) the_attr = attr;                                        
  else        the_attr = &_POSIX_Condition_variables_Default_attributes;
40007bac:	10 bf ff db 	b  40007b18 <pthread_cond_init+0x10>           
40007bb0:	b2 16 60 e4 	or  %i1, 0xe4, %i1                             
  _Thread_Disable_dispatch();                                         
                                                                      
  the_cond = _POSIX_Condition_variables_Allocate();                   
                                                                      
  if ( !the_cond ) {                                                  
    _Thread_Enable_dispatch();                                        
40007bb4:	40 00 0f 9a 	call  4000ba1c <_Thread_Enable_dispatch>       
40007bb8:	01 00 00 00 	nop                                            
    return ENOMEM;                                                    
40007bbc:	10 bf ff df 	b  40007b38 <pthread_cond_init+0x30>           
40007bc0:	82 10 20 0c 	mov  0xc, %g1	! c <PROM_START+0xc>             
                                                                      

4000796c <pthread_condattr_destroy>: */ int pthread_condattr_destroy( pthread_condattr_t *attr ) {
4000796c:	82 10 00 08 	mov  %o0, %g1                                  
  if ( !attr || attr->is_initialized == false )                       
40007970:	80 a0 60 00 	cmp  %g1, 0                                    
40007974:	02 80 00 06 	be  4000798c <pthread_condattr_destroy+0x20>   
40007978:	90 10 20 16 	mov  0x16, %o0                                 
4000797c:	c4 00 40 00 	ld  [ %g1 ], %g2                               
40007980:	80 a0 a0 00 	cmp  %g2, 0                                    
40007984:	32 80 00 04 	bne,a   40007994 <pthread_condattr_destroy+0x28><== ALWAYS TAKEN
40007988:	c0 20 40 00 	clr  [ %g1 ]                                   
    return EINVAL;                                                    
                                                                      
  attr->is_initialized = false;                                       
  return 0;                                                           
}                                                                     
4000798c:	81 c3 e0 08 	retl                                           
40007990:	01 00 00 00 	nop                                            
40007994:	81 c3 e0 08 	retl                                           
40007998:	90 10 20 00 	clr  %o0	! 0 <PROM_START>                      
                                                                      

40007014 <pthread_create>: pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)( void * ), void *arg ) {
40007014:	9d e3 bf 58 	save  %sp, -168, %sp                           
  int                                 schedpolicy = SCHED_RR;         
  struct sched_param                  schedparam;                     
  Objects_Name                        name;                           
  int                                 rc;                             
                                                                      
  if ( !start_routine )                                               
40007018:	80 a6 a0 00 	cmp  %i2, 0                                    
4000701c:	02 80 00 0a 	be  40007044 <pthread_create+0x30>             
40007020:	ba 10 20 0e 	mov  0xe, %i5                                  
    return EFAULT;                                                    
                                                                      
  the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;      
40007024:	80 a6 60 00 	cmp  %i1, 0                                    
40007028:	22 80 00 63 	be,a   400071b4 <pthread_create+0x1a0>         
4000702c:	33 10 00 78 	sethi  %hi(0x4001e000), %i1                    
                                                                      
  if ( !the_attr->is_initialized )                                    
40007030:	c2 06 40 00 	ld  [ %i1 ], %g1                               
40007034:	80 a0 60 00 	cmp  %g1, 0                                    
40007038:	32 80 00 05 	bne,a   4000704c <pthread_create+0x38>         
4000703c:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
      schedpolicy = the_attr->schedpolicy;                            
      schedparam  = the_attr->schedparam;                             
      break;                                                          
                                                                      
    default:                                                          
      return EINVAL;                                                  
40007040:	ba 10 20 16 	mov  0x16, %i5                                 
   */                                                                 
  *thread = the_thread->Object.id;                                    
                                                                      
  _RTEMS_Unlock_allocator();                                          
  return 0;                                                           
}                                                                     
40007044:	81 c7 e0 08 	ret                                            
40007048:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
   *  stack space if it is allowed to allocate it itself.             
   *                                                                  
   *  NOTE: If the user provides the stack we will let it drop below  
   *        twice the minimum.                                        
   */                                                                 
  if ( the_attr->stackaddr && !_Stack_Is_enough(the_attr->stacksize) )
4000704c:	80 a0 60 00 	cmp  %g1, 0                                    
40007050:	02 80 00 07 	be  4000706c <pthread_create+0x58>             
40007054:	03 10 00 7b 	sethi  %hi(0x4001ec00), %g1                    
40007058:	c4 06 60 08 	ld  [ %i1 + 8 ], %g2                           
4000705c:	c2 00 62 00 	ld  [ %g1 + 0x200 ], %g1                       
40007060:	80 a0 80 01 	cmp  %g2, %g1                                  
40007064:	0a bf ff f8 	bcs  40007044 <pthread_create+0x30>            
40007068:	ba 10 20 16 	mov  0x16, %i5                                 
   *  If inheritsched is set to PTHREAD_INHERIT_SCHED, then this thread
   *  inherits scheduling attributes from the creating thread.   If it is
   *  PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the
   *  attributes structure.                                           
   */                                                                 
  switch ( the_attr->inheritsched ) {                                 
4000706c:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1                        
40007070:	80 a0 60 01 	cmp  %g1, 1                                    
40007074:	02 80 00 52 	be  400071bc <pthread_create+0x1a8>            
40007078:	80 a0 60 02 	cmp  %g1, 2                                    
4000707c:	32 bf ff f2 	bne,a   40007044 <pthread_create+0x30>         
40007080:	ba 10 20 16 	mov  0x16, %i5                                 
      schedparam  = api->schedparam;                                  
      break;                                                          
                                                                      
    case PTHREAD_EXPLICIT_SCHED:                                      
      schedpolicy = the_attr->schedpolicy;                            
      schedparam  = the_attr->schedparam;                             
40007084:	da 06 60 18 	ld  [ %i1 + 0x18 ], %o5                        
40007088:	de 06 60 1c 	ld  [ %i1 + 0x1c ], %o7                        
4000708c:	fa 06 60 20 	ld  [ %i1 + 0x20 ], %i5                        
40007090:	c8 06 60 24 	ld  [ %i1 + 0x24 ], %g4                        
40007094:	c6 06 60 28 	ld  [ %i1 + 0x28 ], %g3                        
40007098:	c4 06 60 2c 	ld  [ %i1 + 0x2c ], %g2                        
4000709c:	c2 06 60 30 	ld  [ %i1 + 0x30 ], %g1                        
      schedpolicy = api->schedpolicy;                                 
      schedparam  = api->schedparam;                                  
      break;                                                          
                                                                      
    case PTHREAD_EXPLICIT_SCHED:                                      
      schedpolicy = the_attr->schedpolicy;                            
400070a0:	f8 06 60 14 	ld  [ %i1 + 0x14 ], %i4                        
      schedparam  = the_attr->schedparam;                             
400070a4:	da 27 bf e4 	st  %o5, [ %fp + -28 ]                         
400070a8:	de 27 bf e8 	st  %o7, [ %fp + -24 ]                         
400070ac:	fa 27 bf ec 	st  %i5, [ %fp + -20 ]                         
400070b0:	c8 27 bf f0 	st  %g4, [ %fp + -16 ]                         
400070b4:	c6 27 bf f4 	st  %g3, [ %fp + -12 ]                         
400070b8:	c4 27 bf f8 	st  %g2, [ %fp + -8 ]                          
400070bc:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
                                                                      
  /*                                                                  
   *  Check the contentionscope since rtems only supports PROCESS wide
   *  contention (i.e. no system wide contention).                    
   */                                                                 
  if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )           
400070c0:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
400070c4:	80 a0 60 00 	cmp  %g1, 0                                    
400070c8:	12 bf ff df 	bne  40007044 <pthread_create+0x30>            
400070cc:	ba 10 20 86 	mov  0x86, %i5                                 
    return ENOTSUP;                                                   
                                                                      
  /*                                                                  
   *  Interpret the scheduling parameters.                            
   */                                                                 
  if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )       
400070d0:	40 00 19 e7 	call  4000d86c <_POSIX_Priority_Is_valid>      
400070d4:	d0 07 bf e4 	ld  [ %fp + -28 ], %o0                         
400070d8:	80 8a 20 ff 	btst  0xff, %o0                                
400070dc:	02 bf ff da 	be  40007044 <pthread_create+0x30>             <== NEVER TAKEN
400070e0:	ba 10 20 16 	mov  0x16, %i5                                 
                                                                      
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(        
  int priority                                                        
)                                                                     
{                                                                     
  return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
400070e4:	03 10 00 7b 	sethi  %hi(0x4001ec00), %g1                    
    return EINVAL;                                                    
                                                                      
  core_priority = _POSIX_Priority_To_core( schedparam.sched_priority );
400070e8:	e0 07 bf e4 	ld  [ %fp + -28 ], %l0                         
400070ec:	e8 08 61 fc 	ldub  [ %g1 + 0x1fc ], %l4                     
                                                                      
  /*                                                                  
   *  Set the core scheduling policy information.                     
   */                                                                 
  rc = _POSIX_Thread_Translate_sched_param(                           
400070f0:	90 10 00 1c 	mov  %i4, %o0                                  
400070f4:	92 07 bf e4 	add  %fp, -28, %o1                             
400070f8:	94 07 bf dc 	add  %fp, -36, %o2                             
400070fc:	40 00 19 e9 	call  4000d8a0 <_POSIX_Thread_Translate_sched_param>
40007100:	96 07 bf e0 	add  %fp, -32, %o3                             
    schedpolicy,                                                      
    &schedparam,                                                      
    &budget_algorithm,                                                
    &budget_callout                                                   
  );                                                                  
  if ( rc )                                                           
40007104:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40007108:	12 bf ff cf 	bne  40007044 <pthread_create+0x30>            
4000710c:	25 10 00 7e 	sethi  %hi(0x4001f800), %l2                    
  #endif                                                              
                                                                      
  /*                                                                  
   *  Lock the allocator mutex for protection                         
   */                                                                 
  _RTEMS_Lock_allocator();                                            
40007110:	d0 04 a2 30 	ld  [ %l2 + 0x230 ], %o0	! 4001fa30 <_RTEMS_Allocator_Mutex>
40007114:	40 00 06 99 	call  40008b78 <_API_Mutex_Lock>               
40007118:	27 10 00 7e 	sethi  %hi(0x4001f800), %l3                    
 *  _POSIX_Threads_Allocate                                           
 */                                                                   
                                                                      
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void )  
{                                                                     
  return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information );
4000711c:	40 00 09 70 	call  400096dc <_Objects_Allocate>             
40007120:	90 14 e3 b4 	or  %l3, 0x3b4, %o0	! 4001fbb4 <_POSIX_Threads_Information>
   *  Allocate the thread control block.                              
   *                                                                  
   *  NOTE:  Global threads are not currently supported.              
   */                                                                 
  the_thread = _POSIX_Threads_Allocate();                             
  if ( !the_thread ) {                                                
40007124:	a2 92 20 00 	orcc  %o0, 0, %l1                              
40007128:	02 80 00 1f 	be  400071a4 <pthread_create+0x190>            
4000712c:	05 10 00 7b 	sethi  %hi(0x4001ec00), %g2                    
                                                                      
  /*                                                                  
   *  Initialize the core thread for this task.                       
   */                                                                 
  name.name_p = NULL;   /* posix threads don't have a name by default */
  status = _Thread_Initialize(                                        
40007130:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
                                                                      
static inline size_t _POSIX_Threads_Ensure_minimum_stack (            
  size_t size                                                         
)                                                                     
{                                                                     
  if ( size >= PTHREAD_MINIMUM_STACK_SIZE )                           
40007134:	d6 00 a2 00 	ld  [ %g2 + 0x200 ], %o3                       
                                                                      
  /*                                                                  
   *  Initialize the core thread for this task.                       
   */                                                                 
  name.name_p = NULL;   /* posix threads don't have a name by default */
  status = _Thread_Initialize(                                        
40007138:	c0 27 bf d4 	clr  [ %fp + -44 ]                             
4000713c:	97 2a e0 01 	sll  %o3, 1, %o3                               
40007140:	80 a2 c0 01 	cmp  %o3, %g1                                  
40007144:	1a 80 00 03 	bcc  40007150 <pthread_create+0x13c>           
40007148:	d4 06 60 04 	ld  [ %i1 + 4 ], %o2                           
4000714c:	96 10 00 01 	mov  %g1, %o3                                  
40007150:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1                         
40007154:	9a 0d 20 ff 	and  %l4, 0xff, %o5                            
40007158:	c2 23 a0 60 	st  %g1, [ %sp + 0x60 ]                        
4000715c:	82 10 20 01 	mov  1, %g1                                    
40007160:	c2 23 a0 5c 	st  %g1, [ %sp + 0x5c ]                        
40007164:	c2 07 bf e0 	ld  [ %fp + -32 ], %g1                         
40007168:	c0 23 a0 68 	clr  [ %sp + 0x68 ]                            
4000716c:	c2 23 a0 64 	st  %g1, [ %sp + 0x64 ]                        
40007170:	82 07 bf d4 	add  %fp, -44, %g1                             
40007174:	90 14 e3 b4 	or  %l3, 0x3b4, %o0                            
40007178:	c2 23 a0 6c 	st  %g1, [ %sp + 0x6c ]                        
4000717c:	92 10 00 11 	mov  %l1, %o1                                  
40007180:	98 10 20 00 	clr  %o4                                       
40007184:	40 00 0e a2 	call  4000ac0c <_Thread_Initialize>            
40007188:	9a 23 40 10 	sub  %o5, %l0, %o5                             
    budget_callout,                                                   
    0,                    /* isr level */                             
    name                  /* posix threads don't have a name */       
  );                                                                  
                                                                      
  if ( !status ) {                                                    
4000718c:	80 8a 20 ff 	btst  0xff, %o0                                
40007190:	12 80 00 1e 	bne  40007208 <pthread_create+0x1f4>           
40007194:	11 10 00 7e 	sethi  %hi(0x4001f800), %o0                    
                                                                      
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free (                       
  Thread_Control *the_pthread                                         
)                                                                     
{                                                                     
  _Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object ); 
40007198:	92 10 00 11 	mov  %l1, %o1                                  
4000719c:	40 00 0a 48 	call  40009abc <_Objects_Free>                 
400071a0:	90 12 23 b4 	or  %o0, 0x3b4, %o0                            
    _POSIX_Threads_Free( the_thread );                                
    _RTEMS_Unlock_allocator();                                        
400071a4:	d0 04 a2 30 	ld  [ %l2 + 0x230 ], %o0                       
400071a8:	40 00 06 89 	call  40008bcc <_API_Mutex_Unlock>             
400071ac:	ba 10 20 0b 	mov  0xb, %i5                                  
400071b0:	30 bf ff a5 	b,a   40007044 <pthread_create+0x30>           
  int                                 rc;                             
                                                                      
  if ( !start_routine )                                               
    return EFAULT;                                                    
                                                                      
  the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;      
400071b4:	10 bf ff 9f 	b  40007030 <pthread_create+0x1c>              
400071b8:	b2 16 61 dc 	or  %i1, 0x1dc, %i1                            
   *  PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the
   *  attributes structure.                                           
   */                                                                 
  switch ( the_attr->inheritsched ) {                                 
    case PTHREAD_INHERIT_SCHED:                                       
      api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];    
400071bc:	03 10 00 7f 	sethi  %hi(0x4001fc00), %g1                    
400071c0:	c2 00 62 d0 	ld  [ %g1 + 0x2d0 ], %g1	! 4001fed0 <_Per_CPU_Information+0x10>
400071c4:	c2 00 61 50 	ld  [ %g1 + 0x150 ], %g1                       
      schedpolicy = api->schedpolicy;                                 
      schedparam  = api->schedparam;                                  
400071c8:	d8 00 60 88 	ld  [ %g1 + 0x88 ], %o4                        
400071cc:	da 00 60 8c 	ld  [ %g1 + 0x8c ], %o5                        
400071d0:	de 00 60 90 	ld  [ %g1 + 0x90 ], %o7                        
400071d4:	fa 00 60 94 	ld  [ %g1 + 0x94 ], %i5                        
400071d8:	c8 00 60 98 	ld  [ %g1 + 0x98 ], %g4                        
400071dc:	c6 00 60 9c 	ld  [ %g1 + 0x9c ], %g3                        
400071e0:	c4 00 60 a0 	ld  [ %g1 + 0xa0 ], %g2                        
   *  attributes structure.                                           
   */                                                                 
  switch ( the_attr->inheritsched ) {                                 
    case PTHREAD_INHERIT_SCHED:                                       
      api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];    
      schedpolicy = api->schedpolicy;                                 
400071e4:	f8 00 60 84 	ld  [ %g1 + 0x84 ], %i4                        
      schedparam  = api->schedparam;                                  
400071e8:	d8 27 bf e4 	st  %o4, [ %fp + -28 ]                         
400071ec:	da 27 bf e8 	st  %o5, [ %fp + -24 ]                         
400071f0:	de 27 bf ec 	st  %o7, [ %fp + -20 ]                         
400071f4:	fa 27 bf f0 	st  %i5, [ %fp + -16 ]                         
400071f8:	c8 27 bf f4 	st  %g4, [ %fp + -12 ]                         
400071fc:	c6 27 bf f8 	st  %g3, [ %fp + -8 ]                          
      break;                                                          
40007200:	10 bf ff b0 	b  400070c0 <pthread_create+0xac>              
40007204:	c4 27 bf fc 	st  %g2, [ %fp + -4 ]                          
  }                                                                   
                                                                      
  /*                                                                  
   *  finish initializing the per API structure                       
   */                                                                 
  api = the_thread->API_Extensions[ THREAD_API_POSIX ];               
40007208:	e0 04 61 50 	ld  [ %l1 + 0x150 ], %l0                       
                                                                      
  api->Attributes  = *the_attr;                                       
4000720c:	92 10 00 19 	mov  %i1, %o1                                  
40007210:	94 10 20 40 	mov  0x40, %o2                                 
40007214:	40 00 25 ed 	call  400109c8 <memcpy>                        
40007218:	90 10 00 10 	mov  %l0, %o0                                  
  api->detachstate = the_attr->detachstate;                           
4000721c:	c2 06 60 3c 	ld  [ %i1 + 0x3c ], %g1                        
  api->schedpolicy = schedpolicy;                                     
  api->schedparam  = schedparam;                                      
40007220:	92 07 bf e4 	add  %fp, -28, %o1                             
40007224:	94 10 20 1c 	mov  0x1c, %o2                                 
   *  finish initializing the per API structure                       
   */                                                                 
  api = the_thread->API_Extensions[ THREAD_API_POSIX ];               
                                                                      
  api->Attributes  = *the_attr;                                       
  api->detachstate = the_attr->detachstate;                           
40007228:	c2 24 20 40 	st  %g1, [ %l0 + 0x40 ]                        
  api->schedpolicy = schedpolicy;                                     
4000722c:	f8 24 20 84 	st  %i4, [ %l0 + 0x84 ]                        
  api->schedparam  = schedparam;                                      
40007230:	40 00 25 e6 	call  400109c8 <memcpy>                        
40007234:	90 04 20 88 	add  %l0, 0x88, %o0                            
                                                                      
  /*                                                                  
   *  POSIX threads are allocated and started in one operation.       
   */                                                                 
  status = _Thread_Start(                                             
40007238:	90 10 00 11 	mov  %l1, %o0                                  
4000723c:	92 10 20 01 	mov  1, %o1                                    
40007240:	94 10 00 1a 	mov  %i2, %o2                                  
40007244:	96 10 00 1b 	mov  %i3, %o3                                  
40007248:	40 00 10 d3 	call  4000b594 <_Thread_Start>                 
4000724c:	98 10 20 00 	clr  %o4                                       
      _RTEMS_Unlock_allocator();                                      
      return EINVAL;                                                  
    }                                                                 
  #endif                                                              
                                                                      
  if ( schedpolicy == SCHED_SPORADIC ) {                              
40007250:	80 a7 20 04 	cmp  %i4, 4                                    
40007254:	02 80 00 07 	be  40007270 <pthread_create+0x25c>            
40007258:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  /*                                                                  
   *  Return the id and indicate we successfully created the thread   
   */                                                                 
  *thread = the_thread->Object.id;                                    
4000725c:	c2 04 60 08 	ld  [ %l1 + 8 ], %g1                           
                                                                      
  _RTEMS_Unlock_allocator();                                          
40007260:	d0 04 a2 30 	ld  [ %l2 + 0x230 ], %o0                       
40007264:	40 00 06 5a 	call  40008bcc <_API_Mutex_Unlock>             
40007268:	c2 26 00 00 	st  %g1, [ %i0 ]                               
4000726c:	30 bf ff 76 	b,a   40007044 <pthread_create+0x30>           
      return EINVAL;                                                  
    }                                                                 
  #endif                                                              
                                                                      
  if ( schedpolicy == SCHED_SPORADIC ) {                              
    _Watchdog_Insert_ticks(                                           
40007270:	40 00 10 f3 	call  4000b63c <_Timespec_To_ticks>            
40007274:	90 04 20 90 	add  %l0, 0x90, %o0                            
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
40007278:	92 04 20 a8 	add  %l0, 0xa8, %o1                            
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
4000727c:	d0 24 20 b4 	st  %o0, [ %l0 + 0xb4 ]                        
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
40007280:	11 10 00 7e 	sethi  %hi(0x4001f800), %o0                    
40007284:	40 00 11 a8 	call  4000b924 <_Watchdog_Insert>              
40007288:	90 12 22 48 	or  %o0, 0x248, %o0	! 4001fa48 <_Watchdog_Ticks_chain>
  }                                                                   
                                                                      
  /*                                                                  
   *  Return the id and indicate we successfully created the thread   
   */                                                                 
  *thread = the_thread->Object.id;                                    
4000728c:	10 bf ff f5 	b  40007260 <pthread_create+0x24c>             
40007290:	c2 04 60 08 	ld  [ %l1 + 8 ], %g1                           
                                                                      

4001be5c <pthread_kill>: int pthread_kill( pthread_t thread, int sig ) {
4001be5c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  POSIX_API_Control  *api;                                            
  Thread_Control     *the_thread;                                     
  Objects_Locations  location;                                        
                                                                      
  if ( !sig )                                                         
4001be60:	80 a6 60 00 	cmp  %i1, 0                                    
4001be64:	02 80 00 31 	be  4001bf28 <pthread_kill+0xcc>               
4001be68:	b8 06 7f ff 	add  %i1, -1, %i4                              
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( !is_valid_signo(sig) )                                         
4001be6c:	80 a7 20 1f 	cmp  %i4, 0x1f                                 
4001be70:	18 80 00 2e 	bgu  4001bf28 <pthread_kill+0xcc>              
4001be74:	90 10 00 18 	mov  %i0, %o0                                  
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  the_thread = _Thread_Get( thread, &location );                      
4001be78:	7f ff b8 20 	call  40009ef8 <_Thread_Get>                   
4001be7c:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
4001be80:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4001be84:	80 a0 60 00 	cmp  %g1, 0                                    
4001be88:	12 80 00 2e 	bne  4001bf40 <pthread_kill+0xe4>              <== NEVER TAKEN
4001be8c:	ba 10 00 08 	mov  %o0, %i5                                  
4001be90:	11 10 00 79 	sethi  %hi(0x4001e400), %o0                    
4001be94:	7f ff af b9 	call  40007d78 <_API_extensions_Add_post_switch>
4001be98:	90 12 20 a8 	or  %o0, 0xa8, %o0	! 4001e4a8 <_POSIX_signals_Post_switch>
                                                                      
      api = the_thread->API_Extensions[ THREAD_API_POSIX ];           
                                                                      
      if ( sig ) {                                                    
                                                                      
        if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {  
4001be9c:	83 2e 60 02 	sll  %i1, 2, %g1                               
4001bea0:	85 2e 60 04 	sll  %i1, 4, %g2                               
4001bea4:	84 20 80 01 	sub  %g2, %g1, %g2                             
4001bea8:	03 10 00 7d 	sethi  %hi(0x4001f400), %g1                    
4001beac:	82 10 60 30 	or  %g1, 0x30, %g1	! 4001f430 <_POSIX_signals_Vectors>
4001beb0:	82 00 40 02 	add  %g1, %g2, %g1                             
4001beb4:	c4 00 60 08 	ld  [ %g1 + 8 ], %g2                           
4001beb8:	80 a0 a0 01 	cmp  %g2, 1                                    
4001bebc:	02 80 00 15 	be  4001bf10 <pthread_kill+0xb4>               
4001bec0:	c2 07 61 50 	ld  [ %i5 + 0x150 ], %g1                       
          return 0;                                                   
        }                                                             
                                                                      
        /* XXX critical section */                                    
                                                                      
        api->signals_pending |= signo_to_mask( sig );                 
4001bec4:	c4 00 60 d4 	ld  [ %g1 + 0xd4 ], %g2                        
4001bec8:	b6 10 20 01 	mov  1, %i3                                    
                                                                      
        (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
4001becc:	90 10 00 1d 	mov  %i5, %o0                                  
4001bed0:	b9 2e c0 1c 	sll  %i3, %i4, %i4                             
4001bed4:	92 10 00 19 	mov  %i1, %o1                                  
          return 0;                                                   
        }                                                             
                                                                      
        /* XXX critical section */                                    
                                                                      
        api->signals_pending |= signo_to_mask( sig );                 
4001bed8:	b8 10 80 1c 	or  %g2, %i4, %i4                              
                                                                      
        (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
4001bedc:	94 10 20 00 	clr  %o2                                       
4001bee0:	7f ff ff 86 	call  4001bcf8 <_POSIX_signals_Unblock_thread> 
4001bee4:	f8 20 60 d4 	st  %i4, [ %g1 + 0xd4 ]                        
                                                                      
        if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
4001bee8:	03 10 00 7c 	sethi  %hi(0x4001f000), %g1                    
4001beec:	82 10 63 d0 	or  %g1, 0x3d0, %g1	! 4001f3d0 <_Per_CPU_Information>
4001bef0:	c4 00 60 08 	ld  [ %g1 + 8 ], %g2                           
4001bef4:	80 a0 a0 00 	cmp  %g2, 0                                    
4001bef8:	02 80 00 06 	be  4001bf10 <pthread_kill+0xb4>               
4001befc:	01 00 00 00 	nop                                            
4001bf00:	c4 00 60 10 	ld  [ %g1 + 0x10 ], %g2                        
4001bf04:	80 a7 40 02 	cmp  %i5, %g2                                  
4001bf08:	02 80 00 06 	be  4001bf20 <pthread_kill+0xc4>               
4001bf0c:	01 00 00 00 	nop                                            
      api = the_thread->API_Extensions[ THREAD_API_POSIX ];           
                                                                      
      if ( sig ) {                                                    
                                                                      
        if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {  
          _Thread_Enable_dispatch();                                  
4001bf10:	7f ff b7 ee 	call  40009ec8 <_Thread_Enable_dispatch>       
4001bf14:	b0 10 20 00 	clr  %i0	! 0 <PROM_START>                      
4001bf18:	81 c7 e0 08 	ret                                            
4001bf1c:	81 e8 00 00 	restore                                        
        api->signals_pending |= signo_to_mask( sig );                 
                                                                      
        (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
                                                                      
        if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
	  _Thread_Dispatch_necessary = true;                                 
4001bf20:	f6 28 60 0c 	stb  %i3, [ %g1 + 0xc ]                        
4001bf24:	30 bf ff fb 	b,a   4001bf10 <pthread_kill+0xb4>             
                                                                      
  if ( !sig )                                                         
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( !is_valid_signo(sig) )                                         
    rtems_set_errno_and_return_minus_one( EINVAL );                   
4001bf28:	7f ff ce 06 	call  4000f740 <__errno>                       
4001bf2c:	b0 10 3f ff 	mov  -1, %i0                                   
4001bf30:	82 10 20 16 	mov  0x16, %g1                                 
4001bf34:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4001bf38:	81 c7 e0 08 	ret                                            
4001bf3c:	81 e8 00 00 	restore                                        
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  rtems_set_errno_and_return_minus_one( ESRCH );                      
4001bf40:	7f ff ce 00 	call  4000f740 <__errno>                       <== NOT EXECUTED
4001bf44:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4001bf48:	82 10 20 03 	mov  3, %g1                                    <== NOT EXECUTED
4001bf4c:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
}                                                                     
4001bf50:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001bf54:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40009054 <pthread_mutex_timedlock>: */ int pthread_mutex_timedlock( pthread_mutex_t *mutex, const struct timespec *abstime ) {
40009054:	9d e3 bf 98 	save  %sp, -104, %sp                           
   *                                                                  
   *  If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,                
   *  POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
   *  then we should not wait.                                        
   */                                                                 
  status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );       
40009058:	90 10 00 19 	mov  %i1, %o0                                  
4000905c:	40 00 00 38 	call  4000913c <_POSIX_Absolute_timeout_to_ticks>
40009060:	92 07 bf fc 	add  %fp, -4, %o1                              
  if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )                
    do_wait = false;                                                  
                                                                      
  lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );   
40009064:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          
   *                                                                  
   *  If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,                
   *  POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
   *  then we should not wait.                                        
   */                                                                 
  status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );       
40009068:	ba 10 00 08 	mov  %o0, %i5                                  
  if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )                
4000906c:	80 a7 60 03 	cmp  %i5, 3                                    
40009070:	02 80 00 0c 	be  400090a0 <pthread_mutex_timedlock+0x4c>    
40009074:	90 10 00 18 	mov  %i0, %o0                                  
    do_wait = false;                                                  
                                                                      
  lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );   
40009078:	7f ff ff bd 	call  40008f6c <_POSIX_Mutex_Lock_support>     
4000907c:	92 10 20 00 	clr  %o1                                       
   *  This service only gives us the option to block.  We used a polling
   *  attempt to lock if the abstime was not in the future.  If we did
   *  not obtain the mutex, then not look at the status immediately,  
   *  make sure the right reason is returned.                         
   */                                                                 
  if ( !do_wait && (lock_status == EBUSY) ) {                         
40009080:	80 a2 20 10 	cmp  %o0, 0x10                                 
40009084:	12 80 00 0a 	bne  400090ac <pthread_mutex_timedlock+0x58>   
40009088:	b0 10 00 08 	mov  %o0, %i0                                  
    if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )                   
4000908c:	80 a7 60 00 	cmp  %i5, 0                                    
40009090:	12 80 00 09 	bne  400090b4 <pthread_mutex_timedlock+0x60>   <== ALWAYS TAKEN
40009094:	ba 07 7f ff 	add  %i5, -1, %i5                              
      return EINVAL;                                                  
40009098:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000909c:	91 e8 20 16 	restore  %g0, 0x16, %o0                        <== NOT EXECUTED
   */                                                                 
  status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );       
  if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )                
    do_wait = false;                                                  
                                                                      
  lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );   
400090a0:	7f ff ff b3 	call  40008f6c <_POSIX_Mutex_Lock_support>     
400090a4:	92 10 20 01 	mov  1, %o1                                    
400090a8:	b0 10 00 08 	mov  %o0, %i0                                  
         status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )                    
      return ETIMEDOUT;                                               
  }                                                                   
                                                                      
  return lock_status;                                                 
}                                                                     
400090ac:	81 c7 e0 08 	ret                                            
400090b0:	81 e8 00 00 	restore                                        
   *  make sure the right reason is returned.                         
   */                                                                 
  if ( !do_wait && (lock_status == EBUSY) ) {                         
    if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )                   
      return EINVAL;                                                  
    if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||               
400090b4:	80 a7 60 01 	cmp  %i5, 1                                    
400090b8:	18 bf ff fd 	bgu  400090ac <pthread_mutex_timedlock+0x58>   <== NEVER TAKEN
400090bc:	01 00 00 00 	nop                                            
         status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )                    
      return ETIMEDOUT;                                               
400090c0:	81 c7 e0 08 	ret                                            
400090c4:	91 e8 20 74 	restore  %g0, 0x74, %o0                        
                                                                      

40006918 <pthread_mutexattr_gettype>: #if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES) int pthread_mutexattr_gettype( const pthread_mutexattr_t *attr, int *type ) {
40006918:	82 10 00 08 	mov  %o0, %g1                                  
  if ( !attr )                                                        
4000691c:	80 a0 60 00 	cmp  %g1, 0                                    
40006920:	02 80 00 06 	be  40006938 <pthread_mutexattr_gettype+0x20>  
40006924:	90 10 20 16 	mov  0x16, %o0                                 
    return EINVAL;                                                    
                                                                      
  if ( !attr->is_initialized )                                        
40006928:	c4 00 40 00 	ld  [ %g1 ], %g2                               
4000692c:	80 a0 a0 00 	cmp  %g2, 0                                    
40006930:	12 80 00 04 	bne  40006940 <pthread_mutexattr_gettype+0x28> 
40006934:	80 a2 60 00 	cmp  %o1, 0                                    
  if ( !type )                                                        
    return EINVAL;                                                    
                                                                      
  *type = attr->type;                                                 
  return 0;                                                           
}                                                                     
40006938:	81 c3 e0 08 	retl                                           
4000693c:	01 00 00 00 	nop                                            
    return EINVAL;                                                    
                                                                      
  if ( !attr->is_initialized )                                        
    return EINVAL;                                                    
                                                                      
  if ( !type )                                                        
40006940:	02 bf ff fe 	be  40006938 <pthread_mutexattr_gettype+0x20>  <== NEVER TAKEN
40006944:	01 00 00 00 	nop                                            
    return EINVAL;                                                    
                                                                      
  *type = attr->type;                                                 
40006948:	c2 00 60 10 	ld  [ %g1 + 0x10 ], %g1                        
  return 0;                                                           
4000694c:	90 10 20 00 	clr  %o0                                       
}                                                                     
40006950:	81 c3 e0 08 	retl                                           
40006954:	c2 22 40 00 	st  %g1, [ %o1 ]                               
                                                                      

40008c20 <pthread_mutexattr_setpshared>: int pthread_mutexattr_setpshared( pthread_mutexattr_t *attr, int pshared ) {
40008c20:	82 10 00 08 	mov  %o0, %g1                                  
  if ( !attr || !attr->is_initialized )                               
40008c24:	80 a0 60 00 	cmp  %g1, 0                                    
40008c28:	02 80 00 06 	be  40008c40 <pthread_mutexattr_setpshared+0x20>
40008c2c:	90 10 20 16 	mov  0x16, %o0                                 
40008c30:	c4 00 40 00 	ld  [ %g1 ], %g2                               
40008c34:	80 a0 a0 00 	cmp  %g2, 0                                    
40008c38:	12 80 00 04 	bne  40008c48 <pthread_mutexattr_setpshared+0x28>
40008c3c:	80 a2 60 01 	cmp  %o1, 1                                    
      return 0;                                                       
                                                                      
    default:                                                          
      return EINVAL;                                                  
  }                                                                   
}                                                                     
40008c40:	81 c3 e0 08 	retl                                           
40008c44:	01 00 00 00 	nop                                            
)                                                                     
{                                                                     
  if ( !attr || !attr->is_initialized )                               
    return EINVAL;                                                    
                                                                      
  switch ( pshared ) {                                                
40008c48:	18 bf ff fe 	bgu  40008c40 <pthread_mutexattr_setpshared+0x20><== NEVER TAKEN
40008c4c:	01 00 00 00 	nop                                            
    case PTHREAD_PROCESS_SHARED:                                      
    case PTHREAD_PROCESS_PRIVATE:                                     
      attr->process_shared = pshared;                                 
40008c50:	d2 20 60 04 	st  %o1, [ %g1 + 4 ]                           
      return 0;                                                       
                                                                      
    default:                                                          
      return EINVAL;                                                  
  }                                                                   
}                                                                     
40008c54:	81 c3 e0 08 	retl                                           
40008c58:	90 10 20 00 	clr  %o0                                       
                                                                      

400069ac <pthread_mutexattr_settype>: #if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES) int pthread_mutexattr_settype( pthread_mutexattr_t *attr, int type ) {
400069ac:	82 10 00 08 	mov  %o0, %g1                                  
  if ( !attr || !attr->is_initialized )                               
400069b0:	80 a0 60 00 	cmp  %g1, 0                                    
400069b4:	02 80 00 06 	be  400069cc <pthread_mutexattr_settype+0x20>  
400069b8:	90 10 20 16 	mov  0x16, %o0                                 
400069bc:	c4 00 40 00 	ld  [ %g1 ], %g2                               
400069c0:	80 a0 a0 00 	cmp  %g2, 0                                    
400069c4:	12 80 00 04 	bne  400069d4 <pthread_mutexattr_settype+0x28> <== ALWAYS TAKEN
400069c8:	80 a2 60 03 	cmp  %o1, 3                                    
      return 0;                                                       
                                                                      
    default:                                                          
      return EINVAL;                                                  
  }                                                                   
}                                                                     
400069cc:	81 c3 e0 08 	retl                                           
400069d0:	01 00 00 00 	nop                                            
)                                                                     
{                                                                     
  if ( !attr || !attr->is_initialized )                               
    return EINVAL;                                                    
                                                                      
  switch ( type ) {                                                   
400069d4:	18 bf ff fe 	bgu  400069cc <pthread_mutexattr_settype+0x20> 
400069d8:	01 00 00 00 	nop                                            
    case PTHREAD_MUTEX_NORMAL:                                        
    case PTHREAD_MUTEX_RECURSIVE:                                     
    case PTHREAD_MUTEX_ERRORCHECK:                                    
    case PTHREAD_MUTEX_DEFAULT:                                       
      attr->type = type;                                              
400069dc:	d2 20 60 10 	st  %o1, [ %g1 + 0x10 ]                        
      return 0;                                                       
                                                                      
    default:                                                          
      return EINVAL;                                                  
  }                                                                   
}                                                                     
400069e0:	81 c3 e0 08 	retl                                           
400069e4:	90 10 20 00 	clr  %o0                                       
                                                                      

40007748 <pthread_once>: int pthread_once( pthread_once_t *once_control, void (*init_routine)(void) ) {
40007748:	9d e3 bf 98 	save  %sp, -104, %sp                           
  if ( !once_control || !init_routine )                               
4000774c:	80 a6 60 00 	cmp  %i1, 0                                    
40007750:	12 80 00 05 	bne  40007764 <pthread_once+0x1c>              
40007754:	80 a6 20 00 	cmp  %i0, 0                                    
    return EINVAL;                                                    
40007758:	82 10 20 16 	mov  0x16, %g1                                 
      (*init_routine)();                                              
    }                                                                 
    rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);         
  }                                                                   
  return 0;                                                           
}                                                                     
4000775c:	81 c7 e0 08 	ret                                            
40007760:	91 e8 00 01 	restore  %g0, %g1, %o0                         
int pthread_once(                                                     
  pthread_once_t  *once_control,                                      
  void           (*init_routine)(void)                                
)                                                                     
{                                                                     
  if ( !once_control || !init_routine )                               
40007764:	22 bf ff fe 	be,a   4000775c <pthread_once+0x14>            
40007768:	82 10 20 16 	mov  0x16, %g1                                 
    return EINVAL;                                                    
                                                                      
  if ( !once_control->init_executed ) {                               
4000776c:	c4 06 20 04 	ld  [ %i0 + 4 ], %g2                           
40007770:	80 a0 a0 00 	cmp  %g2, 0                                    
40007774:	12 bf ff fa 	bne  4000775c <pthread_once+0x14>              
40007778:	82 10 20 00 	clr  %g1                                       
    rtems_mode saveMode;                                              
    rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); 
4000777c:	90 10 21 00 	mov  0x100, %o0                                
40007780:	92 10 21 00 	mov  0x100, %o1                                
40007784:	40 00 03 21 	call  40008408 <rtems_task_mode>               
40007788:	94 07 bf fc 	add  %fp, -4, %o2                              
    if ( !once_control->init_executed ) {                             
4000778c:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
40007790:	80 a0 60 00 	cmp  %g1, 0                                    
40007794:	02 80 00 09 	be  400077b8 <pthread_once+0x70>               <== ALWAYS TAKEN
40007798:	82 10 20 01 	mov  1, %g1                                    
      once_control->is_initialized = true;                            
      once_control->init_executed = true;                             
      (*init_routine)();                                              
    }                                                                 
    rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);         
4000779c:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          <== NOT EXECUTED
400077a0:	92 10 21 00 	mov  0x100, %o1                                
400077a4:	40 00 03 19 	call  40008408 <rtems_task_mode>               
400077a8:	94 07 bf fc 	add  %fp, -4, %o2                              
  }                                                                   
  return 0;                                                           
400077ac:	82 10 20 00 	clr  %g1                                       
}                                                                     
400077b0:	81 c7 e0 08 	ret                                            
400077b4:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      
  if ( !once_control->init_executed ) {                               
    rtems_mode saveMode;                                              
    rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); 
    if ( !once_control->init_executed ) {                             
      once_control->is_initialized = true;                            
400077b8:	c2 26 00 00 	st  %g1, [ %i0 ]                               
      once_control->init_executed = true;                             
      (*init_routine)();                                              
400077bc:	9f c6 40 00 	call  %i1                                      
400077c0:	c2 26 20 04 	st  %g1, [ %i0 + 4 ]                           
    }                                                                 
    rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);         
400077c4:	10 bf ff f7 	b  400077a0 <pthread_once+0x58>                
400077c8:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
                                                                      

40007990 <pthread_rwlock_init>: int pthread_rwlock_init( pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr ) {
40007990:	9d e3 bf 90 	save  %sp, -112, %sp                           
  const pthread_rwlockattr_t  *the_attr;                              
                                                                      
  /*                                                                  
   *  Error check parameters                                          
   */                                                                 
  if ( !rwlock )                                                      
40007994:	80 a6 20 00 	cmp  %i0, 0                                    
40007998:	02 80 00 08 	be  400079b8 <pthread_rwlock_init+0x28>        
4000799c:	80 a6 60 00 	cmp  %i1, 0                                    
    return EINVAL;                                                    
                                                                      
  /*                                                                  
   * If the user passed in NULL, use the default attributes           
   */                                                                 
  if ( attr ) {                                                       
400079a0:	02 80 00 23 	be  40007a2c <pthread_rwlock_init+0x9c>        
400079a4:	90 07 bf f8 	add  %fp, -8, %o0                              
  }                                                                   
                                                                      
  /*                                                                  
   * Now start error checking the attributes that we are going to use 
   */                                                                 
  if ( !the_attr->is_initialized )                                    
400079a8:	c2 06 40 00 	ld  [ %i1 ], %g1                               
400079ac:	80 a0 60 00 	cmp  %g1, 0                                    
400079b0:	32 80 00 04 	bne,a   400079c0 <pthread_rwlock_init+0x30>    <== ALWAYS TAKEN
400079b4:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
                                                                      
  *rwlock = the_rwlock->Object.id;                                    
                                                                      
  _Thread_Enable_dispatch();                                          
  return 0;                                                           
}                                                                     
400079b8:	81 c7 e0 08 	ret                                            
400079bc:	91 e8 20 16 	restore  %g0, 0x16, %o0                        
   * Now start error checking the attributes that we are going to use 
   */                                                                 
  if ( !the_attr->is_initialized )                                    
    return EINVAL;                                                    
                                                                      
  switch ( the_attr->process_shared ) {                               
400079c0:	80 a0 60 00 	cmp  %g1, 0                                    
400079c4:	12 bf ff fd 	bne  400079b8 <pthread_rwlock_init+0x28>       <== NEVER TAKEN
400079c8:	03 10 00 8e 	sethi  %hi(0x40023800), %g1                    
   *                                                                  
   * This rountine increments the thread dispatch level               
   */                                                                 
  RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
  {                                                                   
    uint32_t level = _Thread_Dispatch_disable_level;                  
400079cc:	c4 00 60 c0 	ld  [ %g1 + 0xc0 ], %g2	! 400238c0 <_Thread_Dispatch_disable_level>
 */                                                                   
RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes(         
  CORE_RWLock_Attributes *the_attributes                              
)                                                                     
{                                                                     
  the_attributes->XXX = 0;                                            
400079d0:	c0 27 bf f4 	clr  [ %fp + -12 ]                             
                                                                      
    ++level;                                                          
400079d4:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
400079d8:	c4 20 60 c0 	st  %g2, [ %g1 + 0xc0 ]                        
 *  This function allocates a RWLock control block from               
 *  the inactive chain of free RWLock control blocks.                 
 */                                                                   
RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Allocate( void )
{                                                                     
  return (POSIX_RWLock_Control *)                                     
400079dc:	39 10 00 8e 	sethi  %hi(0x40023800), %i4                    
400079e0:	40 00 0b 14 	call  4000a630 <_Objects_Allocate>             
400079e4:	90 17 22 c4 	or  %i4, 0x2c4, %o0	! 40023ac4 <_POSIX_RWLock_Information>
   */                                                                 
  _Thread_Disable_dispatch();             /* prevents deletion */     
                                                                      
  the_rwlock = _POSIX_RWLock_Allocate();                              
                                                                      
  if ( !the_rwlock ) {                                                
400079e8:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400079ec:	02 80 00 14 	be  40007a3c <pthread_rwlock_init+0xac>        
400079f0:	90 07 60 10 	add  %i5, 0x10, %o0                            
    _Thread_Enable_dispatch();                                        
    return EAGAIN;                                                    
  }                                                                   
                                                                      
  _CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes );    
400079f4:	40 00 09 5f 	call  40009f70 <_CORE_RWLock_Initialize>       
400079f8:	92 07 bf f4 	add  %fp, -12, %o1                             
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  uint32_t             name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
400079fc:	c4 17 60 0a 	lduh  [ %i5 + 0xa ], %g2                       
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
40007a00:	b8 17 22 c4 	or  %i4, 0x2c4, %i4                            
40007a04:	c6 07 20 1c 	ld  [ %i4 + 0x1c ], %g3                        
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  uint32_t             name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
40007a08:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
40007a0c:	85 28 a0 02 	sll  %g2, 2, %g2                               
40007a10:	fa 20 c0 02 	st  %i5, [ %g3 + %g2 ]                         
    _Objects_Get_index( the_object->id ),                             
    the_object                                                        
  );                                                                  
                                                                      
  /* ASSERT: information->is_string == false */                       
  the_object->name.name_u32 = name;                                   
40007a14:	c0 27 60 0c 	clr  [ %i5 + 0xc ]                             
    &_POSIX_RWLock_Information,                                       
    &the_rwlock->Object,                                              
    0                                                                 
  );                                                                  
                                                                      
  *rwlock = the_rwlock->Object.id;                                    
40007a18:	c2 26 00 00 	st  %g1, [ %i0 ]                               
                                                                      
  _Thread_Enable_dispatch();                                          
40007a1c:	40 00 10 51 	call  4000bb60 <_Thread_Enable_dispatch>       
40007a20:	b0 10 20 00 	clr  %i0                                       
40007a24:	81 c7 e0 08 	ret                                            
40007a28:	81 e8 00 00 	restore                                        
   * If the user passed in NULL, use the default attributes           
   */                                                                 
  if ( attr ) {                                                       
    the_attr = attr;                                                  
  } else {                                                            
    (void) pthread_rwlockattr_init( &default_attr );                  
40007a2c:	40 00 01 b6 	call  40008104 <pthread_rwlockattr_init>       
40007a30:	b2 07 bf f8 	add  %fp, -8, %i1                              
  }                                                                   
                                                                      
  /*                                                                  
   * Now start error checking the attributes that we are going to use 
   */                                                                 
  if ( !the_attr->is_initialized )                                    
40007a34:	10 bf ff de 	b  400079ac <pthread_rwlock_init+0x1c>         
40007a38:	c2 06 40 00 	ld  [ %i1 ], %g1                               
  _Thread_Disable_dispatch();             /* prevents deletion */     
                                                                      
  the_rwlock = _POSIX_RWLock_Allocate();                              
                                                                      
  if ( !the_rwlock ) {                                                
    _Thread_Enable_dispatch();                                        
40007a3c:	40 00 10 49 	call  4000bb60 <_Thread_Enable_dispatch>       
40007a40:	b0 10 20 0b 	mov  0xb, %i0                                  
40007a44:	81 c7 e0 08 	ret                                            
40007a48:	81 e8 00 00 	restore                                        
                                                                      

40007fa0 <pthread_rwlock_timedrdlock>: int pthread_rwlock_timedrdlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) {
40007fa0:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Objects_Locations                            location;              
  Watchdog_Interval                            ticks;                 
  bool                                         do_wait = true;        
  POSIX_Absolute_timeout_conversion_results_t  status;                
                                                                      
  if ( !rwlock )                                                      
40007fa4:	80 a6 20 00 	cmp  %i0, 0                                    
40007fa8:	02 80 00 25 	be  4000803c <pthread_rwlock_timedrdlock+0x9c> 
40007fac:	92 07 bf fc 	add  %fp, -4, %o1                              
   *                                                                  
   *  If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,                
   *  POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
   *  then we should not wait.                                        
   */                                                                 
  status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );       
40007fb0:	40 00 1a 80 	call  4000e9b0 <_POSIX_Absolute_timeout_to_ticks>
40007fb4:	90 10 00 19 	mov  %i1, %o0                                  
40007fb8:	d2 06 00 00 	ld  [ %i0 ], %o1                               
40007fbc:	ba 10 00 08 	mov  %o0, %i5                                  
40007fc0:	94 07 bf f8 	add  %fp, -8, %o2                              
40007fc4:	11 10 00 6a 	sethi  %hi(0x4001a800), %o0                    
40007fc8:	40 00 0b b8 	call  4000aea8 <_Objects_Get>                  
40007fcc:	90 12 21 a4 	or  %o0, 0x1a4, %o0	! 4001a9a4 <_POSIX_RWLock_Information>
  if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )                
    do_wait = false;                                                  
                                                                      
  the_rwlock = _POSIX_RWLock_Get( rwlock, &location );                
  switch ( location ) {                                               
40007fd0:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
40007fd4:	80 a0 60 00 	cmp  %g1, 0                                    
40007fd8:	32 80 00 1a 	bne,a   40008040 <pthread_rwlock_timedrdlock+0xa0>
40007fdc:	b0 10 20 16 	mov  0x16, %i0                                 
                                                                      
    case OBJECTS_LOCAL:                                               
                                                                      
      _CORE_RWLock_Obtain_for_reading(                                
40007fe0:	d2 06 00 00 	ld  [ %i0 ], %o1                               
40007fe4:	d6 07 bf fc 	ld  [ %fp + -4 ], %o3                          
   *  If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,                
   *  POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
   *  then we should not wait.                                        
   */                                                                 
  status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );       
  if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )                
40007fe8:	82 1f 60 03 	xor  %i5, 3, %g1                               
  the_rwlock = _POSIX_RWLock_Get( rwlock, &location );                
  switch ( location ) {                                               
                                                                      
    case OBJECTS_LOCAL:                                               
                                                                      
      _CORE_RWLock_Obtain_for_reading(                                
40007fec:	90 02 20 10 	add  %o0, 0x10, %o0                            
40007ff0:	80 a0 00 01 	cmp  %g0, %g1                                  
40007ff4:	98 10 20 00 	clr  %o4                                       
40007ff8:	b8 60 3f ff 	subx  %g0, -1, %i4                             
40007ffc:	40 00 07 f6 	call  40009fd4 <_CORE_RWLock_Obtain_for_reading>
40008000:	94 10 00 1c 	mov  %i4, %o2                                  
	do_wait,                                                             
	ticks,                                                               
	NULL                                                                 
      );                                                              
                                                                      
      _Thread_Enable_dispatch();                                      
40008004:	40 00 0f 60 	call  4000bd84 <_Thread_Enable_dispatch>       
40008008:	01 00 00 00 	nop                                            
      if ( !do_wait ) {                                               
        if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
4000800c:	03 10 00 6b 	sethi  %hi(0x4001ac00), %g1                    
40008010:	c2 00 61 00 	ld  [ %g1 + 0x100 ], %g1	! 4001ad00 <_Per_CPU_Information+0x10>
	ticks,                                                               
	NULL                                                                 
      );                                                              
                                                                      
      _Thread_Enable_dispatch();                                      
      if ( !do_wait ) {                                               
40008014:	80 a7 20 00 	cmp  %i4, 0                                    
40008018:	12 80 00 05 	bne  4000802c <pthread_rwlock_timedrdlock+0x8c>
4000801c:	d0 00 60 34 	ld  [ %g1 + 0x34 ], %o0                        
        if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
40008020:	80 a2 20 02 	cmp  %o0, 2                                    
40008024:	02 80 00 09 	be  40008048 <pthread_rwlock_timedrdlock+0xa8> 
40008028:	80 a7 60 00 	cmp  %i5, 0                                    
	       status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )                     
	    return ETIMEDOUT;                                                
        }                                                             
      }                                                               
                                                                      
      return _POSIX_RWLock_Translate_core_RWLock_return_code(         
4000802c:	40 00 00 3f 	call  40008128 <_POSIX_RWLock_Translate_core_RWLock_return_code>
40008030:	01 00 00 00 	nop                                            
40008034:	81 c7 e0 08 	ret                                            
40008038:	91 e8 00 08 	restore  %g0, %o0, %o0                         
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return EINVAL;                                                      
4000803c:	b0 10 20 16 	mov  0x16, %i0                                 
}                                                                     
40008040:	81 c7 e0 08 	ret                                            
40008044:	81 e8 00 00 	restore                                        
      );                                                              
                                                                      
      _Thread_Enable_dispatch();                                      
      if ( !do_wait ) {                                               
        if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
	  if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )                    
40008048:	22 bf ff fe 	be,a   40008040 <pthread_rwlock_timedrdlock+0xa0><== NEVER TAKEN
4000804c:	b0 10 20 16 	mov  0x16, %i0                                 <== NOT EXECUTED
	    return EINVAL;                                                   
	  if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||                
40008050:	ba 07 7f ff 	add  %i5, -1, %i5                              
40008054:	80 a7 60 01 	cmp  %i5, 1                                    
40008058:	18 bf ff f5 	bgu  4000802c <pthread_rwlock_timedrdlock+0x8c><== NEVER TAKEN
4000805c:	b0 10 20 74 	mov  0x74, %i0                                 
40008060:	30 bf ff f8 	b,a   40008040 <pthread_rwlock_timedrdlock+0xa0>
                                                                      

40008064 <pthread_rwlock_timedwrlock>: int pthread_rwlock_timedwrlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) {
40008064:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Objects_Locations                            location;              
  Watchdog_Interval                            ticks;                 
  bool                                         do_wait = true;        
  POSIX_Absolute_timeout_conversion_results_t  status;                
                                                                      
  if ( !rwlock )                                                      
40008068:	80 a6 20 00 	cmp  %i0, 0                                    
4000806c:	02 80 00 25 	be  40008100 <pthread_rwlock_timedwrlock+0x9c> 
40008070:	92 07 bf fc 	add  %fp, -4, %o1                              
   *                                                                  
   *  If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,                
   *  POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
   *  then we should not wait.                                        
   */                                                                 
  status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );       
40008074:	40 00 1a 4f 	call  4000e9b0 <_POSIX_Absolute_timeout_to_ticks>
40008078:	90 10 00 19 	mov  %i1, %o0                                  
4000807c:	d2 06 00 00 	ld  [ %i0 ], %o1                               
40008080:	ba 10 00 08 	mov  %o0, %i5                                  
40008084:	94 07 bf f8 	add  %fp, -8, %o2                              
40008088:	11 10 00 6a 	sethi  %hi(0x4001a800), %o0                    
4000808c:	40 00 0b 87 	call  4000aea8 <_Objects_Get>                  
40008090:	90 12 21 a4 	or  %o0, 0x1a4, %o0	! 4001a9a4 <_POSIX_RWLock_Information>
  if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )                
    do_wait = false;                                                  
                                                                      
  the_rwlock = _POSIX_RWLock_Get( rwlock, &location );                
  switch ( location ) {                                               
40008094:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
40008098:	80 a0 60 00 	cmp  %g1, 0                                    
4000809c:	32 80 00 1a 	bne,a   40008104 <pthread_rwlock_timedwrlock+0xa0>
400080a0:	b0 10 20 16 	mov  0x16, %i0                                 
                                                                      
    case OBJECTS_LOCAL:                                               
                                                                      
      _CORE_RWLock_Obtain_for_writing(                                
400080a4:	d2 06 00 00 	ld  [ %i0 ], %o1                               
400080a8:	d6 07 bf fc 	ld  [ %fp + -4 ], %o3                          
   *  If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,                
   *  POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
   *  then we should not wait.                                        
   */                                                                 
  status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );       
  if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )                
400080ac:	82 1f 60 03 	xor  %i5, 3, %g1                               
  the_rwlock = _POSIX_RWLock_Get( rwlock, &location );                
  switch ( location ) {                                               
                                                                      
    case OBJECTS_LOCAL:                                               
                                                                      
      _CORE_RWLock_Obtain_for_writing(                                
400080b0:	90 02 20 10 	add  %o0, 0x10, %o0                            
400080b4:	80 a0 00 01 	cmp  %g0, %g1                                  
400080b8:	98 10 20 00 	clr  %o4                                       
400080bc:	b8 60 3f ff 	subx  %g0, -1, %i4                             
400080c0:	40 00 07 fa 	call  4000a0a8 <_CORE_RWLock_Obtain_for_writing>
400080c4:	94 10 00 1c 	mov  %i4, %o2                                  
	do_wait,                                                             
	ticks,                                                               
	NULL                                                                 
      );                                                              
                                                                      
      _Thread_Enable_dispatch();                                      
400080c8:	40 00 0f 2f 	call  4000bd84 <_Thread_Enable_dispatch>       
400080cc:	01 00 00 00 	nop                                            
      if ( !do_wait &&                                                
           (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
400080d0:	03 10 00 6b 	sethi  %hi(0x4001ac00), %g1                    
400080d4:	c2 00 61 00 	ld  [ %g1 + 0x100 ], %g1	! 4001ad00 <_Per_CPU_Information+0x10>
	ticks,                                                               
	NULL                                                                 
      );                                                              
                                                                      
      _Thread_Enable_dispatch();                                      
      if ( !do_wait &&                                                
400080d8:	80 a7 20 00 	cmp  %i4, 0                                    
400080dc:	12 80 00 05 	bne  400080f0 <pthread_rwlock_timedwrlock+0x8c>
400080e0:	d0 00 60 34 	ld  [ %g1 + 0x34 ], %o0                        
400080e4:	80 a2 20 02 	cmp  %o0, 2                                    
400080e8:	02 80 00 09 	be  4000810c <pthread_rwlock_timedwrlock+0xa8> 
400080ec:	80 a7 60 00 	cmp  %i5, 0                                    
	if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||                  
	     status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )                       
	  return ETIMEDOUT;                                                  
      }                                                               
                                                                      
      return _POSIX_RWLock_Translate_core_RWLock_return_code(         
400080f0:	40 00 00 0e 	call  40008128 <_POSIX_RWLock_Translate_core_RWLock_return_code>
400080f4:	01 00 00 00 	nop                                            
400080f8:	81 c7 e0 08 	ret                                            
400080fc:	91 e8 00 08 	restore  %g0, %o0, %o0                         
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return EINVAL;                                                      
40008100:	b0 10 20 16 	mov  0x16, %i0                                 
}                                                                     
40008104:	81 c7 e0 08 	ret                                            
40008108:	81 e8 00 00 	restore                                        
      );                                                              
                                                                      
      _Thread_Enable_dispatch();                                      
      if ( !do_wait &&                                                
           (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
	if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )                      
4000810c:	22 bf ff fe 	be,a   40008104 <pthread_rwlock_timedwrlock+0xa0><== NEVER TAKEN
40008110:	b0 10 20 16 	mov  0x16, %i0                                 <== NOT EXECUTED
	  return EINVAL;                                                     
	if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||                  
40008114:	ba 07 7f ff 	add  %i5, -1, %i5                              
40008118:	80 a7 60 01 	cmp  %i5, 1                                    
4000811c:	18 bf ff f5 	bgu  400080f0 <pthread_rwlock_timedwrlock+0x8c><== NEVER TAKEN
40008120:	b0 10 20 74 	mov  0x74, %i0                                 
40008124:	30 bf ff f8 	b,a   40008104 <pthread_rwlock_timedwrlock+0xa0>
                                                                      

40008940 <pthread_rwlockattr_setpshared>: int pthread_rwlockattr_setpshared( pthread_rwlockattr_t *attr, int pshared ) {
40008940:	82 10 00 08 	mov  %o0, %g1                                  
  if ( !attr )                                                        
40008944:	80 a0 60 00 	cmp  %g1, 0                                    
40008948:	02 80 00 06 	be  40008960 <pthread_rwlockattr_setpshared+0x20>
4000894c:	90 10 20 16 	mov  0x16, %o0                                 
    return EINVAL;                                                    
                                                                      
  if ( !attr->is_initialized )                                        
40008950:	c4 00 40 00 	ld  [ %g1 ], %g2                               
40008954:	80 a0 a0 00 	cmp  %g2, 0                                    
40008958:	12 80 00 04 	bne  40008968 <pthread_rwlockattr_setpshared+0x28>
4000895c:	80 a2 60 01 	cmp  %o1, 1                                    
      return 0;                                                       
                                                                      
    default:                                                          
      return EINVAL;                                                  
  }                                                                   
}                                                                     
40008960:	81 c3 e0 08 	retl                                           
40008964:	01 00 00 00 	nop                                            
    return EINVAL;                                                    
                                                                      
  if ( !attr->is_initialized )                                        
    return EINVAL;                                                    
                                                                      
  switch ( pshared ) {                                                
40008968:	18 bf ff fe 	bgu  40008960 <pthread_rwlockattr_setpshared+0x20><== NEVER TAKEN
4000896c:	01 00 00 00 	nop                                            
    case PTHREAD_PROCESS_SHARED:                                      
    case PTHREAD_PROCESS_PRIVATE:                                     
      attr->process_shared = pshared;                                 
40008970:	d2 20 60 04 	st  %o1, [ %g1 + 4 ]                           
      return 0;                                                       
                                                                      
    default:                                                          
      return EINVAL;                                                  
  }                                                                   
}                                                                     
40008974:	81 c3 e0 08 	retl                                           
40008978:	90 10 20 00 	clr  %o0                                       
                                                                      

40009a00 <pthread_setschedparam>: int pthread_setschedparam( pthread_t thread, int policy, struct sched_param *param ) {
40009a00:	9d e3 bf 90 	save  %sp, -112, %sp                           
  int                                  rc;                            
                                                                      
  /*                                                                  
   *  Check all the parameters                                        
   */                                                                 
  if ( !param )                                                       
40009a04:	80 a6 a0 00 	cmp  %i2, 0                                    
40009a08:	02 80 00 0a 	be  40009a30 <pthread_setschedparam+0x30>      
40009a0c:	ba 10 20 16 	mov  0x16, %i5                                 
    return EINVAL;                                                    
                                                                      
  rc = _POSIX_Thread_Translate_sched_param(                           
40009a10:	90 10 00 19 	mov  %i1, %o0                                  
40009a14:	92 10 00 1a 	mov  %i2, %o1                                  
40009a18:	94 07 bf f4 	add  %fp, -12, %o2                             
40009a1c:	40 00 18 52 	call  4000fb64 <_POSIX_Thread_Translate_sched_param>
40009a20:	96 07 bf f8 	add  %fp, -8, %o3                              
    policy,                                                           
    param,                                                            
    &budget_algorithm,                                                
    &budget_callout                                                   
  );                                                                  
  if ( rc )                                                           
40009a24:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40009a28:	02 80 00 05 	be  40009a3c <pthread_setschedparam+0x3c>      
40009a2c:	90 10 00 18 	mov  %i0, %o0                                  
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return ESRCH;                                                       
}                                                                     
40009a30:	b0 10 00 1d 	mov  %i5, %i0                                  
40009a34:	81 c7 e0 08 	ret                                            
40009a38:	81 e8 00 00 	restore                                        
    return rc;                                                        
                                                                      
  /*                                                                  
   *  Actually change the scheduling policy and parameters            
   */                                                                 
  the_thread = _Thread_Get( thread, &location );                      
40009a3c:	40 00 0c b3 	call  4000cd08 <_Thread_Get>                   
40009a40:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
40009a44:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40009a48:	80 a0 60 00 	cmp  %g1, 0                                    
40009a4c:	12 80 00 2b 	bne  40009af8 <pthread_setschedparam+0xf8>     
40009a50:	b6 10 00 08 	mov  %o0, %i3                                  
                                                                      
    case OBJECTS_LOCAL:                                               
      api = the_thread->API_Extensions[ THREAD_API_POSIX ];           
40009a54:	f8 02 21 50 	ld  [ %o0 + 0x150 ], %i4                       
                                                                      
      if ( api->schedpolicy == SCHED_SPORADIC )                       
40009a58:	c2 07 20 84 	ld  [ %i4 + 0x84 ], %g1                        
40009a5c:	80 a0 60 04 	cmp  %g1, 4                                    
40009a60:	02 80 00 35 	be  40009b34 <pthread_setschedparam+0x134>     
40009a64:	01 00 00 00 	nop                                            
        (void) _Watchdog_Remove( &api->Sporadic_timer );              
                                                                      
      api->schedpolicy = policy;                                      
      api->schedparam  = *param;                                      
40009a68:	c2 06 80 00 	ld  [ %i2 ], %g1                               
      the_thread->budget_algorithm = budget_algorithm;                
      the_thread->budget_callout   = budget_callout;                  
                                                                      
      switch ( api->schedpolicy ) {                                   
40009a6c:	80 a6 60 00 	cmp  %i1, 0                                    
                                                                      
      if ( api->schedpolicy == SCHED_SPORADIC )                       
        (void) _Watchdog_Remove( &api->Sporadic_timer );              
                                                                      
      api->schedpolicy = policy;                                      
      api->schedparam  = *param;                                      
40009a70:	c2 27 20 88 	st  %g1, [ %i4 + 0x88 ]                        
40009a74:	c4 06 a0 04 	ld  [ %i2 + 4 ], %g2                           
40009a78:	c4 27 20 8c 	st  %g2, [ %i4 + 0x8c ]                        
40009a7c:	c4 06 a0 08 	ld  [ %i2 + 8 ], %g2                           
      api = the_thread->API_Extensions[ THREAD_API_POSIX ];           
                                                                      
      if ( api->schedpolicy == SCHED_SPORADIC )                       
        (void) _Watchdog_Remove( &api->Sporadic_timer );              
                                                                      
      api->schedpolicy = policy;                                      
40009a80:	f2 27 20 84 	st  %i1, [ %i4 + 0x84 ]                        
      api->schedparam  = *param;                                      
40009a84:	c4 27 20 90 	st  %g2, [ %i4 + 0x90 ]                        
40009a88:	c4 06 a0 0c 	ld  [ %i2 + 0xc ], %g2                         
40009a8c:	c4 27 20 94 	st  %g2, [ %i4 + 0x94 ]                        
40009a90:	c4 06 a0 10 	ld  [ %i2 + 0x10 ], %g2                        
40009a94:	c4 27 20 98 	st  %g2, [ %i4 + 0x98 ]                        
40009a98:	c4 06 a0 14 	ld  [ %i2 + 0x14 ], %g2                        
40009a9c:	c4 27 20 9c 	st  %g2, [ %i4 + 0x9c ]                        
40009aa0:	c4 06 a0 18 	ld  [ %i2 + 0x18 ], %g2                        
40009aa4:	c4 27 20 a0 	st  %g2, [ %i4 + 0xa0 ]                        
      the_thread->budget_algorithm = budget_algorithm;                
40009aa8:	c4 07 bf f4 	ld  [ %fp + -12 ], %g2                         
40009aac:	c4 26 e0 78 	st  %g2, [ %i3 + 0x78 ]                        
      the_thread->budget_callout   = budget_callout;                  
40009ab0:	c4 07 bf f8 	ld  [ %fp + -8 ], %g2                          
                                                                      
      switch ( api->schedpolicy ) {                                   
40009ab4:	06 80 00 0e 	bl  40009aec <pthread_setschedparam+0xec>      <== NEVER TAKEN
40009ab8:	c4 26 e0 7c 	st  %g2, [ %i3 + 0x7c ]                        
40009abc:	80 a6 60 02 	cmp  %i1, 2                                    
40009ac0:	04 80 00 11 	ble  40009b04 <pthread_setschedparam+0x104>    
40009ac4:	07 10 00 6d 	sethi  %hi(0x4001b400), %g3                    
40009ac8:	80 a6 60 04 	cmp  %i1, 4                                    
40009acc:	12 80 00 08 	bne  40009aec <pthread_setschedparam+0xec>     <== NEVER TAKEN
40009ad0:	01 00 00 00 	nop                                            
             true                                                     
          );                                                          
          break;                                                      
                                                                      
        case SCHED_SPORADIC:                                          
          api->ss_high_priority = api->schedparam.sched_priority;     
40009ad4:	c2 27 20 a4 	st  %g1, [ %i4 + 0xa4 ]                        
          _Watchdog_Remove( &api->Sporadic_timer );                   
40009ad8:	40 00 10 b0 	call  4000dd98 <_Watchdog_Remove>              
40009adc:	90 07 20 a8 	add  %i4, 0xa8, %o0                            
          _POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );        
40009ae0:	90 10 20 00 	clr  %o0                                       
40009ae4:	7f ff ff 7b 	call  400098d0 <_POSIX_Threads_Sporadic_budget_TSR>
40009ae8:	92 10 00 1b 	mov  %i3, %o1                                  
          break;                                                      
      }                                                               
                                                                      
      _Thread_Enable_dispatch();                                      
40009aec:	40 00 0c 7b 	call  4000ccd8 <_Thread_Enable_dispatch>       
40009af0:	b0 10 00 1d 	mov  %i5, %i0                                  
40009af4:	30 bf ff d0 	b,a   40009a34 <pthread_setschedparam+0x34>    
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return ESRCH;                                                       
40009af8:	ba 10 20 03 	mov  3, %i5                                    
}                                                                     
40009afc:	81 c7 e0 08 	ret                                            
40009b00:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
40009b04:	d2 08 e0 5c 	ldub  [ %g3 + 0x5c ], %o1                      
                                                                      
      switch ( api->schedpolicy ) {                                   
        case SCHED_OTHER:                                             
        case SCHED_FIFO:                                              
        case SCHED_RR:                                                
          the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;  
40009b08:	05 10 00 6f 	sethi  %hi(0x4001bc00), %g2                    
40009b0c:	c4 00 a3 d0 	ld  [ %g2 + 0x3d0 ], %g2	! 4001bfd0 <_Thread_Ticks_per_timeslice>
40009b10:	92 22 40 01 	sub  %o1, %g1, %o1                             
                                                                      
          the_thread->real_priority =                                 
            _POSIX_Priority_To_core( api->schedparam.sched_priority );
                                                                      
          _Thread_Change_priority(                                    
40009b14:	90 10 00 1b 	mov  %i3, %o0                                  
40009b18:	94 10 20 01 	mov  1, %o2                                    
                                                                      
      switch ( api->schedpolicy ) {                                   
        case SCHED_OTHER:                                             
        case SCHED_FIFO:                                              
        case SCHED_RR:                                                
          the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;  
40009b1c:	c4 26 e0 74 	st  %g2, [ %i3 + 0x74 ]                        
                                                                      
          the_thread->real_priority =                                 
            _POSIX_Priority_To_core( api->schedparam.sched_priority );
                                                                      
          _Thread_Change_priority(                                    
40009b20:	40 00 0b 34 	call  4000c7f0 <_Thread_Change_priority>       
40009b24:	d2 26 e0 18 	st  %o1, [ %i3 + 0x18 ]                        
          _Watchdog_Remove( &api->Sporadic_timer );                   
          _POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );        
          break;                                                      
      }                                                               
                                                                      
      _Thread_Enable_dispatch();                                      
40009b28:	40 00 0c 6c 	call  4000ccd8 <_Thread_Enable_dispatch>       
40009b2c:	b0 10 00 1d 	mov  %i5, %i0                                  
40009b30:	30 bf ff c1 	b,a   40009a34 <pthread_setschedparam+0x34>    
                                                                      
    case OBJECTS_LOCAL:                                               
      api = the_thread->API_Extensions[ THREAD_API_POSIX ];           
                                                                      
      if ( api->schedpolicy == SCHED_SPORADIC )                       
        (void) _Watchdog_Remove( &api->Sporadic_timer );              
40009b34:	40 00 10 99 	call  4000dd98 <_Watchdog_Remove>              
40009b38:	90 07 20 a8 	add  %i4, 0xa8, %o0                            
                                                                      
      api->schedpolicy = policy;                                      
      api->schedparam  = *param;                                      
40009b3c:	10 bf ff cc 	b  40009a6c <pthread_setschedparam+0x6c>       
40009b40:	c2 06 80 00 	ld  [ %i2 ], %g1                               
                                                                      

40007398 <pthread_testcancel>: /* * 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183 */ void pthread_testcancel( void ) {
40007398:	9d e3 bf a0 	save  %sp, -96, %sp                            
   *  Don't even think about deleting a resource from an ISR.         
   *  Besides this request is supposed to be for _Thread_Executing    
   *  and the ISR context is not a thread.                            
   */                                                                 
                                                                      
  if ( _ISR_Is_in_progress() )                                        
4000739c:	3b 10 00 62 	sethi  %hi(0x40018800), %i5                    
400073a0:	ba 17 63 20 	or  %i5, 0x320, %i5	! 40018b20 <_Per_CPU_Information>
400073a4:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
400073a8:	80 a0 60 00 	cmp  %g1, 0                                    
400073ac:	12 80 00 16 	bne  40007404 <pthread_testcancel+0x6c>        <== NEVER TAKEN
400073b0:	03 10 00 61 	sethi  %hi(0x40018400), %g1                    
    return;                                                           
                                                                      
  thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
400073b4:	c4 07 60 10 	ld  [ %i5 + 0x10 ], %g2                        
   *                                                                  
   * This rountine increments the thread dispatch level               
   */                                                                 
  RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
  {                                                                   
    uint32_t level = _Thread_Dispatch_disable_level;                  
400073b8:	c6 00 62 10 	ld  [ %g1 + 0x210 ], %g3                       
400073bc:	c4 00 a1 50 	ld  [ %g2 + 0x150 ], %g2                       
                                                                      
    ++level;                                                          
400073c0:	86 00 e0 01 	inc  %g3                                       
    _Thread_Dispatch_disable_level = level;                           
400073c4:	c6 20 62 10 	st  %g3, [ %g1 + 0x210 ]                       
                                                                      
  _Thread_Disable_dispatch();                                         
    if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
400073c8:	c2 00 a0 d8 	ld  [ %g2 + 0xd8 ], %g1                        
400073cc:	80 a0 60 00 	cmp  %g1, 0                                    
400073d0:	12 80 00 0b 	bne  400073fc <pthread_testcancel+0x64>        <== NEVER TAKEN
400073d4:	01 00 00 00 	nop                                            
400073d8:	c2 00 a0 e0 	ld  [ %g2 + 0xe0 ], %g1                        
400073dc:	80 a0 60 00 	cmp  %g1, 0                                    
400073e0:	02 80 00 07 	be  400073fc <pthread_testcancel+0x64>         
400073e4:	01 00 00 00 	nop                                            
         thread_support->cancelation_requested )                      
      cancel = true;                                                  
  _Thread_Enable_dispatch();                                          
400073e8:	40 00 0c 26 	call  4000a480 <_Thread_Enable_dispatch>       
400073ec:	b2 10 3f ff 	mov  -1, %i1	! ffffffff <LEON_REG+0x7fffffff>  
                                                                      
  if ( cancel )                                                       
    _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );        
400073f0:	f0 07 60 10 	ld  [ %i5 + 0x10 ], %i0                        
400073f4:	40 00 17 ef 	call  4000d3b0 <_POSIX_Thread_Exit>            
400073f8:	81 e8 00 00 	restore                                        
                                                                      
  _Thread_Disable_dispatch();                                         
    if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
         thread_support->cancelation_requested )                      
      cancel = true;                                                  
  _Thread_Enable_dispatch();                                          
400073fc:	40 00 0c 21 	call  4000a480 <_Thread_Enable_dispatch>       
40007400:	81 e8 00 00 	restore                                        
40007404:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40007408:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4000c5ac <ramdisk_allocate>: void *area_begin, uint32_t media_block_size, rtems_blkdev_bnum media_block_count, bool trace ) {
4000c5ac:	9d e3 bf a0 	save  %sp, -96, %sp                            
  struct ramdisk *rd = malloc(sizeof(struct ramdisk));                
4000c5b0:	7f ff df f0 	call  40004570 <malloc>                        
4000c5b4:	90 10 20 10 	mov  0x10, %o0                                 
                                                                      
  if (rd == NULL) {                                                   
4000c5b8:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4000c5bc:	02 80 00 0b 	be  4000c5e8 <ramdisk_allocate+0x3c>           <== NEVER TAKEN
4000c5c0:	80 a6 20 00 	cmp  %i0, 0                                    
    return NULL;                                                      
  }                                                                   
                                                                      
  if (area_begin == NULL) {                                           
4000c5c4:	02 80 00 0b 	be  4000c5f0 <ramdisk_allocate+0x44>           
4000c5c8:	90 10 00 1a 	mov  %i2, %o0                                  
                                                                      
      return NULL;                                                    
    }                                                                 
    rd->malloced = true;                                              
  } else {                                                            
    rd->malloced = false;                                             
4000c5cc:	c0 2f 60 0d 	clrb  [ %i5 + 0xd ]                            
  }                                                                   
  rd->block_size = media_block_size;                                  
  rd->block_num = media_block_count;                                  
  rd->area = area_begin;                                              
  rd->trace = trace;                                                  
  rd->initialized = true;                                             
4000c5d0:	82 10 20 01 	mov  1, %g1                                    
    }                                                                 
    rd->malloced = true;                                              
  } else {                                                            
    rd->malloced = false;                                             
  }                                                                   
  rd->block_size = media_block_size;                                  
4000c5d4:	f2 27 40 00 	st  %i1, [ %i5 ]                               
  rd->block_num = media_block_count;                                  
4000c5d8:	f4 27 60 04 	st  %i2, [ %i5 + 4 ]                           
  rd->area = area_begin;                                              
4000c5dc:	f0 27 60 08 	st  %i0, [ %i5 + 8 ]                           
  rd->trace = trace;                                                  
4000c5e0:	f6 2f 60 0e 	stb  %i3, [ %i5 + 0xe ]                        
  rd->initialized = true;                                             
4000c5e4:	c2 2f 60 0c 	stb  %g1, [ %i5 + 0xc ]                        
                                                                      
  return rd;                                                          
}                                                                     
4000c5e8:	81 c7 e0 08 	ret                                            
4000c5ec:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
  if (rd == NULL) {                                                   
    return NULL;                                                      
  }                                                                   
                                                                      
  if (area_begin == NULL) {                                           
    area_begin = calloc(media_block_count, media_block_size);         
4000c5f0:	7f ff de 61 	call  40003f74 <calloc>                        
4000c5f4:	92 10 00 19 	mov  %i1, %o1                                  
    if (area_begin == NULL) {                                         
4000c5f8:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4000c5fc:	02 80 00 04 	be  4000c60c <ramdisk_allocate+0x60>           <== NEVER TAKEN
4000c600:	82 10 20 01 	mov  1, %g1                                    
      free(rd);                                                       
                                                                      
      return NULL;                                                    
    }                                                                 
    rd->malloced = true;                                              
4000c604:	10 bf ff f4 	b  4000c5d4 <ramdisk_allocate+0x28>            
4000c608:	c2 2f 60 0d 	stb  %g1, [ %i5 + 0xd ]                        
  }                                                                   
                                                                      
  if (area_begin == NULL) {                                           
    area_begin = calloc(media_block_count, media_block_size);         
    if (area_begin == NULL) {                                         
      free(rd);                                                       
4000c60c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4000c610:	7f ff de 90 	call  40004050 <free>                          <== NOT EXECUTED
4000c614:	ba 10 20 00 	clr  %i5                                       <== NOT EXECUTED
                                                                      
      return NULL;                                                    
4000c618:	30 bf ff f4 	b,a   4000c5e8 <ramdisk_allocate+0x3c>         <== NOT EXECUTED
                                                                      

4000c61c <ramdisk_free>: return rd; } void ramdisk_free(ramdisk *rd) {
4000c61c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if (rd != NULL) {                                                   
4000c620:	80 a6 20 00 	cmp  %i0, 0                                    
4000c624:	02 80 00 0c 	be  4000c654 <ramdisk_free+0x38>               <== NEVER TAKEN
4000c628:	01 00 00 00 	nop                                            
    if (rd->malloced) {                                               
4000c62c:	c2 0e 20 0d 	ldub  [ %i0 + 0xd ], %g1                       
4000c630:	80 a0 60 00 	cmp  %g1, 0                                    
4000c634:	12 80 00 04 	bne  4000c644 <ramdisk_free+0x28>              
4000c638:	01 00 00 00 	nop                                            
      free(rd->area);                                                 
    }                                                                 
    free(rd);                                                         
4000c63c:	7f ff de 85 	call  40004050 <free>                          
4000c640:	81 e8 00 00 	restore                                        
                                                                      
void ramdisk_free(ramdisk *rd)                                        
{                                                                     
  if (rd != NULL) {                                                   
    if (rd->malloced) {                                               
      free(rd->area);                                                 
4000c644:	7f ff de 83 	call  40004050 <free>                          
4000c648:	d0 06 20 08 	ld  [ %i0 + 8 ], %o0                           
    }                                                                 
    free(rd);                                                         
4000c64c:	7f ff de 81 	call  40004050 <free>                          
4000c650:	81 e8 00 00 	restore                                        
4000c654:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000c658:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4000dac0 <ramdisk_initialize>: rtems_device_driver ramdisk_initialize( rtems_device_major_number major, rtems_device_minor_number minor __attribute__((unused)), void *arg __attribute__((unused))) {
4000dac0:	9d e3 bf 80 	save  %sp, -128, %sp                           
    rtems_device_minor_number i;                                      
    rtems_ramdisk_config *c = rtems_ramdisk_configuration;            
    struct ramdisk *r;                                                
    rtems_status_code rc;                                             
                                                                      
    rc = rtems_disk_io_initialize();                                  
4000dac4:	7f ff da 0e 	call  400042fc <rtems_disk_io_initialize>      
4000dac8:	a0 10 00 18 	mov  %i0, %l0                                  
    if (rc != RTEMS_SUCCESSFUL)                                       
4000dacc:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4000dad0:	02 80 00 04 	be  4000dae0 <ramdisk_initialize+0x20>         <== ALWAYS TAKEN
4000dad4:	23 10 00 99 	sethi  %hi(0x40026400), %l1                    
            }                                                         
            r->initialized = false;                                   
        }                                                             
    }                                                                 
    return RTEMS_SUCCESSFUL;                                          
}                                                                     
4000dad8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000dadc:	81 e8 00 00 	restore                                        <== 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));
4000dae0:	fa 04 62 2c 	ld  [ %l1 + 0x22c ], %i5                       
4000dae4:	92 10 20 10 	mov  0x10, %o1                                 
4000dae8:	7f ff dd ed 	call  4000529c <calloc>                        
4000daec:	90 10 00 1d 	mov  %i5, %o0                                  
    r->trace = false;                                                 
4000daf0:	c0 2a 20 0e 	clrb  [ %o0 + 0xe ]                            
    for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)  
4000daf4:	80 a7 60 00 	cmp  %i5, 0                                    
4000daf8:	02 80 00 2e 	be  4000dbb0 <ramdisk_initialize+0xf0>         <== NEVER TAKEN
4000dafc:	b6 10 00 08 	mov  %o0, %i3                                  
4000db00:	35 10 00 99 	sethi  %hi(0x40026400), %i2                    
    {                                                                 
        dev_t dev = rtems_filesystem_make_dev_t(major, i);            
        char name [] = RAMDISK_DEVICE_BASE_NAME "a";                  
4000db04:	39 0b d9 19 	sethi  %hi(0x2f646400), %i4                    
4000db08:	3b 0b dc 99 	sethi  %hi(0x2f726400), %i5                    
        {                                                             
            r->malloced = false;                                      
            r->initialized = true;                                    
            r->area = c->location;                                    
        }                                                             
        rc = rtems_disk_create_phys(dev, c->block_size, c->block_num, 
4000db0c:	25 10 00 36 	sethi  %hi(0x4000d800), %l2                    
     * 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++)  
4000db10:	b4 16 a2 30 	or  %i2, 0x230, %i2                            
4000db14:	b2 10 20 00 	clr  %i1                                       
4000db18:	a2 14 62 2c 	or  %l1, 0x22c, %l1                            
    {                                                                 
        dev_t dev = rtems_filesystem_make_dev_t(major, i);            
        char name [] = RAMDISK_DEVICE_BASE_NAME "a";                  
4000db1c:	b8 17 21 76 	or  %i4, 0x176, %i4                            
4000db20:	ba 17 60 61 	or  %i5, 0x61, %i5                             
            r->malloced = false;                                      
            r->initialized = true;                                    
            r->area = c->location;                                    
        }                                                             
        rc = rtems_disk_create_phys(dev, c->block_size, c->block_num, 
                                    ramdisk_ioctl, r, name);          
4000db24:	a6 07 bf f0 	add  %fp, -16, %l3                             
        {                                                             
            r->malloced = false;                                      
            r->initialized = true;                                    
            r->area = c->location;                                    
        }                                                             
        rc = rtems_disk_create_phys(dev, c->block_size, c->block_num, 
4000db28:	a4 14 a3 fc 	or  %l2, 0x3fc, %l2                            
            }                                                         
        }                                                             
        else                                                          
        {                                                             
            r->malloced = false;                                      
            r->initialized = true;                                    
4000db2c:	b0 10 20 01 	mov  1, %i0                                    
    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;                                
4000db30:	d4 06 80 00 	ld  [ %i2 ], %o2                               
        r->block_num = c->block_num;                                  
4000db34:	d6 06 a0 04 	ld  [ %i2 + 4 ], %o3                           
        if (c->location == NULL)                                      
4000db38:	c2 06 a0 08 	ld  [ %i2 + 8 ], %g1                           
    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;                 
4000db3c:	f2 2f bf f8 	stb  %i1, [ %fp + -8 ]                         
        r->block_size = c->block_size;                                
4000db40:	d4 26 c0 00 	st  %o2, [ %i3 ]                               
        r->block_num = c->block_num;                                  
4000db44:	d6 26 e0 04 	st  %o3, [ %i3 + 4 ]                           
        if (c->location == NULL)                                      
4000db48:	80 a0 60 00 	cmp  %g1, 0                                    
4000db4c:	02 80 00 1f 	be  4000dbc8 <ramdisk_initialize+0x108>        <== ALWAYS TAKEN
4000db50:	f8 3f bf f0 	std  %i4, [ %fp + -16 ]                        
                r->initialized = true;                                
            }                                                         
        }                                                             
        else                                                          
        {                                                             
            r->malloced = false;                                      
4000db54:	c0 2e e0 0d 	clrb  [ %i3 + 0xd ]                            <== NOT EXECUTED
            r->initialized = true;                                    
4000db58:	f0 2e e0 0c 	stb  %i0, [ %i3 + 0xc ]                        <== NOT EXECUTED
            r->area = c->location;                                    
4000db5c:	c2 26 e0 08 	st  %g1, [ %i3 + 8 ]                           <== NOT EXECUTED
        }                                                             
        rc = rtems_disk_create_phys(dev, c->block_size, c->block_num, 
4000db60:	92 10 00 19 	mov  %i1, %o1                                  
4000db64:	9a 10 00 1b 	mov  %i3, %o5                                  
4000db68:	98 10 00 12 	mov  %l2, %o4                                  
4000db6c:	e6 23 a0 5c 	st  %l3, [ %sp + 0x5c ]                        
4000db70:	7f ff d9 43 	call  4000407c <rtems_disk_create_phys>        
4000db74:	90 10 00 10 	mov  %l0, %o0                                  
                                    ramdisk_ioctl, r, name);          
        if (rc != RTEMS_SUCCESSFUL)                                   
4000db78:	80 a2 20 00 	cmp  %o0, 0                                    
4000db7c:	22 80 00 08 	be,a   4000db9c <ramdisk_initialize+0xdc>      <== ALWAYS TAKEN
4000db80:	c2 04 40 00 	ld  [ %l1 ], %g1                               
        {                                                             
            if (r->malloced)                                          
4000db84:	c2 0e e0 0d 	ldub  [ %i3 + 0xd ], %g1                       <== NOT EXECUTED
4000db88:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4000db8c:	12 80 00 0b 	bne  4000dbb8 <ramdisk_initialize+0xf8>        <== NOT EXECUTED
4000db90:	01 00 00 00 	nop                                            <== NOT EXECUTED
            {                                                         
                free(r->area);                                        
            }                                                         
            r->initialized = false;                                   
4000db94:	c0 2e e0 0c 	clrb  [ %i3 + 0xc ]                            <== 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++)  
4000db98:	c2 04 40 00 	ld  [ %l1 ], %g1                               <== NOT EXECUTED
4000db9c:	b2 06 60 01 	inc  %i1                                       
4000dba0:	b4 06 a0 0c 	add  %i2, 0xc, %i2                             
4000dba4:	80 a0 40 19 	cmp  %g1, %i1                                  
4000dba8:	18 bf ff e2 	bgu  4000db30 <ramdisk_initialize+0x70>        <== NEVER TAKEN
4000dbac:	b6 06 e0 10 	add  %i3, 0x10, %i3                            
                free(r->area);                                        
            }                                                         
            r->initialized = false;                                   
        }                                                             
    }                                                                 
    return RTEMS_SUCCESSFUL;                                          
4000dbb0:	81 c7 e0 08 	ret                                            
4000dbb4:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                    ramdisk_ioctl, r, name);          
        if (rc != RTEMS_SUCCESSFUL)                                   
        {                                                             
            if (r->malloced)                                          
            {                                                         
                free(r->area);                                        
4000dbb8:	7f ff dd f0 	call  40005378 <free>                          <== NOT EXECUTED
4000dbbc:	d0 06 e0 08 	ld  [ %i3 + 8 ], %o0                           <== NOT EXECUTED
            }                                                         
            r->initialized = false;                                   
4000dbc0:	10 bf ff f6 	b  4000db98 <ramdisk_initialize+0xd8>          <== NOT EXECUTED
4000dbc4:	c0 2e e0 0c 	clrb  [ %i3 + 0xc ]                            <== 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);           
4000dbc8:	92 10 00 0a 	mov  %o2, %o1                                  
4000dbcc:	90 10 00 0b 	mov  %o3, %o0                                  
4000dbd0:	d4 3f bf e8 	std  %o2, [ %fp + -24 ]                        
4000dbd4:	40 00 4f e5 	call  40021b68 <.umul>                         
4000dbd8:	f0 2e e0 0d 	stb  %i0, [ %i3 + 0xd ]                        
4000dbdc:	7f ff df 84 	call  400059ec <malloc>                        
4000dbe0:	01 00 00 00 	nop                                            
4000dbe4:	d0 26 e0 08 	st  %o0, [ %i3 + 8 ]                           
            if (r->area == NULL) /* No enough memory for this disk */ 
4000dbe8:	80 a2 20 00 	cmp  %o0, 0                                    
4000dbec:	02 bf ff ea 	be  4000db94 <ramdisk_initialize+0xd4>         <== NEVER TAKEN
4000dbf0:	d4 1f bf e8 	ldd  [ %fp + -24 ], %o2                        
                r->initialized = false;                               
                continue;                                             
            }                                                         
            else                                                      
            {                                                         
                r->initialized = true;                                
4000dbf4:	10 bf ff db 	b  4000db60 <ramdisk_initialize+0xa0>          
4000dbf8:	f0 2e e0 0c 	stb  %i0, [ %i3 + 0xc ]                        
                                                                      

4000c464 <ramdisk_ioctl>: return 0; } int ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp) {
4000c464:	9d e3 bf a0 	save  %sp, -96, %sp                            
    struct ramdisk *rd = rtems_disk_get_driver_data(dd);              
                                                                      
    switch (req)                                                      
4000c468:	05 08 00 10 	sethi  %hi(0x20004000), %g2                    
    return 0;                                                         
}                                                                     
                                                                      
int                                                                   
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)        
{                                                                     
4000c46c:	b8 10 00 1a 	mov  %i2, %i4                                  
    struct ramdisk *rd = rtems_disk_get_driver_data(dd);              
                                                                      
    switch (req)                                                      
4000c470:	84 10 a2 07 	or  %g2, 0x207, %g2                            
4000c474:	80 a6 40 02 	cmp  %i1, %g2                                  
4000c478:	02 80 00 09 	be  4000c49c <ramdisk_ioctl+0x38>              
4000c47c:	f6 06 20 3c 	ld  [ %i0 + 0x3c ], %i3                        
4000c480:	05 30 06 10 	sethi  %hi(0xc0184000), %g2                    
4000c484:	84 10 a2 01 	or  %g2, 0x201, %g2	! c0184201 <LEON_REG+0x40184201>
4000c488:	80 a6 40 02 	cmp  %i1, %g2                                  
4000c48c:	22 80 00 0e 	be,a   4000c4c4 <ramdisk_ioctl+0x60>           
4000c490:	c2 06 80 00 	ld  [ %i2 ], %g1                               
              ramdisk_free(rd);                                       
            }                                                         
            break;                                                    
                                                                      
        default:                                                      
            return rtems_blkdev_ioctl (dd, req, argp);                
4000c494:	40 00 0b 08 	call  4000f0b4 <rtems_blkdev_ioctl>            
4000c498:	81 e8 00 00 	restore                                        
            }                                                         
            break;                                                    
        }                                                             
                                                                      
        case RTEMS_BLKIO_DELETED:                                     
            if (rd->free_at_delete_request) {                         
4000c49c:	c2 0e e0 0f 	ldub  [ %i3 + 0xf ], %g1                       
4000c4a0:	80 a0 60 00 	cmp  %g1, 0                                    
4000c4a4:	12 80 00 3f 	bne  4000c5a0 <ramdisk_ioctl+0x13c>            
4000c4a8:	01 00 00 00 	nop                                            
        default:                                                      
            return rtems_blkdev_ioctl (dd, req, argp);                
            break;                                                    
    }                                                                 
                                                                      
    errno = EINVAL;                                                   
4000c4ac:	40 00 1e 5a 	call  40013e14 <__errno>                       
4000c4b0:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <LEON_REG+0x7fffffff>  
4000c4b4:	82 10 20 16 	mov  0x16, %g1                                 
4000c4b8:	c2 22 00 00 	st  %g1, [ %o0 ]                               
    return -1;                                                        
}                                                                     
4000c4bc:	81 c7 e0 08 	ret                                            
4000c4c0:	81 e8 00 00 	restore                                        
    {                                                                 
        case RTEMS_BLKIO_REQUEST:                                     
        {                                                             
            rtems_blkdev_request *r = argp;                           
                                                                      
            switch (r->req)                                           
4000c4c4:	80 a0 60 00 	cmp  %g1, 0                                    
4000c4c8:	12 80 00 1c 	bne  4000c538 <ramdisk_ioctl+0xd4>             
4000c4cc:	80 a0 60 01 	cmp  %g1, 1                                    
#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++)           
4000c4d0:	c2 06 a0 10 	ld  [ %i2 + 0x10 ], %g1                        
4000c4d4:	ba 06 a0 18 	add  %i2, 0x18, %i5                            
#endif                                                                
                                                                      
static int                                                            
ramdisk_read(struct ramdisk *rd, rtems_blkdev_request *req)           
{                                                                     
    uint8_t *from = rd->area;                                         
4000c4d8:	f0 06 e0 08 	ld  [ %i3 + 8 ], %i0                           
#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++)           
4000c4dc:	80 a0 60 00 	cmp  %g1, 0                                    
4000c4e0:	02 80 00 0f 	be  4000c51c <ramdisk_ioctl+0xb8>              <== NEVER TAKEN
4000c4e4:	b4 10 20 00 	clr  %i2                                       
#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);
4000c4e8:	d0 07 40 00 	ld  [ %i5 ], %o0                               
4000c4ec:	d2 06 c0 00 	ld  [ %i3 ], %o1                               
4000c4f0:	40 00 2b 98 	call  40017350 <.umul>                         
4000c4f4:	f2 07 60 08 	ld  [ %i5 + 8 ], %i1                           
4000c4f8:	d4 07 60 04 	ld  [ %i5 + 4 ], %o2                           
4000c4fc:	92 06 00 08 	add  %i0, %o0, %o1                             
4000c500:	40 00 20 7c 	call  400146f0 <memcpy>                        
4000c504:	90 10 00 19 	mov  %i1, %o0                                  
#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++)           
4000c508:	c2 07 20 10 	ld  [ %i4 + 0x10 ], %g1                        
4000c50c:	b4 06 a0 01 	inc  %i2                                       
4000c510:	80 a6 80 01 	cmp  %i2, %g1                                  
4000c514:	0a bf ff f5 	bcs  4000c4e8 <ramdisk_ioctl+0x84>             <== NEVER TAKEN
4000c518:	ba 07 60 10 	add  %i5, 0x10, %i5                            
static inline void rtems_blkdev_request_done(                         
  rtems_blkdev_request *req,                                          
  rtems_status_code status                                            
)                                                                     
{                                                                     
  (*req->done)(req, status);                                          
4000c51c:	c2 07 20 04 	ld  [ %i4 + 4 ], %g1                           
4000c520:	90 10 00 1c 	mov  %i4, %o0                                  
4000c524:	92 10 20 00 	clr  %o1                                       
4000c528:	9f c0 40 00 	call  %g1                                      
4000c52c:	b0 10 20 00 	clr  %i0                                       
            {                                                         
                case RTEMS_BLKDEV_REQ_READ:                           
                    return ramdisk_read(rd, r);                       
                                                                      
                case RTEMS_BLKDEV_REQ_WRITE:                          
                    return ramdisk_write(rd, r);                      
4000c530:	81 c7 e0 08 	ret                                            
4000c534:	81 e8 00 00 	restore                                        
    {                                                                 
        case RTEMS_BLKIO_REQUEST:                                     
        {                                                             
            rtems_blkdev_request *r = argp;                           
                                                                      
            switch (r->req)                                           
4000c538:	12 bf ff dd 	bne  4000c4ac <ramdisk_ioctl+0x48>             <== NEVER TAKEN
4000c53c:	ba 06 a0 18 	add  %i2, 0x18, %i5                            
                                                                      
#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++)           
4000c540:	c2 06 a0 10 	ld  [ %i2 + 0x10 ], %g1                        
}                                                                     
                                                                      
static int                                                            
ramdisk_write(struct ramdisk *rd, rtems_blkdev_request *req)          
{                                                                     
    uint8_t *to = rd->area;                                           
4000c544:	f2 06 e0 08 	ld  [ %i3 + 8 ], %i1                           
                                                                      
#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++)           
4000c548:	80 a0 60 00 	cmp  %g1, 0                                    
4000c54c:	02 bf ff f4 	be  4000c51c <ramdisk_ioctl+0xb8>              <== NEVER TAKEN
4000c550:	b4 10 20 00 	clr  %i2                                       
#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);
4000c554:	d0 07 40 00 	ld  [ %i5 ], %o0                               
4000c558:	d2 06 c0 00 	ld  [ %i3 ], %o1                               
4000c55c:	40 00 2b 7d 	call  40017350 <.umul>                         
4000c560:	b4 06 a0 01 	inc  %i2                                       
4000c564:	d2 07 60 08 	ld  [ %i5 + 8 ], %o1                           
4000c568:	d4 07 60 04 	ld  [ %i5 + 4 ], %o2                           
4000c56c:	40 00 20 61 	call  400146f0 <memcpy>                        
4000c570:	90 06 40 08 	add  %i1, %o0, %o0                             
                                                                      
#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++)           
4000c574:	c2 07 20 10 	ld  [ %i4 + 0x10 ], %g1                        
4000c578:	80 a6 80 01 	cmp  %i2, %g1                                  
4000c57c:	0a bf ff f6 	bcs  4000c554 <ramdisk_ioctl+0xf0>             
4000c580:	ba 07 60 10 	add  %i5, 0x10, %i5                            
4000c584:	c2 07 20 04 	ld  [ %i4 + 4 ], %g1                           
4000c588:	90 10 00 1c 	mov  %i4, %o0                                  
4000c58c:	92 10 20 00 	clr  %o1                                       
4000c590:	9f c0 40 00 	call  %g1                                      
4000c594:	b0 10 20 00 	clr  %i0                                       
            {                                                         
                case RTEMS_BLKDEV_REQ_READ:                           
                    return ramdisk_read(rd, r);                       
                                                                      
                case RTEMS_BLKDEV_REQ_WRITE:                          
                    return ramdisk_write(rd, r);                      
4000c598:	81 c7 e0 08 	ret                                            
4000c59c:	81 e8 00 00 	restore                                        
            break;                                                    
        }                                                             
                                                                      
        case RTEMS_BLKIO_DELETED:                                     
            if (rd->free_at_delete_request) {                         
              ramdisk_free(rd);                                       
4000c5a0:	40 00 00 1f 	call  4000c61c <ramdisk_free>                  
4000c5a4:	90 10 00 1b 	mov  %i3, %o0                                  
4000c5a8:	30 bf ff c1 	b,a   4000c4ac <ramdisk_ioctl+0x48>            
                                                                      

4000c65c <ramdisk_register>: rtems_blkdev_bnum media_block_count, bool trace, const char *disk, dev_t *dev_ptr ) {
4000c65c:	9d e3 bf 90 	save  %sp, -112, %sp                           
  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);             
4000c660:	90 10 20 00 	clr  %o0                                       
  const char *disk,                                                   
  dev_t *dev_ptr                                                      
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_device_major_number major = 0;                                
4000c664:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
  ramdisk *rd = NULL;                                                 
  dev_t dev = 0;                                                      
                                                                      
  sc = rtems_io_register_driver(0, &ramdisk_ops, &major);             
4000c668:	94 07 bf fc 	add  %fp, -4, %o2                              
4000c66c:	13 10 00 67 	sethi  %hi(0x40019c00), %o1                    
  if (sc != RTEMS_SUCCESSFUL) {                                       
    return RTEMS_UNSATISFIED;                                         
4000c670:	ba 10 20 0d 	mov  0xd, %i5                                  
  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);             
4000c674:	7f ff f1 fe 	call  40008e6c <rtems_io_register_driver>      
4000c678:	92 12 62 40 	or  %o1, 0x240, %o1                            
  if (sc != RTEMS_SUCCESSFUL) {                                       
4000c67c:	80 a2 20 00 	cmp  %o0, 0                                    
4000c680:	02 80 00 04 	be  4000c690 <ramdisk_register+0x34>           <== ALWAYS TAKEN
4000c684:	96 10 00 1a 	mov  %i2, %o3                                  
  }                                                                   
                                                                      
  *dev_ptr = dev;                                                     
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
4000c688:	81 c7 e0 08 	ret                                            
4000c68c:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
  sc = rtems_io_register_driver(0, &ramdisk_ops, &major);             
  if (sc != RTEMS_SUCCESSFUL) {                                       
    return RTEMS_UNSATISFIED;                                         
  }                                                                   
                                                                      
  rd = ramdisk_allocate(NULL, media_block_size, media_block_count, trace);
4000c690:	92 10 00 18 	mov  %i0, %o1                                  
4000c694:	7f ff ff c6 	call  4000c5ac <ramdisk_allocate>              
4000c698:	94 10 00 19 	mov  %i1, %o2                                  
  if (rd == NULL) {                                                   
4000c69c:	b4 92 20 00 	orcc  %o0, 0, %i2                              
4000c6a0:	02 80 00 14 	be  4000c6f0 <ramdisk_register+0x94>           <== NEVER TAKEN
4000c6a4:	e0 07 bf fc 	ld  [ %fp + -4 ], %l0                          
    return RTEMS_UNSATISFIED;                                         
  }                                                                   
                                                                      
  dev = rtems_filesystem_make_dev_t(major, 0);                        
                                                                      
  sc = rtems_disk_create_phys(                                        
4000c6a8:	f6 23 a0 5c 	st  %i3, [ %sp + 0x5c ]                        
4000c6ac:	90 10 00 10 	mov  %l0, %o0                                  
4000c6b0:	92 10 20 00 	clr  %o1                                       
4000c6b4:	94 10 00 18 	mov  %i0, %o2                                  
4000c6b8:	96 10 00 19 	mov  %i1, %o3                                  
4000c6bc:	9a 10 00 1a 	mov  %i2, %o5                                  
4000c6c0:	19 10 00 31 	sethi  %hi(0x4000c400), %o4                    
4000c6c4:	7f ff db 4a 	call  400033ec <rtems_disk_create_phys>        
4000c6c8:	98 13 20 64 	or  %o4, 0x64, %o4	! 4000c464 <ramdisk_ioctl>  
    media_block_count,                                                
    ramdisk_ioctl,                                                    
    rd,                                                               
    disk                                                              
  );                                                                  
  if (sc != RTEMS_SUCCESSFUL) {                                       
4000c6cc:	80 a2 20 00 	cmp  %o0, 0                                    
4000c6d0:	12 80 00 06 	bne  4000c6e8 <ramdisk_register+0x8c>          <== NEVER TAKEN
4000c6d4:	01 00 00 00 	nop                                            
    rtems_io_unregister_driver(major);                                
                                                                      
    return RTEMS_UNSATISFIED;                                         
  }                                                                   
                                                                      
  *dev_ptr = dev;                                                     
4000c6d8:	e0 27 00 00 	st  %l0, [ %i4 ]                               
4000c6dc:	c0 27 20 04 	clr  [ %i4 + 4 ]                               
                                                                      
  return RTEMS_SUCCESSFUL;                                            
4000c6e0:	10 bf ff ea 	b  4000c688 <ramdisk_register+0x2c>            
4000c6e4:	ba 10 20 00 	clr  %i5                                       
    ramdisk_ioctl,                                                    
    rd,                                                               
    disk                                                              
  );                                                                  
  if (sc != RTEMS_SUCCESSFUL) {                                       
    ramdisk_free(rd);                                                 
4000c6e8:	7f ff ff cd 	call  4000c61c <ramdisk_free>                  <== NOT EXECUTED
4000c6ec:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
    rtems_io_unregister_driver(major);                                
4000c6f0:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          <== NOT EXECUTED
4000c6f4:	7f ff f2 43 	call  40009000 <rtems_io_unregister_driver>    <== NOT EXECUTED
4000c6f8:	b0 10 00 1d 	mov  %i5, %i0                                  <== NOT EXECUTED
  }                                                                   
                                                                      
  *dev_ptr = dev;                                                     
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
4000c6fc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000c700:	81 e8 00 00 	restore                                        <== NOT EXECUTED
4000c704:	40 00 d7 80 	call  40042504 <__end+0x26704>                 <== NOT EXECUTED
4000c708:	40 00 d9 1c 	call  40042b78 <__end+0x26d78>                 <== NOT EXECUTED
4000c70c:	40 00 d9 14 	call  40042b5c <__end+0x26d5c>                 <== NOT EXECUTED
4000c710:	40 00 d9 00 	call  40042b10 <__end+0x26d10>                 <== NOT EXECUTED
4000c714:	40 00 d9 00 	call  40042b14 <__end+0x26d14>                 <== NOT EXECUTED
4000c718:	40 00 d9 00 	call  40042b18 <__end+0x26d18>                 <== NOT EXECUTED
4000c71c:	40 00 d9 00 	call  40042b1c <__end+0x26d1c>                 <== NOT EXECUTED
4000c720:	40 00 d8 cc 	call  40042a50 <__end+0x26c50>                 <== NOT EXECUTED
4000c724:	40 00 d8 b8 	call  40042a04 <__end+0x26c04>                 <== NOT EXECUTED
4000c728:	40 00 d8 b8 	call  40042a08 <__end+0x26c08>                 <== NOT EXECUTED
4000c72c:	40 00 d8 b8 	call  40042a0c <__end+0x26c0c>                 <== NOT EXECUTED
4000c730:	40 00 d7 c8 	call  40042650 <__end+0x26850>                 <== NOT EXECUTED
4000c734:	40 00 d7 b8 	call  40042614 <__end+0x26814>                 <== NOT EXECUTED
4000c738:	40 00 d7 b8 	call  40042618 <__end+0x26818>                 <== NOT EXECUTED
4000c73c:	40 00 d8 94 	call  4004298c <__end+0x26b8c>                 <== NOT EXECUTED
4000c740:	40 00 d8 94 	call  40042990 <__end+0x26b90>                 <== NOT EXECUTED
4000c744:	40 00 d8 94 	call  40042994 <__end+0x26b94>                 <== NOT EXECUTED
4000c748:	40 00 d8 94 	call  40042998 <__end+0x26b98>                 <== NOT EXECUTED
4000c74c:	40 00 d8 60 	call  400428cc <__end+0x26acc>                 <== NOT EXECUTED
4000c750:	40 00 d8 4c 	call  40042880 <__end+0x26a80>                 <== NOT EXECUTED
4000c754:	40 00 d8 4c 	call  40042884 <__end+0x26a84>                 <== NOT EXECUTED
4000c758:	40 00 d8 4c 	call  40042888 <__end+0x26a88>                 <== NOT EXECUTED
4000c75c:	40 00 ed cc 	call  40047e8c <__end+0x2c08c>                 <== NOT EXECUTED
4000c760:	40 00 ed cc 	call  40047e90 <__end+0x2c090>                 <== NOT EXECUTED
4000c764:	40 00 ee f4 	call  40048334 <__end+0x2c534>                 <== NOT EXECUTED
4000c768:	40 00 ef 1c 	call  400483d8 <__end+0x2c5d8>                 <== NOT EXECUTED
4000c76c:	40 00 ef 1c 	call  400483dc <__end+0x2c5dc>                 <== NOT EXECUTED
4000c770:	40 00 ef 1c 	call  400483e0 <__end+0x2c5e0>                 <== NOT EXECUTED
4000c774:	40 00 ed cc 	call  40047ea4 <__end+0x2c0a4>                 <== NOT EXECUTED
4000c778:	40 00 ee e4 	call  40048308 <__end+0x2c508>                 <== NOT EXECUTED
4000c77c:	40 00 ee dc 	call  400482ec <__end+0x2c4ec>                 <== NOT EXECUTED
4000c780:	40 00 ef 24 	call  40048410 <__end+0x2c610>                 <== NOT EXECUTED
4000c784:	40 00 ed cc 	call  40047eb4 <__end+0x2c0b4>                 <== NOT EXECUTED
                                                                      

4001b6d0 <read>: ssize_t read( int fd, void *buffer, size_t count ) {
4001b6d0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_libio_t *iop;                                                 
                                                                      
  rtems_libio_check_fd( fd );                                         
4001b6d4:	03 10 00 78 	sethi  %hi(0x4001e000), %g1                    
4001b6d8:	c2 00 63 a4 	ld  [ %g1 + 0x3a4 ], %g1	! 4001e3a4 <rtems_libio_number_iops>
4001b6dc:	80 a6 00 01 	cmp  %i0, %g1                                  
4001b6e0:	1a 80 00 18 	bcc  4001b740 <read+0x70>                      
4001b6e4:	03 10 00 7b 	sethi  %hi(0x4001ec00), %g1                    
  iop = rtems_libio_iop( fd );                                        
4001b6e8:	d0 00 61 30 	ld  [ %g1 + 0x130 ], %o0	! 4001ed30 <rtems_libio_iops>
4001b6ec:	83 2e 20 03 	sll  %i0, 3, %g1                               
4001b6f0:	b1 2e 20 06 	sll  %i0, 6, %i0                               
4001b6f4:	b0 26 00 01 	sub  %i0, %g1, %i0                             
4001b6f8:	90 02 00 18 	add  %o0, %i0, %o0                             
  rtems_libio_check_is_open( iop );                                   
4001b6fc:	c2 02 20 10 	ld  [ %o0 + 0x10 ], %g1                        
4001b700:	80 88 61 00 	btst  0x100, %g1                               
4001b704:	02 80 00 0f 	be  4001b740 <read+0x70>                       
4001b708:	80 a6 60 00 	cmp  %i1, 0                                    
  rtems_libio_check_buffer( buffer );                                 
4001b70c:	02 80 00 13 	be  4001b758 <read+0x88>                       <== NEVER TAKEN
4001b710:	80 a6 a0 00 	cmp  %i2, 0                                    
  rtems_libio_check_count( count );                                   
4001b714:	02 80 00 0f 	be  4001b750 <read+0x80>                       
4001b718:	b0 10 20 00 	clr  %i0                                       
  rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
4001b71c:	80 88 60 02 	btst  2, %g1                                   
4001b720:	02 80 00 08 	be  4001b740 <read+0x70>                       
4001b724:	92 10 00 19 	mov  %i1, %o1                                  
                                                                      
  /*                                                                  
   *  Now process the read().                                         
   */                                                                 
  return (*iop->pathinfo.handlers->read_h)( iop, buffer, count );     
4001b728:	c2 02 20 24 	ld  [ %o0 + 0x24 ], %g1                        
4001b72c:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
4001b730:	9f c0 40 00 	call  %g1                                      
4001b734:	94 10 00 1a 	mov  %i2, %o2                                  
}                                                                     
4001b738:	81 c7 e0 08 	ret                                            
4001b73c:	91 e8 00 08 	restore  %g0, %o0, %o0                         
  rtems_libio_check_fd( fd );                                         
  iop = rtems_libio_iop( fd );                                        
  rtems_libio_check_is_open( iop );                                   
  rtems_libio_check_buffer( buffer );                                 
  rtems_libio_check_count( count );                                   
  rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
4001b740:	7f ff d0 00 	call  4000f740 <__errno>                       
4001b744:	b0 10 3f ff 	mov  -1, %i0                                   
4001b748:	82 10 20 09 	mov  9, %g1                                    
4001b74c:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4001b750:	81 c7 e0 08 	ret                                            
4001b754:	81 e8 00 00 	restore                                        
  rtems_libio_t *iop;                                                 
                                                                      
  rtems_libio_check_fd( fd );                                         
  iop = rtems_libio_iop( fd );                                        
  rtems_libio_check_is_open( iop );                                   
  rtems_libio_check_buffer( buffer );                                 
4001b758:	7f ff cf fa 	call  4000f740 <__errno>                       <== NOT EXECUTED
4001b75c:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4001b760:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
4001b764:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4001b768:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001b76c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40004674 <read_extended_partition>: * RTEMS_NO_MEMOTY if cannot allocate memory for part_desc_t strucure, * RTEMS_INTERNAL_ERROR if other error occurs. */ static rtems_status_code read_extended_partition(int fd, uint32_t start, rtems_part_desc_t *ext_part) {
40004674:	9d e3 bf 98 	save  %sp, -104, %sp                           
    int                  i;                                           
    rtems_sector_data_t *sector = NULL;                               
40004678:	c0 27 bf f8 	clr  [ %fp + -8 ]                              
 *      RTEMS_NO_MEMOTY if cannot allocate memory for part_desc_t strucure,
 *      RTEMS_INTERNAL_ERROR if other error occurs.                   
 */                                                                   
static rtems_status_code                                              
read_extended_partition(int fd, uint32_t start, rtems_part_desc_t *ext_part)
{                                                                     
4000467c:	ba 10 00 18 	mov  %i0, %i5                                  
    uint32_t             here;                                        
    uint8_t             *data;                                        
    rtems_part_desc_t   *new_part_desc;                               
    rtems_status_code    rc;                                          
                                                                      
    if ((ext_part == NULL) || (ext_part->disk_desc == NULL))          
40004680:	80 a6 a0 00 	cmp  %i2, 0                                    
40004684:	02 80 00 16 	be  400046dc <read_extended_partition+0x68>    <== NEVER TAKEN
40004688:	b0 10 20 19 	mov  0x19, %i0                                 
4000468c:	c2 06 a0 10 	ld  [ %i2 + 0x10 ], %g1                        
40004690:	80 a0 60 00 	cmp  %g1, 0                                    
40004694:	02 80 00 12 	be  400046dc <read_extended_partition+0x68>    <== NEVER TAKEN
40004698:	90 10 00 1d 	mov  %i5, %o0                                  
    {                                                                 
        return RTEMS_INTERNAL_ERROR;                                  
    }                                                                 
                                                                      
    /* get start sector of current extended partition */              
    here = ext_part->start;                                           
4000469c:	e0 06 a0 04 	ld  [ %i2 + 4 ], %l0                           
    if (sector == NULL)                                               
    {                                                                 
        return RTEMS_INTERNAL_ERROR;                                  
    }                                                                 
                                                                      
    off = sector_num * RTEMS_IDE_SECTOR_SIZE;                         
400046a0:	b9 2c 20 09 	sll  %l0, 9, %i4                               
    new_off = lseek(fd, off, SEEK_SET);                               
400046a4:	92 10 20 00 	clr  %o1                                       
400046a8:	94 10 00 1c 	mov  %i4, %o2                                  
400046ac:	40 00 04 57 	call  40005808 <lseek>                         
400046b0:	96 10 20 00 	clr  %o3                                       
    if (new_off != off) {                                             
400046b4:	80 a2 20 00 	cmp  %o0, 0                                    
400046b8:	02 80 00 0b 	be  400046e4 <read_extended_partition+0x70>    <== ALWAYS TAKEN
400046bc:	80 a7 00 09 	cmp  %i4, %o1                                  
        return RTEMS_IO_ERROR;                                        
400046c0:	b0 10 20 1b 	mov  0x1b, %i0                                 <== NOT EXECUTED
    /* get first extended partition sector */                         
                                                                      
    rc = get_sector(fd, here, §or);                               
    if (rc != RTEMS_SUCCESSFUL)                                       
    {                                                                 
        if (sector)                                                   
400046c4:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0                          <== NOT EXECUTED
400046c8:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
400046cc:	02 80 00 41 	be  400047d0 <read_extended_partition+0x15c>   <== NOT EXECUTED
400046d0:	01 00 00 00 	nop                                            <== NOT EXECUTED
            new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
        }                                                             
        data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;                  
    }                                                                 
                                                                      
    free(sector);                                                     
400046d4:	40 00 03 29 	call  40005378 <free>                          <== NOT EXECUTED
400046d8:	01 00 00 00 	nop                                            <== NOT EXECUTED
400046dc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400046e0:	81 e8 00 00 	restore                                        <== NOT EXECUTED
        return RTEMS_INTERNAL_ERROR;                                  
    }                                                                 
                                                                      
    off = sector_num * RTEMS_IDE_SECTOR_SIZE;                         
    new_off = lseek(fd, off, SEEK_SET);                               
    if (new_off != off) {                                             
400046e4:	12 bf ff f8 	bne  400046c4 <read_extended_partition+0x50>   <== NEVER TAKEN
400046e8:	b0 10 20 1b 	mov  0x1b, %i0                                 
400046ec:	90 10 00 1d 	mov  %i5, %o0                                  
400046f0:	92 10 00 10 	mov  %l0, %o1                                  
400046f4:	7f ff ff 7c 	call  400044e4 <get_sector.part.0>             
400046f8:	94 07 bf f8 	add  %fp, -8, %o2                              
    here = ext_part->start;                                           
                                                                      
    /* get first extended partition sector */                         
                                                                      
    rc = get_sector(fd, here, §or);                               
    if (rc != RTEMS_SUCCESSFUL)                                       
400046fc:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40004700:	12 bf ff f1 	bne  400046c4 <read_extended_partition+0x50>   <== NEVER TAKEN
40004704:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0                          
static bool                                                           
msdos_signature_check (rtems_sector_data_t *sector)                   
{                                                                     
    uint8_t *p = sector->data + RTEMS_IDE_PARTITION_MSDOS_SIGNATURE_OFFSET;
                                                                      
    return ((p[0] == RTEMS_IDE_PARTITION_MSDOS_SIGNATURE_DATA1) &&    
40004708:	c2 0a 22 02 	ldub  [ %o0 + 0x202 ], %g1                     
4000470c:	80 a0 60 55 	cmp  %g1, 0x55                                 
40004710:	22 80 00 06 	be,a   40004728 <read_extended_partition+0xb4> <== ALWAYS TAKEN
40004714:	c2 0a 22 03 	ldub  [ %o0 + 0x203 ], %g1                     
        return rc;                                                    
    }                                                                 
                                                                      
    if (!msdos_signature_check(sector))                               
    {                                                                 
        free(sector);                                                 
40004718:	40 00 03 18 	call  40005378 <free>                          <== NOT EXECUTED
4000471c:	b0 10 20 19 	mov  0x19, %i0                                 <== NOT EXECUTED
40004720:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40004724:	81 e8 00 00 	restore                                        <== NOT EXECUTED
static bool                                                           
msdos_signature_check (rtems_sector_data_t *sector)                   
{                                                                     
    uint8_t *p = sector->data + RTEMS_IDE_PARTITION_MSDOS_SIGNATURE_OFFSET;
                                                                      
    return ((p[0] == RTEMS_IDE_PARTITION_MSDOS_SIGNATURE_DATA1) &&    
40004728:	80 a0 60 aa 	cmp  %g1, 0xaa                                 
4000472c:	12 bf ff fb 	bne  40004718 <read_extended_partition+0xa4>   <== NEVER TAKEN
40004730:	b6 02 21 d2 	add  %o0, 0x1d2, %i3                           
40004734:	b8 10 00 1a 	mov  %i2, %i4                                  
 *      RTEMS_SUCCESSFUL if success,                                  
 *      RTEMS_NO_MEMOTY if cannot allocate memory for part_desc_t strucure,
 *      RTEMS_INTERNAL_ERROR if other error occurs.                   
 */                                                                   
static rtems_status_code                                              
read_extended_partition(int fd, uint32_t start, rtems_part_desc_t *ext_part)
40004738:	a2 06 a0 10 	add  %i2, 0x10, %l1                            
4000473c:	90 06 ff f0 	add  %i3, -16, %o0                             
40004740:	7f ff ff 80 	call  40004540 <data_to_part_desc.part.1>      
40004744:	92 07 bf fc 	add  %fp, -4, %o1                              
    {                                                                 
        /* if data_to_part_desc fails skip this partition             
         * and parse the next one                                     
         */                                                           
        rc = data_to_part_desc(data, &new_part_desc);                 
        if (rc != RTEMS_SUCCESSFUL)                                   
40004748:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4000474c:	12 80 00 1f 	bne  400047c8 <read_extended_partition+0x154>  <== NEVER TAKEN
40004750:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          
        {                                                             
            free(sector);                                             
            return rc;                                                
        }                                                             
                                                                      
        if (new_part_desc == NULL)                                    
40004754:	80 a2 a0 00 	cmp  %o2, 0                                    
40004758:	22 80 00 19 	be,a   400047bc <read_extended_partition+0x148>
4000475c:	b8 07 20 04 	add  %i4, 4, %i4                               
        {                                                             
            data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;              
            continue;                                                 
        }                                                             
                                                                      
        ext_part->sub_part[i] = new_part_desc;                        
40004760:	d4 27 20 18 	st  %o2, [ %i4 + 0x18 ]                        
        new_part_desc->ext_part = ext_part;                           
        new_part_desc->disk_desc = ext_part->disk_desc;               
40004764:	c2 06 a0 10 	ld  [ %i2 + 0x10 ], %g1                        
 *      true if partition type is extended, false otherwise           
 */                                                                   
static bool                                                           
is_extended(uint8_t type)                                             
{                                                                     
    return ((type == EXTENDED_PARTITION) || (type == LINUX_EXTENDED));
40004768:	c4 0a a0 01 	ldub  [ %o2 + 1 ], %g2                         
            data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;              
            continue;                                                 
        }                                                             
                                                                      
        ext_part->sub_part[i] = new_part_desc;                        
        new_part_desc->ext_part = ext_part;                           
4000476c:	f4 22 a0 14 	st  %i2, [ %o2 + 0x14 ]                        
        new_part_desc->disk_desc = ext_part->disk_desc;               
                                                                      
        if (is_extended(new_part_desc->sys_type))                     
40004770:	84 08 a0 7f 	and  %g2, 0x7f, %g2                            
40004774:	80 a0 a0 05 	cmp  %g2, 5                                    
40004778:	02 80 00 18 	be  400047d8 <read_extended_partition+0x164>   
4000477c:	c2 22 a0 10 	st  %g1, [ %o2 + 0x10 ]                        
            read_extended_partition(fd, start, new_part_desc);        
        }                                                             
        else                                                          
        {                                                             
            rtems_disk_desc_t *disk_desc = new_part_desc->disk_desc;  
            disk_desc->partitions[disk_desc->last_log_id] = new_part_desc;
40004780:	c6 00 60 24 	ld  [ %g1 + 0x24 ], %g3                        
            new_part_desc->log_id = ++disk_desc->last_log_id;         
            new_part_desc->start += here;                             
40004784:	de 02 a0 04 	ld  [ %o2 + 4 ], %o7                           
            new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
40004788:	c8 02 a0 08 	ld  [ %o2 + 8 ], %g4                           
        }                                                             
        else                                                          
        {                                                             
            rtems_disk_desc_t *disk_desc = new_part_desc->disk_desc;  
            disk_desc->partitions[disk_desc->last_log_id] = new_part_desc;
            new_part_desc->log_id = ++disk_desc->last_log_id;         
4000478c:	84 00 e0 01 	add  %g3, 1, %g2                               
            read_extended_partition(fd, start, new_part_desc);        
        }                                                             
        else                                                          
        {                                                             
            rtems_disk_desc_t *disk_desc = new_part_desc->disk_desc;  
            disk_desc->partitions[disk_desc->last_log_id] = new_part_desc;
40004790:	86 00 e0 0a 	add  %g3, 0xa, %g3                             
            new_part_desc->log_id = ++disk_desc->last_log_id;         
40004794:	c4 20 60 24 	st  %g2, [ %g1 + 0x24 ]                        
            read_extended_partition(fd, start, new_part_desc);        
        }                                                             
        else                                                          
        {                                                             
            rtems_disk_desc_t *disk_desc = new_part_desc->disk_desc;  
            disk_desc->partitions[disk_desc->last_log_id] = new_part_desc;
40004798:	87 28 e0 02 	sll  %g3, 2, %g3                               
4000479c:	d4 20 40 03 	st  %o2, [ %g1 + %g3 ]                         
            new_part_desc->log_id = ++disk_desc->last_log_id;         
400047a0:	c4 2a a0 02 	stb  %g2, [ %o2 + 2 ]                          
            new_part_desc->start += here;                             
400047a4:	82 04 00 0f 	add  %l0, %o7, %g1                             
            new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
400047a8:	84 01 3f ff 	add  %g4, -1, %g2                              
        else                                                          
        {                                                             
            rtems_disk_desc_t *disk_desc = new_part_desc->disk_desc;  
            disk_desc->partitions[disk_desc->last_log_id] = new_part_desc;
            new_part_desc->log_id = ++disk_desc->last_log_id;         
            new_part_desc->start += here;                             
400047ac:	c2 22 a0 04 	st  %g1, [ %o2 + 4 ]                           
            new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
400047b0:	82 00 80 01 	add  %g2, %g1, %g1                             
400047b4:	c2 22 a0 0c 	st  %g1, [ %o2 + 0xc ]                         
400047b8:	b8 07 20 04 	add  %i4, 4, %i4                               
                                                                      
    /* read and process up to 4 logical partition descriptors */      
                                                                      
    data = sector->data + RTEMS_IDE_PARTITION_TABLE_OFFSET;           
                                                                      
    for (i = 0; i < RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER; i++)
400047bc:	80 a7 00 11 	cmp  %i4, %l1                                  
400047c0:	12 bf ff df 	bne  4000473c <read_extended_partition+0xc8>   
400047c4:	b6 06 e0 10 	add  %i3, 0x10, %i3                            
            new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
        }                                                             
        data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;                  
    }                                                                 
                                                                      
    free(sector);                                                     
400047c8:	40 00 02 ec 	call  40005378 <free>                          
400047cc:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0                          
400047d0:	81 c7 e0 08 	ret                                            
400047d4:	81 e8 00 00 	restore                                        
        new_part_desc->disk_desc = ext_part->disk_desc;               
                                                                      
        if (is_extended(new_part_desc->sys_type))                     
        {                                                             
            new_part_desc->log_id = EMPTY_PARTITION;                  
            new_part_desc->start += start;                            
400047d8:	c2 02 a0 04 	ld  [ %o2 + 4 ], %g1                           
        new_part_desc->ext_part = ext_part;                           
        new_part_desc->disk_desc = ext_part->disk_desc;               
                                                                      
        if (is_extended(new_part_desc->sys_type))                     
        {                                                             
            new_part_desc->log_id = EMPTY_PARTITION;                  
400047dc:	c0 2a a0 02 	clrb  [ %o2 + 2 ]                              
            new_part_desc->start += start;                            
400047e0:	82 00 40 19 	add  %g1, %i1, %g1                             
            read_extended_partition(fd, start, new_part_desc);        
400047e4:	90 10 00 1d 	mov  %i5, %o0                                  
        new_part_desc->disk_desc = ext_part->disk_desc;               
                                                                      
        if (is_extended(new_part_desc->sys_type))                     
        {                                                             
            new_part_desc->log_id = EMPTY_PARTITION;                  
            new_part_desc->start += start;                            
400047e8:	c2 22 a0 04 	st  %g1, [ %o2 + 4 ]                           
            read_extended_partition(fd, start, new_part_desc);        
400047ec:	7f ff ff a2 	call  40004674 <read_extended_partition>       
400047f0:	92 10 00 19 	mov  %i1, %o1                                  
400047f4:	10 bf ff f2 	b  400047bc <read_extended_partition+0x148>    
400047f8:	b8 07 20 04 	add  %i4, 4, %i4                               
                                                                      

400048ec <readv>: ssize_t readv( int fd, const struct iovec *iov, int iovcnt ) {
400048ec:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int            v;                                                   
  int            bytes;                                               
  rtems_libio_t *iop;                                                 
  bool           all_zeros;                                           
                                                                      
  rtems_libio_check_fd( fd );                                         
400048f0:	03 10 00 5d 	sethi  %hi(0x40017400), %g1                    
400048f4:	c2 00 63 d4 	ld  [ %g1 + 0x3d4 ], %g1	! 400177d4 <rtems_libio_number_iops>
400048f8:	80 a6 00 01 	cmp  %i0, %g1                                  
400048fc:	1a 80 00 45 	bcc  40004a10 <readv+0x124>                    
40004900:	03 10 00 60 	sethi  %hi(0x40018000), %g1                    
  iop = rtems_libio_iop( fd );                                        
40004904:	f6 00 61 2c 	ld  [ %g1 + 0x12c ], %i3	! 4001812c <rtems_libio_iops>
40004908:	83 2e 20 03 	sll  %i0, 3, %g1                               
4000490c:	b1 2e 20 06 	sll  %i0, 6, %i0                               
40004910:	b0 26 00 01 	sub  %i0, %g1, %i0                             
40004914:	b6 06 c0 18 	add  %i3, %i0, %i3                             
  rtems_libio_check_is_open( iop );                                   
40004918:	c2 06 e0 10 	ld  [ %i3 + 0x10 ], %g1                        
4000491c:	80 88 61 00 	btst  0x100, %g1                               
40004920:	02 80 00 3c 	be  40004a10 <readv+0x124>                     
40004924:	80 88 60 02 	btst  2, %g1                                   
  rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
40004928:	02 80 00 3a 	be  40004a10 <readv+0x124>                     <== NEVER TAKEN
4000492c:	80 a6 60 00 	cmp  %i1, 0                                    
                                                                      
  /*                                                                  
   *  Argument validation on IO vector                                
   */                                                                 
  if ( !iov )                                                         
40004930:	02 80 00 32 	be  400049f8 <readv+0x10c>                     
40004934:	80 a6 a0 00 	cmp  %i2, 0                                    
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( iovcnt <= 0 )                                                  
40004938:	04 80 00 30 	ble  400049f8 <readv+0x10c>                    
4000493c:	80 a6 a4 00 	cmp  %i2, 0x400                                
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( iovcnt > IOV_MAX )                                             
40004940:	14 80 00 2e 	bg  400049f8 <readv+0x10c>                     <== NEVER TAKEN
40004944:	b5 2e a0 03 	sll  %i2, 3, %i2                               
 *                                                                    
 *  OpenGroup URL:                                                    
 *                                                                    
 *  http://www.opengroup.org/onlinepubs/009695399/functions/readv.html
 */                                                                   
ssize_t readv(                                                        
40004948:	82 10 20 00 	clr  %g1                                       
4000494c:	ba 10 20 01 	mov  1, %i5                                    
40004950:	10 80 00 03 	b  4000495c <readv+0x70>                       
40004954:	84 10 20 00 	clr  %g2                                       
    if ( iov[v].iov_base == 0 )                                       
      rtems_set_errno_and_return_minus_one( EINVAL );                 
                                                                      
    /* check for wrap */                                              
    old    = total;                                                   
    total += iov[v].iov_len;                                          
40004958:	84 10 00 04 	mov  %g4, %g2                                  
                                                                      
    /*                                                                
     *  iov[v].iov_len cannot be less than 0 because size_t is unsigned.
     *  So we only check for zero.                                    
     */                                                               
    if ( iov[v].iov_base == 0 )                                       
4000495c:	c6 06 40 01 	ld  [ %i1 + %g1 ], %g3                         
40004960:	80 a0 e0 00 	cmp  %g3, 0                                    
40004964:	02 80 00 25 	be  400049f8 <readv+0x10c>                     
40004968:	88 06 40 01 	add  %i1, %g1, %g4                             
      rtems_set_errno_and_return_minus_one( EINVAL );                 
                                                                      
    /* check for wrap */                                              
    old    = total;                                                   
    total += iov[v].iov_len;                                          
4000496c:	c6 01 20 04 	ld  [ %g4 + 4 ], %g3                           
40004970:	88 00 c0 02 	add  %g3, %g2, %g4                             
    if ( total < old )                                                
40004974:	80 a1 00 02 	cmp  %g4, %g2                                  
40004978:	06 80 00 20 	bl  400049f8 <readv+0x10c>                     
4000497c:	82 00 60 08 	add  %g1, 8, %g1                               
      rtems_set_errno_and_return_minus_one( EINVAL );                 
                                                                      
    if ( iov[v].iov_len )                                             
      all_zeros = false;                                              
40004980:	80 a0 00 03 	cmp  %g0, %g3                                  
40004984:	84 40 3f ff 	addx  %g0, -1, %g2                             
   *  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++ ) {                           
40004988:	80 a0 40 1a 	cmp  %g1, %i2                                  
4000498c:	12 bf ff f3 	bne  40004958 <readv+0x6c>                     
40004990:	ba 0f 40 02 	and  %i5, %g2, %i5                             
  /*                                                                  
   *  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 ) {                                          
40004994:	80 8f 60 ff 	btst  0xff, %i5                                
40004998:	12 80 00 16 	bne  400049f0 <readv+0x104>                    
4000499c:	b0 10 20 00 	clr  %i0                                       
400049a0:	ba 10 20 00 	clr  %i5                                       
                                                                      
  /*                                                                  
   *  Now process the readv().                                        
   */                                                                 
  for ( total=0, v=0 ; v < iovcnt ; v++ ) {                           
    bytes = (*iop->pathinfo.handlers->read_h)(                        
400049a4:	c2 06 e0 24 	ld  [ %i3 + 0x24 ], %g1                        
 *                                                                    
 *  OpenGroup URL:                                                    
 *                                                                    
 *  http://www.opengroup.org/onlinepubs/009695399/functions/readv.html
 */                                                                   
ssize_t readv(                                                        
400049a8:	b8 06 40 1d 	add  %i1, %i5, %i4                             
                                                                      
  /*                                                                  
   *  Now process the readv().                                        
   */                                                                 
  for ( total=0, v=0 ; v < iovcnt ; v++ ) {                           
    bytes = (*iop->pathinfo.handlers->read_h)(                        
400049ac:	d2 06 40 1d 	ld  [ %i1 + %i5 ], %o1                         
400049b0:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
400049b4:	d4 07 20 04 	ld  [ %i4 + 4 ], %o2                           
400049b8:	9f c0 40 00 	call  %g1                                      
400049bc:	90 10 00 1b 	mov  %i3, %o0                                  
      iop,                                                            
      iov[v].iov_base,                                                
      iov[v].iov_len                                                  
    );                                                                
                                                                      
    if ( bytes < 0 )                                                  
400049c0:	80 a2 20 00 	cmp  %o0, 0                                    
400049c4:	26 80 00 0b 	bl,a   400049f0 <readv+0x104>                  <== NEVER TAKEN
400049c8:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
      return -1;                                                      
                                                                      
    if ( bytes > 0 ) {                                                
400049cc:	32 80 00 02 	bne,a   400049d4 <readv+0xe8>                  <== ALWAYS TAKEN
400049d0:	b0 06 00 08 	add  %i0, %o0, %i0                             
      total       += bytes;                                           
    }                                                                 
                                                                      
    if (bytes != iov[ v ].iov_len)                                    
400049d4:	c2 07 20 04 	ld  [ %i4 + 4 ], %g1                           
400049d8:	80 a2 00 01 	cmp  %o0, %g1                                  
400049dc:	12 80 00 05 	bne  400049f0 <readv+0x104>                    <== NEVER TAKEN
400049e0:	ba 07 60 08 	add  %i5, 8, %i5                               
  }                                                                   
                                                                      
  /*                                                                  
   *  Now process the readv().                                        
   */                                                                 
  for ( total=0, v=0 ; v < iovcnt ; v++ ) {                           
400049e4:	80 a6 80 1d 	cmp  %i2, %i5                                  
400049e8:	32 bf ff f0 	bne,a   400049a8 <readv+0xbc>                  
400049ec:	c2 06 e0 24 	ld  [ %i3 + 0x24 ], %g1                        
400049f0:	81 c7 e0 08 	ret                                            
400049f4:	81 e8 00 00 	restore                                        
                                                                      
    /* check for wrap */                                              
    old    = total;                                                   
    total += iov[v].iov_len;                                          
    if ( total < old )                                                
      rtems_set_errno_and_return_minus_one( EINVAL );                 
400049f8:	40 00 2d a3 	call  40010084 <__errno>                       
400049fc:	b0 10 3f ff 	mov  -1, %i0                                   
40004a00:	82 10 20 16 	mov  0x16, %g1                                 
40004a04:	c2 22 00 00 	st  %g1, [ %o0 ]                               
40004a08:	81 c7 e0 08 	ret                                            
40004a0c:	81 e8 00 00 	restore                                        
  bool           all_zeros;                                           
                                                                      
  rtems_libio_check_fd( fd );                                         
  iop = rtems_libio_iop( fd );                                        
  rtems_libio_check_is_open( iop );                                   
  rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
40004a10:	40 00 2d 9d 	call  40010084 <__errno>                       
40004a14:	b0 10 3f ff 	mov  -1, %i0                                   
40004a18:	82 10 20 09 	mov  9, %g1                                    
40004a1c:	c2 22 00 00 	st  %g1, [ %o0 ]                               
40004a20:	81 c7 e0 08 	ret                                            
40004a24:	81 e8 00 00 	restore                                        
                                                                      

4001b7cc <realloc>: void *realloc( void *ptr, size_t size ) {
4001b7cc:	9d e3 bf 98 	save  %sp, -104, %sp                           
  uintptr_t old_size;                                                 
  char    *new_area;                                                  
                                                                      
  MSBUMP(realloc_calls, 1);                                           
4001b7d0:	3b 10 00 7b 	sethi  %hi(0x4001ec00), %i5                    
4001b7d4:	ba 17 61 40 	or  %i5, 0x140, %i5	! 4001ed40 <rtems_malloc_statistics>
4001b7d8:	c4 07 60 10 	ld  [ %i5 + 0x10 ], %g2                        
                                                                      
  /*                                                                  
   *  Do not attempt to allocate memory if in a critical section or ISR.
   */                                                                 
                                                                      
  if (_System_state_Is_up(_System_state_Get())) {                     
4001b7dc:	03 10 00 7c 	sethi  %hi(0x4001f000), %g1                    
4001b7e0:	c2 00 63 c8 	ld  [ %g1 + 0x3c8 ], %g1	! 4001f3c8 <_System_state_Current>
)                                                                     
{                                                                     
  uintptr_t old_size;                                                 
  char    *new_area;                                                  
                                                                      
  MSBUMP(realloc_calls, 1);                                           
4001b7e4:	84 00 a0 01 	inc  %g2                                       
                                                                      
  /*                                                                  
   *  Do not attempt to allocate memory if in a critical section or ISR.
   */                                                                 
                                                                      
  if (_System_state_Is_up(_System_state_Get())) {                     
4001b7e8:	80 a0 60 03 	cmp  %g1, 3                                    
4001b7ec:	02 80 00 2a 	be  4001b894 <realloc+0xc8>                    
4001b7f0:	c4 27 60 10 	st  %g2, [ %i5 + 0x10 ]                        
  }                                                                   
                                                                      
  /*                                                                  
   * Continue with realloc().                                         
   */                                                                 
  if ( !ptr )                                                         
4001b7f4:	80 a6 20 00 	cmp  %i0, 0                                    
4001b7f8:	02 80 00 46 	be  4001b910 <realloc+0x144>                   
4001b7fc:	80 a6 60 00 	cmp  %i1, 0                                    
    return malloc( size );                                            
                                                                      
  if ( !size ) {                                                      
4001b800:	02 80 00 39 	be  4001b8e4 <realloc+0x118>                   <== NEVER TAKEN
4001b804:	39 10 00 78 	sethi  %hi(0x4001e000), %i4                    
    free( ptr );                                                      
    return (void *) 0;                                                
  }                                                                   
                                                                      
  if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
4001b808:	d0 07 23 60 	ld  [ %i4 + 0x360 ], %o0	! 4001e360 <RTEMS_Malloc_Heap>
4001b80c:	92 10 00 18 	mov  %i0, %o1                                  
4001b810:	40 00 01 d6 	call  4001bf68 <_Protected_heap_Get_block_size>
4001b814:	94 07 bf fc 	add  %fp, -4, %o2                              
4001b818:	80 8a 20 ff 	btst  0xff, %o0                                
4001b81c:	02 80 00 37 	be  4001b8f8 <realloc+0x12c>                   
4001b820:	d0 07 23 60 	ld  [ %i4 + 0x360 ], %o0                       
  }                                                                   
                                                                      
  /*                                                                  
   *  Now resize it.                                                  
   */                                                                 
  if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) {
4001b824:	92 10 00 18 	mov  %i0, %o1                                  
4001b828:	40 00 01 de 	call  4001bfa0 <_Protected_heap_Resize_block>  
4001b82c:	94 10 00 19 	mov  %i1, %o2                                  
4001b830:	80 8a 20 ff 	btst  0xff, %o0                                
4001b834:	02 80 00 04 	be  4001b844 <realloc+0x78>                    
4001b838:	01 00 00 00 	nop                                            
  memcpy( new_area, ptr, (size < old_size) ? size : old_size );       
  free( ptr );                                                        
                                                                      
  return new_area;                                                    
                                                                      
}                                                                     
4001b83c:	81 c7 e0 08 	ret                                            
4001b840:	81 e8 00 00 	restore                                        
   *  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 );                                          
4001b844:	7f ff 9e d3 	call  40003390 <malloc>                        
4001b848:	90 10 00 19 	mov  %i1, %o0                                  
                                                                      
  MSBUMP(malloc_calls, (uint32_t) -1);   /* subtract off the malloc */
4001b84c:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
   *  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 );                                          
4001b850:	b8 10 00 08 	mov  %o0, %i4                                  
                                                                      
  MSBUMP(malloc_calls, (uint32_t) -1);   /* subtract off the malloc */
4001b854:	82 00 7f ff 	add  %g1, -1, %g1                              
                                                                      
  if ( !new_area ) {                                                  
4001b858:	80 a2 20 00 	cmp  %o0, 0                                    
4001b85c:	02 80 00 17 	be  4001b8b8 <realloc+0xec>                    
4001b860:	c2 27 60 04 	st  %g1, [ %i5 + 4 ]                           
    return (void *) 0;                                                
  }                                                                   
                                                                      
  memcpy( new_area, ptr, (size < old_size) ? size : old_size );       
4001b864:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4001b868:	80 a6 40 01 	cmp  %i1, %g1                                  
4001b86c:	18 80 00 15 	bgu  4001b8c0 <realloc+0xf4>                   <== ALWAYS TAKEN
4001b870:	94 10 00 19 	mov  %i1, %o2                                  
4001b874:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
4001b878:	7f ff d2 03 	call  40010084 <memcpy>                        <== NOT EXECUTED
4001b87c:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
  free( ptr );                                                        
4001b880:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001b884:	7f ff 9d e9 	call  40003028 <free>                          <== NOT EXECUTED
4001b888:	b0 10 00 1c 	mov  %i4, %i0                                  <== NOT EXECUTED
4001b88c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001b890:	81 e8 00 00 	restore                                        <== NOT EXECUTED
   * This routine returns true if thread dispatch indicates           
   * that we are in a critical section.                               
   */                                                                 
  RTEMS_INLINE_ROUTINE bool _Thread_Dispatch_in_critical_section(void)
  {                                                                   
     if (  _Thread_Dispatch_disable_level == 0 )                      
4001b894:	03 10 00 7b 	sethi  %hi(0x4001ec00), %g1                    
4001b898:	c2 00 62 c0 	ld  [ %g1 + 0x2c0 ], %g1	! 4001eec0 <_Thread_Dispatch_disable_level>
4001b89c:	80 a0 60 00 	cmp  %g1, 0                                    
4001b8a0:	12 80 00 06 	bne  4001b8b8 <realloc+0xec>                   <== NEVER TAKEN
4001b8a4:	03 10 00 7c 	sethi  %hi(0x4001f000), %g1                    
                                                                      
  if (_System_state_Is_up(_System_state_Get())) {                     
    if (_Thread_Dispatch_in_critical_section())                       
      return (void *) 0;                                              
                                                                      
    if (_ISR_Nest_level > 0)                                          
4001b8a8:	c2 00 63 d8 	ld  [ %g1 + 0x3d8 ], %g1	! 4001f3d8 <_Per_CPU_Information+0x8>
4001b8ac:	80 a0 60 00 	cmp  %g1, 0                                    
4001b8b0:	02 bf ff d2 	be  4001b7f8 <realloc+0x2c>                    <== ALWAYS TAKEN
4001b8b4:	80 a6 20 00 	cmp  %i0, 0                                    
   *  Do not attempt to allocate memory if in a critical section or ISR.
   */                                                                 
                                                                      
  if (_System_state_Is_up(_System_state_Get())) {                     
    if (_Thread_Dispatch_in_critical_section())                       
      return (void *) 0;                                              
4001b8b8:	81 c7 e0 08 	ret                                            
4001b8bc:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      
  if ( !new_area ) {                                                  
    return (void *) 0;                                                
  }                                                                   
                                                                      
  memcpy( new_area, ptr, (size < old_size) ? size : old_size );       
4001b8c0:	92 10 00 18 	mov  %i0, %o1                                  
4001b8c4:	94 10 00 01 	mov  %g1, %o2                                  
4001b8c8:	7f ff d1 ef 	call  40010084 <memcpy>                        
4001b8cc:	90 10 00 1c 	mov  %i4, %o0                                  
  free( ptr );                                                        
4001b8d0:	90 10 00 18 	mov  %i0, %o0                                  
4001b8d4:	7f ff 9d d5 	call  40003028 <free>                          
4001b8d8:	b0 10 00 1c 	mov  %i4, %i0                                  
4001b8dc:	81 c7 e0 08 	ret                                            
4001b8e0:	81 e8 00 00 	restore                                        
   */                                                                 
  if ( !ptr )                                                         
    return malloc( size );                                            
                                                                      
  if ( !size ) {                                                      
    free( ptr );                                                      
4001b8e4:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001b8e8:	7f ff 9d d0 	call  40003028 <free>                          <== NOT EXECUTED
4001b8ec:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
4001b8f0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001b8f4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    return (void *) 0;                                                
  }                                                                   
                                                                      
  if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
    errno = EINVAL;                                                   
4001b8f8:	7f ff cf 92 	call  4000f740 <__errno>                       
4001b8fc:	b0 10 20 00 	clr  %i0                                       
4001b900:	82 10 20 16 	mov  0x16, %g1                                 
4001b904:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4001b908:	81 c7 e0 08 	ret                                            
4001b90c:	81 e8 00 00 	restore                                        
                                                                      
  /*                                                                  
   * Continue with realloc().                                         
   */                                                                 
  if ( !ptr )                                                         
    return malloc( size );                                            
4001b910:	7f ff 9e a0 	call  40003390 <malloc>                        
4001b914:	91 e8 00 19 	restore  %g0, %i1, %o0                         
                                                                      

400078f4 <rtems_aio_enqueue>: * errno - otherwise */ int rtems_aio_enqueue (rtems_aio_request *req) {
400078f4:	9d e3 bf 78 	save  %sp, -136, %sp                           
  struct sched_param param;                                           
                                                                      
  /* The queue should be initialized */                               
  AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED);
                                                                      
  result = pthread_mutex_lock (&aio_request_queue.mutex);             
400078f8:	39 10 00 63 	sethi  %hi(0x40018c00), %i4                    
400078fc:	40 00 02 7b 	call  400082e8 <pthread_mutex_lock>            
40007900:	90 17 23 f4 	or  %i4, 0x3f4, %o0	! 40018ff4 <aio_request_queue>
  if (result != 0) {                                                  
40007904:	b6 92 20 00 	orcc  %o0, 0, %i3                              
40007908:	12 80 00 31 	bne  400079cc <rtems_aio_enqueue+0xd8>         <== NEVER TAKEN
4000790c:	90 10 00 18 	mov  %i0, %o0                                  
    return result;                                                    
  }                                                                   
                                                                      
  /* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
     we can use aio_reqprio to lower the priority of the request */   
  pthread_getschedparam (pthread_self(), &policy, ¶m);            
40007910:	40 00 04 b6 	call  40008be8 <pthread_self>                  
40007914:	b2 17 23 f4 	or  %i4, 0x3f4, %i1                            
40007918:	92 07 bf e0 	add  %fp, -32, %o1                             
4000791c:	40 00 03 a8 	call  400087bc <pthread_getschedparam>         
40007920:	94 07 bf e4 	add  %fp, -28, %o2                             
                                                                      
  req->caller_thread = pthread_self ();                               
40007924:	40 00 04 b1 	call  40008be8 <pthread_self>                  
40007928:	01 00 00 00 	nop                                            
  req->priority = param.sched_priority - req->aiocbp->aio_reqprio;    
4000792c:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
  req->policy = policy;                                               
40007930:	c6 07 bf e0 	ld  [ %fp + -32 ], %g3                         
  /* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
     we can use aio_reqprio to lower the priority of the request */   
  pthread_getschedparam (pthread_self(), &policy, ¶m);            
                                                                      
  req->caller_thread = pthread_self ();                               
  req->priority = param.sched_priority - req->aiocbp->aio_reqprio;    
40007934:	c4 00 60 18 	ld  [ %g1 + 0x18 ], %g2                        
  req->policy = policy;                                               
40007938:	c6 26 20 08 	st  %g3, [ %i0 + 8 ]                           
  /* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
     we can use aio_reqprio to lower the priority of the request */   
  pthread_getschedparam (pthread_self(), &policy, ¶m);            
                                                                      
  req->caller_thread = pthread_self ();                               
  req->priority = param.sched_priority - req->aiocbp->aio_reqprio;    
4000793c:	c6 07 bf e4 	ld  [ %fp + -28 ], %g3                         
                                                                      
  /* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
     we can use aio_reqprio to lower the priority of the request */   
  pthread_getschedparam (pthread_self(), &policy, ¶m);            
                                                                      
  req->caller_thread = pthread_self ();                               
40007940:	d0 26 20 10 	st  %o0, [ %i0 + 0x10 ]                        
  req->priority = param.sched_priority - req->aiocbp->aio_reqprio;    
40007944:	84 20 c0 02 	sub  %g3, %g2, %g2                             
40007948:	c4 26 20 0c 	st  %g2, [ %i0 + 0xc ]                         
  req->policy = policy;                                               
  req->aiocbp->error_code = EINPROGRESS;                              
  req->aiocbp->return_value = 0;                                      
                                                                      
  if ((aio_request_queue.idle_threads == 0) &&                        
4000794c:	c4 06 60 68 	ld  [ %i1 + 0x68 ], %g2                        
  pthread_getschedparam (pthread_self(), &policy, ¶m);            
                                                                      
  req->caller_thread = pthread_self ();                               
  req->priority = param.sched_priority - req->aiocbp->aio_reqprio;    
  req->policy = policy;                                               
  req->aiocbp->error_code = EINPROGRESS;                              
40007950:	86 10 20 77 	mov  0x77, %g3                                 
  req->aiocbp->return_value = 0;                                      
40007954:	c0 20 60 38 	clr  [ %g1 + 0x38 ]                            
  pthread_getschedparam (pthread_self(), &policy, ¶m);            
                                                                      
  req->caller_thread = pthread_self ();                               
  req->priority = param.sched_priority - req->aiocbp->aio_reqprio;    
  req->policy = policy;                                               
  req->aiocbp->error_code = EINPROGRESS;                              
40007958:	c6 20 60 34 	st  %g3, [ %g1 + 0x34 ]                        
  req->aiocbp->return_value = 0;                                      
                                                                      
  if ((aio_request_queue.idle_threads == 0) &&                        
4000795c:	80 a0 a0 00 	cmp  %g2, 0                                    
40007960:	12 80 00 06 	bne  40007978 <rtems_aio_enqueue+0x84>         <== NEVER TAKEN
40007964:	d2 00 40 00 	ld  [ %g1 ], %o1                               
40007968:	c4 06 60 64 	ld  [ %i1 + 0x64 ], %g2                        
4000796c:	80 a0 a0 04 	cmp  %g2, 4                                    
40007970:	24 80 00 1b 	ble,a   400079dc <rtems_aio_enqueue+0xe8>      
40007974:	90 06 60 48 	add  %i1, 0x48, %o0                            
  else                                                                
    {                                                                 
      /* the maximum number of threads has been already created       
	 even though some of them might be idle.                             
	 The request belongs to one of the active fd chain */                
      r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,     
40007978:	94 10 20 00 	clr  %o2                                       
4000797c:	11 10 00 64 	sethi  %hi(0x40019000), %o0                    
40007980:	7f ff ff 78 	call  40007760 <rtems_aio_search_fd>           
40007984:	90 12 20 3c 	or  %o0, 0x3c, %o0	! 4001903c <aio_request_queue+0x48>
				     req->aiocbp->aio_fildes, 0);                                 
      if (r_chain != NULL)                                            
40007988:	b4 92 20 00 	orcc  %o0, 0, %i2                              
4000798c:	22 80 00 31 	be,a   40007a50 <rtems_aio_enqueue+0x15c>      
40007990:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
	{                                                                    
	  pthread_mutex_lock (&r_chain->mutex);                              
40007994:	b2 06 a0 1c 	add  %i2, 0x1c, %i1                            
40007998:	40 00 02 54 	call  400082e8 <pthread_mutex_lock>            
4000799c:	90 10 00 19 	mov  %i1, %o0                                  
	  rtems_aio_insert_prio (&r_chain->perfd, req);                      
400079a0:	90 06 a0 08 	add  %i2, 8, %o0                               
400079a4:	7f ff ff 12 	call  400075ec <rtems_aio_insert_prio>         
400079a8:	92 10 00 18 	mov  %i0, %o1                                  
	  pthread_cond_signal (&r_chain->cond);                              
400079ac:	40 00 01 2c 	call  40007e5c <pthread_cond_signal>           
400079b0:	90 06 a0 20 	add  %i2, 0x20, %o0                            
	  pthread_mutex_unlock (&r_chain->mutex);                            
400079b4:	40 00 02 6d 	call  40008368 <pthread_mutex_unlock>          
400079b8:	90 10 00 19 	mov  %i1, %o0                                  
	if (aio_request_queue.idle_threads > 0)                              
	  pthread_cond_signal (&aio_request_queue.new_req);                  
      }                                                               
    }                                                                 
                                                                      
  pthread_mutex_unlock (&aio_request_queue.mutex);                    
400079bc:	40 00 02 6b 	call  40008368 <pthread_mutex_unlock>          
400079c0:	90 17 23 f4 	or  %i4, 0x3f4, %o0                            
  return 0;                                                           
}                                                                     
400079c4:	81 c7 e0 08 	ret                                            
400079c8:	91 e8 00 1b 	restore  %g0, %i3, %o0                         
  /* The queue should be initialized */                               
  AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED);
                                                                      
  result = pthread_mutex_lock (&aio_request_queue.mutex);             
  if (result != 0) {                                                  
    free (req);                                                       
400079cc:	7f ff ee 4c 	call  400032fc <free>                          <== NOT EXECUTED
400079d0:	b0 10 00 1b 	mov  %i3, %i0                                  <== NOT EXECUTED
      }                                                               
    }                                                                 
                                                                      
  pthread_mutex_unlock (&aio_request_queue.mutex);                    
  return 0;                                                           
}                                                                     
400079d4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400079d8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  if ((aio_request_queue.idle_threads == 0) &&                        
      aio_request_queue.active_threads < AIO_MAX_THREADS)             
    /* we still have empty places on the active_threads chain */      
    {                                                                 
      chain = &aio_request_queue.work_req;                            
      r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
400079dc:	7f ff ff 61 	call  40007760 <rtems_aio_search_fd>           
400079e0:	94 10 20 01 	mov  1, %o2                                    
                                                                      
      if (r_chain->new_fd == 1) {                                     
400079e4:	c2 02 20 18 	ld  [ %o0 + 0x18 ], %g1                        
400079e8:	80 a0 60 01 	cmp  %g1, 1                                    
400079ec:	12 bf ff ea 	bne  40007994 <rtems_aio_enqueue+0xa0>         
400079f0:	b4 10 00 08 	mov  %o0, %i2                                  
RTEMS_INLINE_ROUTINE void _Chain_Prepend(                             
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  _Chain_Insert(_Chain_Head(the_chain), the_node);                    
400079f4:	90 02 20 08 	add  %o0, 8, %o0                               
400079f8:	40 00 09 44 	call  40009f08 <_Chain_Insert>                 
400079fc:	92 10 00 18 	mov  %i0, %o1                                  
	rtems_chain_prepend (&r_chain->perfd, &req->next_prio);              
	r_chain->new_fd = 0;                                                 
	pthread_mutex_init (&r_chain->mutex, NULL);                          
40007a00:	92 10 20 00 	clr  %o1                                       
      chain = &aio_request_queue.work_req;                            
      r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
                                                                      
      if (r_chain->new_fd == 1) {                                     
	rtems_chain_prepend (&r_chain->perfd, &req->next_prio);              
	r_chain->new_fd = 0;                                                 
40007a04:	c0 26 a0 18 	clr  [ %i2 + 0x18 ]                            
	pthread_mutex_init (&r_chain->mutex, NULL);                          
40007a08:	40 00 01 df 	call  40008184 <pthread_mutex_init>            
40007a0c:	90 06 a0 1c 	add  %i2, 0x1c, %o0                            
	pthread_cond_init (&r_chain->cond, NULL);                            
40007a10:	92 10 20 00 	clr  %o1                                       
40007a14:	40 00 00 e3 	call  40007da0 <pthread_cond_init>             
40007a18:	90 06 a0 20 	add  %i2, 0x20, %o0                            
	                                                                     
	AIO_printf ("New thread \n");                                        
	result = pthread_create (&thid, &aio_request_queue.attr,             
40007a1c:	90 07 bf dc 	add  %fp, -36, %o0                             
40007a20:	92 06 60 08 	add  %i1, 8, %o1                               
40007a24:	96 10 00 1a 	mov  %i2, %o3                                  
40007a28:	15 10 00 1c 	sethi  %hi(0x40007000), %o2                    
40007a2c:	40 00 02 c4 	call  4000853c <pthread_create>                
40007a30:	94 12 a3 40 	or  %o2, 0x340, %o2	! 40007340 <rtems_aio_handle>
				 rtems_aio_handle, (void *) r_chain);                             
	if (result != 0) {                                                   
40007a34:	82 92 20 00 	orcc  %o0, 0, %g1                              
40007a38:	12 80 00 25 	bne  40007acc <rtems_aio_enqueue+0x1d8>        <== NEVER TAKEN
40007a3c:	90 10 00 19 	mov  %i1, %o0                                  
	  pthread_mutex_unlock (&aio_request_queue.mutex);                   
	  return result;                                                     
	}                                                                    
	++aio_request_queue.active_threads;                                  
40007a40:	c2 06 60 64 	ld  [ %i1 + 0x64 ], %g1                        
40007a44:	82 00 60 01 	inc  %g1                                       
40007a48:	10 bf ff dd 	b  400079bc <rtems_aio_enqueue+0xc8>           
40007a4c:	c2 26 60 64 	st  %g1, [ %i1 + 0x64 ]                        
	                                                                     
	} else {                                                             
                                                                      
	/* or to the idle chain */                                           
	chain = &aio_request_queue.idle_req;                                 
	r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);   
40007a50:	11 10 00 64 	sethi  %hi(0x40019000), %o0                    
40007a54:	d2 00 40 00 	ld  [ %g1 ], %o1                               
40007a58:	90 12 20 48 	or  %o0, 0x48, %o0                             
40007a5c:	7f ff ff 41 	call  40007760 <rtems_aio_search_fd>           
40007a60:	94 10 20 01 	mov  1, %o2                                    
                                                                      
	if (r_chain->new_fd == 1) {                                          
40007a64:	c2 02 20 18 	ld  [ %o0 + 0x18 ], %g1                        
	                                                                     
	} else {                                                             
                                                                      
	/* or to the idle chain */                                           
	chain = &aio_request_queue.idle_req;                                 
	r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);   
40007a68:	b4 10 00 08 	mov  %o0, %i2                                  
40007a6c:	92 10 00 18 	mov  %i0, %o1                                  
                                                                      
	if (r_chain->new_fd == 1) {                                          
40007a70:	80 a0 60 01 	cmp  %g1, 1                                    
40007a74:	02 80 00 0b 	be  40007aa0 <rtems_aio_enqueue+0x1ac>         
40007a78:	90 02 20 08 	add  %o0, 8, %o0                               
	  r_chain->new_fd = 0;                                               
	  pthread_mutex_init (&r_chain->mutex, NULL);                        
	  pthread_cond_init (&r_chain->cond, NULL);                          
	} else                                                               
	  /* just insert the request in the existing fd chain */             
	  rtems_aio_insert_prio (&r_chain->perfd, req);                      
40007a7c:	7f ff fe dc 	call  400075ec <rtems_aio_insert_prio>         
40007a80:	01 00 00 00 	nop                                            
	if (aio_request_queue.idle_threads > 0)                              
40007a84:	c2 06 60 68 	ld  [ %i1 + 0x68 ], %g1                        
40007a88:	80 a0 60 00 	cmp  %g1, 0                                    
40007a8c:	04 bf ff cc 	ble  400079bc <rtems_aio_enqueue+0xc8>         <== ALWAYS TAKEN
40007a90:	01 00 00 00 	nop                                            
	  pthread_cond_signal (&aio_request_queue.new_req);                  
40007a94:	40 00 00 f2 	call  40007e5c <pthread_cond_signal>           <== NOT EXECUTED
40007a98:	90 06 60 04 	add  %i1, 4, %o0                               <== NOT EXECUTED
40007a9c:	30 bf ff c8 	b,a   400079bc <rtems_aio_enqueue+0xc8>        <== NOT EXECUTED
40007aa0:	40 00 09 1a 	call  40009f08 <_Chain_Insert>                 
40007aa4:	01 00 00 00 	nop                                            
	  /* If this is a new fd chain we signal the idle threads that       
	     might be waiting for requests */                                
	  AIO_printf (" New chain on waiting queue \n ");                    
	  rtems_chain_prepend (&r_chain->perfd, &req->next_prio);            
	  r_chain->new_fd = 0;                                               
	  pthread_mutex_init (&r_chain->mutex, NULL);                        
40007aa8:	90 06 a0 1c 	add  %i2, 0x1c, %o0                            
	if (r_chain->new_fd == 1) {                                          
	  /* If this is a new fd chain we signal the idle threads that       
	     might be waiting for requests */                                
	  AIO_printf (" New chain on waiting queue \n ");                    
	  rtems_chain_prepend (&r_chain->perfd, &req->next_prio);            
	  r_chain->new_fd = 0;                                               
40007aac:	c0 26 a0 18 	clr  [ %i2 + 0x18 ]                            
	  pthread_mutex_init (&r_chain->mutex, NULL);                        
40007ab0:	40 00 01 b5 	call  40008184 <pthread_mutex_init>            
40007ab4:	92 10 20 00 	clr  %o1                                       
	  pthread_cond_init (&r_chain->cond, NULL);                          
40007ab8:	90 06 a0 20 	add  %i2, 0x20, %o0                            
40007abc:	40 00 00 b9 	call  40007da0 <pthread_cond_init>             
40007ac0:	92 10 20 00 	clr  %o1                                       
	} else                                                               
	  /* just insert the request in the existing fd chain */             
	  rtems_aio_insert_prio (&r_chain->perfd, req);                      
	if (aio_request_queue.idle_threads > 0)                              
40007ac4:	10 bf ff f1 	b  40007a88 <rtems_aio_enqueue+0x194>          
40007ac8:	c2 06 60 68 	ld  [ %i1 + 0x68 ], %g1                        
	                                                                     
	AIO_printf ("New thread \n");                                        
	result = pthread_create (&thid, &aio_request_queue.attr,             
				 rtems_aio_handle, (void *) r_chain);                             
	if (result != 0) {                                                   
	  pthread_mutex_unlock (&aio_request_queue.mutex);                   
40007acc:	40 00 02 27 	call  40008368 <pthread_mutex_unlock>          <== NOT EXECUTED
40007ad0:	b6 10 00 01 	mov  %g1, %i3                                  <== NOT EXECUTED
40007ad4:	30 bf ff bc 	b,a   400079c4 <rtems_aio_enqueue+0xd0>        <== NOT EXECUTED
                                                                      

40007340 <rtems_aio_handle>: * NULL - if error */ static void * rtems_aio_handle (void *arg) {
40007340:	9d e3 bf 78 	save  %sp, -136, %sp                           
      struct timespec timeout;                                        
                                                                      
      AIO_printf ("Chain is empty [WQ], wait for work\n");            
                                                                      
      pthread_mutex_unlock (&r_chain->mutex);                         
      pthread_mutex_lock (&aio_request_queue.mutex);                  
40007344:	35 10 00 63 	sethi  %hi(0x40018c00), %i2                    
40007348:	b6 06 20 1c 	add  %i0, 0x1c, %i3                            
4000734c:	b4 16 a3 f4 	or  %i2, 0x3f4, %i2                            
      if (rtems_chain_is_empty (chain))                               
	{                                                                    
	  clock_gettime (CLOCK_REALTIME, &timeout);                          
	  timeout.tv_sec += 3;                                               
	  timeout.tv_nsec = 0;                                               
	  result = pthread_cond_timedwait (&r_chain->cond,                   
40007350:	a0 10 00 1a 	mov  %i2, %l0                                  
40007354:	a2 10 00 1a 	mov  %i2, %l1                                  
	    pthread_cond_destroy (&r_chain->cond);                           
	    free (r_chain);                                                  
	                                                                     
	    /* If the idle chain is empty sleep for 3 seconds and wait for a 
	       signal. The thread now becomes idle. */                       
	    if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {        
40007358:	a4 06 a0 58 	add  %i2, 0x58, %l2                            
  rtems_chain_node *node;                                             
                                                                      
  node = rtems_chain_first (&aio_request_queue.work_req);             
  temp = (rtems_aio_request_chain *) node;                            
                                                                      
  while (temp->fildes < r_chain->fildes &&                            
4000735c:	b2 06 a0 4c 	add  %i2, 0x4c, %i1                            
    /* acquire the mutex of the current fd chain.                     
       we don't need to lock the queue mutex since we can             
       add requests to idle fd chains or even active ones             
       if the working request has been extracted from the             
       chain */                                                       
    result = pthread_mutex_lock (&r_chain->mutex);                    
40007360:	40 00 03 e2 	call  400082e8 <pthread_mutex_lock>            
40007364:	90 10 00 1b 	mov  %i3, %o0                                  
    if (result != 0)                                                  
40007368:	80 a2 20 00 	cmp  %o0, 0                                    
4000736c:	12 80 00 2b 	bne  40007418 <rtems_aio_handle+0xd8>          <== NEVER TAKEN
40007370:	01 00 00 00 	nop                                            
40007374:	fa 06 20 08 	ld  [ %i0 + 8 ], %i5                           
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
40007378:	82 06 20 0c 	add  %i0, 0xc, %g1                             
                                                                      
    /* If the locked chain is not empty, take the first               
       request extract it, unlock the chain and process               
       the request, in this way the user can supply more              
       requests to this fd chain */                                   
    if (!rtems_chain_is_empty (chain)) {                              
4000737c:	80 a7 40 01 	cmp  %i5, %g1                                  
40007380:	02 80 00 41 	be  40007484 <rtems_aio_handle+0x144>          
40007384:	01 00 00 00 	nop                                            
      node = rtems_chain_first (chain);                               
      req = (rtems_aio_request *) node;                               
                                                                      
      /* See _POSIX_PRIORITIZE_IO and _POSIX_PRIORITY_SCHEDULING      
	 discussion in rtems_aio_enqueue () */                               
      pthread_getschedparam (pthread_self(), &policy, ¶m);        
40007388:	40 00 06 18 	call  40008be8 <pthread_self>                  
4000738c:	01 00 00 00 	nop                                            
40007390:	92 07 bf d8 	add  %fp, -40, %o1                             
40007394:	40 00 05 0a 	call  400087bc <pthread_getschedparam>         
40007398:	94 07 bf e4 	add  %fp, -28, %o2                             
      param.sched_priority = req->priority;                           
4000739c:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
      pthread_setschedparam (pthread_self(), req->policy, ¶m);    
400073a0:	40 00 06 12 	call  40008be8 <pthread_self>                  
400073a4:	c2 27 bf e4 	st  %g1, [ %fp + -28 ]                         
400073a8:	d2 07 60 08 	ld  [ %i5 + 8 ], %o1                           
400073ac:	40 00 06 13 	call  40008bf8 <pthread_setschedparam>         
400073b0:	94 07 bf e4 	add  %fp, -28, %o2                             
400073b4:	40 00 0a bc 	call  40009ea4 <_Chain_Extract>                
400073b8:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
      rtems_chain_extract (node);                                     
                                                                      
      pthread_mutex_unlock (&r_chain->mutex);                         
400073bc:	40 00 03 eb 	call  40008368 <pthread_mutex_unlock>          
400073c0:	90 10 00 1b 	mov  %i3, %o0                                  
                                                                      
      switch (req->aiocbp->aio_lio_opcode) {                          
400073c4:	f8 07 60 14 	ld  [ %i5 + 0x14 ], %i4                        
400073c8:	c2 07 20 30 	ld  [ %i4 + 0x30 ], %g1                        
400073cc:	80 a0 60 02 	cmp  %g1, 2                                    
400073d0:	22 80 00 25 	be,a   40007464 <rtems_aio_handle+0x124>       
400073d4:	c4 1f 20 08 	ldd  [ %i4 + 8 ], %g2                          
400073d8:	80 a0 60 03 	cmp  %g1, 3                                    
400073dc:	02 80 00 1e 	be  40007454 <rtems_aio_handle+0x114>          <== NEVER TAKEN
400073e0:	01 00 00 00 	nop                                            
400073e4:	80 a0 60 01 	cmp  %g1, 1                                    
400073e8:	22 80 00 0e 	be,a   40007420 <rtems_aio_handle+0xe0>        <== ALWAYS TAKEN
400073ec:	c4 1f 20 08 	ldd  [ %i4 + 8 ], %g2                          
                                                                      
      default:                                                        
        result = -1;                                                  
      }                                                               
      if (result == -1) {                                             
        req->aiocbp->return_value = -1;                               
400073f0:	82 10 3f ff 	mov  -1, %g1                                   <== NOT EXECUTED
	req->aiocbp->error_code = errno;                                     
400073f4:	40 00 29 13 	call  40011840 <__errno>                       <== NOT EXECUTED
400073f8:	c2 27 20 38 	st  %g1, [ %i4 + 0x38 ]                        <== NOT EXECUTED
400073fc:	c2 02 00 00 	ld  [ %o0 ], %g1                               <== NOT EXECUTED
    /* acquire the mutex of the current fd chain.                     
       we don't need to lock the queue mutex since we can             
       add requests to idle fd chains or even active ones             
       if the working request has been extracted from the             
       chain */                                                       
    result = pthread_mutex_lock (&r_chain->mutex);                    
40007400:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
40007404:	40 00 03 b9 	call  400082e8 <pthread_mutex_lock>            <== NOT EXECUTED
40007408:	c2 27 20 34 	st  %g1, [ %i4 + 0x34 ]                        <== NOT EXECUTED
    if (result != 0)                                                  
4000740c:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40007410:	22 bf ff da 	be,a   40007378 <rtems_aio_handle+0x38>        <== NOT EXECUTED
40007414:	fa 06 20 08 	ld  [ %i0 + 8 ], %i5                           <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  AIO_printf ("Thread finished\n");                                   
  return NULL;                                                        
}                                                                     
40007418:	81 c7 e0 08 	ret                                            
4000741c:	91 e8 20 00 	restore  %g0, 0, %o0                           
      pthread_mutex_unlock (&r_chain->mutex);                         
                                                                      
      switch (req->aiocbp->aio_lio_opcode) {                          
      case LIO_READ:                                                  
	AIO_printf ("read\n");                                               
        result = pread (req->aiocbp->aio_fildes,                      
40007420:	d0 07 00 00 	ld  [ %i4 ], %o0                               
40007424:	d2 07 20 10 	ld  [ %i4 + 0x10 ], %o1                        
40007428:	d4 07 20 14 	ld  [ %i4 + 0x14 ], %o2                        
4000742c:	96 10 00 02 	mov  %g2, %o3                                  
40007430:	40 00 2b f0 	call  400123f0 <pread>                         
40007434:	98 10 00 03 	mov  %g3, %o4                                  
      	break;                                                         
                                                                      
      default:                                                        
        result = -1;                                                  
      }                                                               
      if (result == -1) {                                             
40007438:	80 a2 3f ff 	cmp  %o0, -1                                   
4000743c:	22 bf ff ed 	be,a   400073f0 <rtems_aio_handle+0xb0>        <== NEVER TAKEN
40007440:	f8 07 60 14 	ld  [ %i5 + 0x14 ], %i4                        <== NOT EXECUTED
        req->aiocbp->return_value = -1;                               
	req->aiocbp->error_code = errno;                                     
      } else {                                                        
        req->aiocbp->return_value = result;                           
40007444:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
40007448:	d0 20 60 38 	st  %o0, [ %g1 + 0x38 ]                        
        req->aiocbp->error_code = 0;                                  
4000744c:	10 bf ff c5 	b  40007360 <rtems_aio_handle+0x20>            
40007450:	c0 20 60 34 	clr  [ %g1 + 0x34 ]                            
                         req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
        break;                                                        
                                                                      
      case LIO_SYNC:                                                  
	AIO_printf ("sync\n");                                               
      	result = fsync (req->aiocbp->aio_fildes);                      
40007454:	40 00 1b 79 	call  4000e238 <fsync>                         <== NOT EXECUTED
40007458:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
      	break;                                                         
4000745c:	10 bf ff f8 	b  4000743c <rtems_aio_handle+0xfc>            <== NOT EXECUTED
40007460:	80 a2 3f ff 	cmp  %o0, -1                                   <== NOT EXECUTED
                        req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
        break;                                                        
                                                                      
      case LIO_WRITE:                                                 
	AIO_printf ("write\n");                                              
        result = pwrite (req->aiocbp->aio_fildes,                     
40007464:	d0 07 00 00 	ld  [ %i4 ], %o0                               
40007468:	d2 07 20 10 	ld  [ %i4 + 0x10 ], %o1                        
4000746c:	d4 07 20 14 	ld  [ %i4 + 0x14 ], %o2                        
40007470:	96 10 00 02 	mov  %g2, %o3                                  
40007474:	40 00 2c 1d 	call  400124e8 <pwrite>                        
40007478:	98 10 00 03 	mov  %g3, %o4                                  
                         (void *) req->aiocbp->aio_buf,               
                         req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
        break;                                                        
4000747c:	10 bf ff f0 	b  4000743c <rtems_aio_handle+0xfc>            
40007480:	80 a2 3f ff 	cmp  %o0, -1                                   
                                                                      
      struct timespec timeout;                                        
                                                                      
      AIO_printf ("Chain is empty [WQ], wait for work\n");            
                                                                      
      pthread_mutex_unlock (&r_chain->mutex);                         
40007484:	40 00 03 b9 	call  40008368 <pthread_mutex_unlock>          
40007488:	90 10 00 1b 	mov  %i3, %o0                                  
      pthread_mutex_lock (&aio_request_queue.mutex);                  
4000748c:	40 00 03 97 	call  400082e8 <pthread_mutex_lock>            
40007490:	90 10 00 1a 	mov  %i2, %o0                                  
                                                                      
      if (rtems_chain_is_empty (chain))                               
40007494:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
40007498:	80 a7 40 01 	cmp  %i5, %g1                                  
4000749c:	02 80 00 05 	be  400074b0 <rtems_aio_handle+0x170>          <== ALWAYS TAKEN
400074a0:	92 07 bf dc 	add  %fp, -36, %o1                             
	                                                                     
	  }                                                                  
	}                                                                    
      /* If there was a request added in the initial fd chain then release
	 the mutex and process it */                                         
      pthread_mutex_unlock (&aio_request_queue.mutex);                
400074a4:	40 00 03 b1 	call  40008368 <pthread_mutex_unlock>          
400074a8:	90 10 00 1a 	mov  %i2, %o0                                  
400074ac:	30 bf ff ad 	b,a   40007360 <rtems_aio_handle+0x20>         
      pthread_mutex_unlock (&r_chain->mutex);                         
      pthread_mutex_lock (&aio_request_queue.mutex);                  
                                                                      
      if (rtems_chain_is_empty (chain))                               
	{                                                                    
	  clock_gettime (CLOCK_REALTIME, &timeout);                          
400074b0:	40 00 01 d3 	call  40007bfc <clock_gettime>                 
400074b4:	90 10 20 01 	mov  1, %o0                                    
	  timeout.tv_sec += 3;                                               
400074b8:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1                         
	  timeout.tv_nsec = 0;                                               
400074bc:	c0 27 bf e0 	clr  [ %fp + -32 ]                             
      pthread_mutex_lock (&aio_request_queue.mutex);                  
                                                                      
      if (rtems_chain_is_empty (chain))                               
	{                                                                    
	  clock_gettime (CLOCK_REALTIME, &timeout);                          
	  timeout.tv_sec += 3;                                               
400074c0:	82 00 60 03 	add  %g1, 3, %g1                               
	  timeout.tv_nsec = 0;                                               
	  result = pthread_cond_timedwait (&r_chain->cond,                   
400074c4:	ba 06 20 20 	add  %i0, 0x20, %i5                            
      pthread_mutex_lock (&aio_request_queue.mutex);                  
                                                                      
      if (rtems_chain_is_empty (chain))                               
	{                                                                    
	  clock_gettime (CLOCK_REALTIME, &timeout);                          
	  timeout.tv_sec += 3;                                               
400074c8:	c2 27 bf dc 	st  %g1, [ %fp + -36 ]                         
	  timeout.tv_nsec = 0;                                               
	  result = pthread_cond_timedwait (&r_chain->cond,                   
400074cc:	90 10 00 1d 	mov  %i5, %o0                                  
400074d0:	92 10 00 10 	mov  %l0, %o1                                  
400074d4:	40 00 02 7e 	call  40007ecc <pthread_cond_timedwait>        
400074d8:	94 07 bf dc 	add  %fp, -36, %o2                             
					   &aio_request_queue.mutex,                                     
					   &timeout);                                                    
                                                                      
	  /* If no requests were added to the chain we delete the fd chain from
	     the queue and start working with idle fd chains */              
	  if (result == ETIMEDOUT) {                                         
400074dc:	80 a2 20 74 	cmp  %o0, 0x74                                 
400074e0:	12 bf ff f1 	bne  400074a4 <rtems_aio_handle+0x164>         <== NEVER TAKEN
400074e4:	01 00 00 00 	nop                                            
400074e8:	40 00 0a 6f 	call  40009ea4 <_Chain_Extract>                
400074ec:	90 10 00 18 	mov  %i0, %o0                                  
	    rtems_chain_extract (&r_chain->next_fd);                         
	    pthread_mutex_destroy (&r_chain->mutex);                         
400074f0:	40 00 02 d2 	call  40008038 <pthread_mutex_destroy>         
400074f4:	90 10 00 1b 	mov  %i3, %o0                                  
	    pthread_cond_destroy (&r_chain->cond);                           
400074f8:	40 00 01 f4 	call  40007cc8 <pthread_cond_destroy>          
400074fc:	90 10 00 1d 	mov  %i5, %o0                                  
	    free (r_chain);                                                  
40007500:	7f ff ef 7f 	call  400032fc <free>                          
40007504:	90 10 00 18 	mov  %i0, %o0                                  
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(        
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_head( the_chain )->next;                    
40007508:	f0 06 a0 54 	ld  [ %i2 + 0x54 ], %i0                        
	                                                                     
	    /* If the idle chain is empty sleep for 3 seconds and wait for a 
	       signal. The thread now becomes idle. */                       
	    if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {        
4000750c:	80 a6 00 12 	cmp  %i0, %l2                                  
40007510:	22 80 00 1d 	be,a   40007584 <rtems_aio_handle+0x244>       
40007514:	c4 06 a0 68 	ld  [ %i2 + 0x68 ], %g2                        
	      }                                                              
	    }                                                                
	    /* Otherwise move this chain to the working chain and            
	       start the loop all over again */                              
	    AIO_printf ("Work on idle\n");                                   
	    --aio_request_queue.idle_threads;                                
40007518:	c4 04 60 68 	ld  [ %l1 + 0x68 ], %g2                        
	    ++aio_request_queue.active_threads;                              
4000751c:	c2 04 60 64 	ld  [ %l1 + 0x64 ], %g1                        
	      }                                                              
	    }                                                                
	    /* Otherwise move this chain to the working chain and            
	       start the loop all over again */                              
	    AIO_printf ("Work on idle\n");                                   
	    --aio_request_queue.idle_threads;                                
40007520:	84 00 bf ff 	add  %g2, -1, %g2                              
	    ++aio_request_queue.active_threads;                              
40007524:	82 00 60 01 	inc  %g1                                       
	      }                                                              
	    }                                                                
	    /* Otherwise move this chain to the working chain and            
	       start the loop all over again */                              
	    AIO_printf ("Work on idle\n");                                   
	    --aio_request_queue.idle_threads;                                
40007528:	c4 24 60 68 	st  %g2, [ %l1 + 0x68 ]                        
	    ++aio_request_queue.active_threads;                              
4000752c:	c2 24 60 64 	st  %g1, [ %l1 + 0x64 ]                        
40007530:	40 00 0a 5d 	call  40009ea4 <_Chain_Extract>                
40007534:	90 10 00 18 	mov  %i0, %o0                                  
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return _Chain_Head( the_chain )->next;                              
40007538:	c2 04 60 48 	ld  [ %l1 + 0x48 ], %g1                        
  rtems_chain_node *node;                                             
                                                                      
  node = rtems_chain_first (&aio_request_queue.work_req);             
  temp = (rtems_aio_request_chain *) node;                            
                                                                      
  while (temp->fildes < r_chain->fildes &&                            
4000753c:	c6 06 20 14 	ld  [ %i0 + 0x14 ], %g3                        
40007540:	c4 00 60 14 	ld  [ %g1 + 0x14 ], %g2                        
40007544:	80 a0 c0 02 	cmp  %g3, %g2                                  
40007548:	14 80 00 08 	bg  40007568 <rtems_aio_handle+0x228>          <== ALWAYS TAKEN
4000754c:	80 a0 40 19 	cmp  %g1, %i1                                  
RTEMS_INLINE_ROUTINE void rtems_chain_insert(                         
  rtems_chain_node *after_node,                                       
  rtems_chain_node *the_node                                          
)                                                                     
{                                                                     
  _Chain_Insert( after_node, the_node );                              
40007550:	10 80 00 09 	b  40007574 <rtems_aio_handle+0x234>           <== NOT EXECUTED
40007554:	d0 00 60 04 	ld  [ %g1 + 4 ], %o0                           <== NOT EXECUTED
40007558:	c4 00 60 14 	ld  [ %g1 + 0x14 ], %g2                        
4000755c:	80 a0 80 03 	cmp  %g2, %g3                                  
40007560:	16 80 00 04 	bge  40007570 <rtems_aio_handle+0x230>         
40007564:	80 a0 40 19 	cmp  %g1, %i1                                  
40007568:	32 bf ff fc 	bne,a   40007558 <rtems_aio_handle+0x218>      <== ALWAYS TAKEN
4000756c:	c2 00 40 00 	ld  [ %g1 ], %g1                               
40007570:	d0 00 60 04 	ld  [ %g1 + 4 ], %o0                           
40007574:	92 10 00 18 	mov  %i0, %o1                                  
40007578:	40 00 0a 64 	call  40009f08 <_Chain_Insert>                 
4000757c:	b6 06 20 1c 	add  %i0, 0x1c, %i3                            
40007580:	30 bf ff c9 	b,a   400074a4 <rtems_aio_handle+0x164>        
	       signal. The thread now becomes idle. */                       
	    if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {        
	      AIO_printf ("Chain is empty [IQ], wait for work\n");	          
                                                                      
	      ++aio_request_queue.idle_threads;                              
	      --aio_request_queue.active_threads;                            
40007584:	c2 06 a0 64 	ld  [ %i2 + 0x64 ], %g1                        
	    /* If the idle chain is empty sleep for 3 seconds and wait for a 
	       signal. The thread now becomes idle. */                       
	    if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {        
	      AIO_printf ("Chain is empty [IQ], wait for work\n");	          
                                                                      
	      ++aio_request_queue.idle_threads;                              
40007588:	84 00 a0 01 	inc  %g2                                       
	      --aio_request_queue.active_threads;                            
4000758c:	82 00 7f ff 	add  %g1, -1, %g1                              
	      clock_gettime (CLOCK_REALTIME, &timeout);                      
40007590:	92 07 bf dc 	add  %fp, -36, %o1                             
	    /* If the idle chain is empty sleep for 3 seconds and wait for a 
	       signal. The thread now becomes idle. */                       
	    if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {        
	      AIO_printf ("Chain is empty [IQ], wait for work\n");	          
                                                                      
	      ++aio_request_queue.idle_threads;                              
40007594:	c4 26 a0 68 	st  %g2, [ %i2 + 0x68 ]                        
	      --aio_request_queue.active_threads;                            
40007598:	c2 26 a0 64 	st  %g1, [ %i2 + 0x64 ]                        
	      clock_gettime (CLOCK_REALTIME, &timeout);                      
4000759c:	40 00 01 98 	call  40007bfc <clock_gettime>                 
400075a0:	90 10 20 01 	mov  1, %o0                                    
	      timeout.tv_sec += 3;                                           
400075a4:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1                         
	      timeout.tv_nsec = 0;                                           
400075a8:	c0 27 bf e0 	clr  [ %fp + -32 ]                             
	      AIO_printf ("Chain is empty [IQ], wait for work\n");	          
                                                                      
	      ++aio_request_queue.idle_threads;                              
	      --aio_request_queue.active_threads;                            
	      clock_gettime (CLOCK_REALTIME, &timeout);                      
	      timeout.tv_sec += 3;                                           
400075ac:	82 00 60 03 	add  %g1, 3, %g1                               
	      timeout.tv_nsec = 0;                                           
                                                                      
	      result = pthread_cond_timedwait (&aio_request_queue.new_req,   
400075b0:	90 06 a0 04 	add  %i2, 4, %o0                               
	      AIO_printf ("Chain is empty [IQ], wait for work\n");	          
                                                                      
	      ++aio_request_queue.idle_threads;                              
	      --aio_request_queue.active_threads;                            
	      clock_gettime (CLOCK_REALTIME, &timeout);                      
	      timeout.tv_sec += 3;                                           
400075b4:	c2 27 bf dc 	st  %g1, [ %fp + -36 ]                         
	      timeout.tv_nsec = 0;                                           
                                                                      
	      result = pthread_cond_timedwait (&aio_request_queue.new_req,   
400075b8:	92 10 00 1a 	mov  %i2, %o1                                  
400075bc:	40 00 02 44 	call  40007ecc <pthread_cond_timedwait>        
400075c0:	94 07 bf dc 	add  %fp, -36, %o2                             
					       &aio_request_queue.mutex,                                 
					       &timeout);                                                
	                                                                     
	      /* If no new fd chain was added in the idle requests           
		 then this thread is finished */                                    
	      if (result == ETIMEDOUT) {                                     
400075c4:	80 a2 20 74 	cmp  %o0, 0x74                                 
400075c8:	22 80 00 04 	be,a   400075d8 <rtems_aio_handle+0x298>       <== ALWAYS TAKEN
400075cc:	c2 06 a0 68 	ld  [ %i2 + 0x68 ], %g1                        
400075d0:	10 bf ff d2 	b  40007518 <rtems_aio_handle+0x1d8>           <== NOT EXECUTED
400075d4:	f0 06 a0 54 	ld  [ %i2 + 0x54 ], %i0                        <== NOT EXECUTED
		AIO_printf ("Etimeout\n");                                          
		--aio_request_queue.idle_threads;                                   
		pthread_mutex_unlock (&aio_request_queue.mutex);                    
400075d8:	90 10 00 1a 	mov  %i2, %o0                                  
	                                                                     
	      /* If no new fd chain was added in the idle requests           
		 then this thread is finished */                                    
	      if (result == ETIMEDOUT) {                                     
		AIO_printf ("Etimeout\n");                                          
		--aio_request_queue.idle_threads;                                   
400075dc:	82 00 7f ff 	add  %g1, -1, %g1                              
		pthread_mutex_unlock (&aio_request_queue.mutex);                    
400075e0:	40 00 03 62 	call  40008368 <pthread_mutex_unlock>          
400075e4:	c2 26 a0 68 	st  %g1, [ %i2 + 0x68 ]                        
400075e8:	30 bf ff 8c 	b,a   40007418 <rtems_aio_handle+0xd8>         
                                                                      

40007658 <rtems_aio_init>: * 0 - if initialization succeeded */ int rtems_aio_init (void) {
40007658:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int result = 0;                                                     
                                                                      
  result = pthread_attr_init (&aio_request_queue.attr);               
4000765c:	3b 10 00 63 	sethi  %hi(0x40018c00), %i5                    
40007660:	40 00 03 9c 	call  400084d0 <pthread_attr_init>             
40007664:	90 17 63 fc 	or  %i5, 0x3fc, %o0	! 40018ffc <aio_request_queue+0x8>
  if (result != 0)                                                    
40007668:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4000766c:	12 80 00 23 	bne  400076f8 <rtems_aio_init+0xa0>            <== NEVER TAKEN
40007670:	90 17 63 fc 	or  %i5, 0x3fc, %o0                            
    return result;                                                    
                                                                      
  result =                                                            
40007674:	40 00 03 a3 	call  40008500 <pthread_attr_setdetachstate>   
40007678:	92 10 20 00 	clr  %o1                                       
    pthread_attr_setdetachstate (&aio_request_queue.attr,             
                                 PTHREAD_CREATE_DETACHED);            
  if (result != 0)                                                    
4000767c:	80 a2 20 00 	cmp  %o0, 0                                    
40007680:	12 80 00 20 	bne  40007700 <rtems_aio_init+0xa8>            <== NEVER TAKEN
40007684:	39 10 00 63 	sethi  %hi(0x40018c00), %i4                    
    pthread_attr_destroy (&aio_request_queue.attr);                   
                                                                      
                                                                      
  result = pthread_mutex_init (&aio_request_queue.mutex, NULL);       
40007688:	92 10 20 00 	clr  %o1                                       
4000768c:	40 00 02 be 	call  40008184 <pthread_mutex_init>            
40007690:	90 17 23 f4 	or  %i4, 0x3f4, %o0                            
  if (result != 0)                                                    
40007694:	80 a2 20 00 	cmp  %o0, 0                                    
40007698:	12 80 00 23 	bne  40007724 <rtems_aio_init+0xcc>            <== NEVER TAKEN
4000769c:	92 10 20 00 	clr  %o1                                       
    pthread_attr_destroy (&aio_request_queue.attr);                   
                                                                      
                                                                      
  result = pthread_cond_init (&aio_request_queue.new_req, NULL);      
400076a0:	11 10 00 63 	sethi  %hi(0x40018c00), %o0                    
400076a4:	40 00 01 bf 	call  40007da0 <pthread_cond_init>             
400076a8:	90 12 23 f8 	or  %o0, 0x3f8, %o0	! 40018ff8 <aio_request_queue+0x4>
  if (result != 0) {                                                  
400076ac:	b0 92 20 00 	orcc  %o0, 0, %i0                              
400076b0:	12 80 00 26 	bne  40007748 <rtems_aio_init+0xf0>            <== NEVER TAKEN
400076b4:	01 00 00 00 	nop                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
400076b8:	82 17 23 f4 	or  %i4, 0x3f4, %g1                            
  head->previous = NULL;                                              
  tail->previous = head;                                              
400076bc:	84 00 60 54 	add  %g1, 0x54, %g2                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
400076c0:	ba 00 60 4c 	add  %g1, 0x4c, %i5                            
  head->previous = NULL;                                              
  tail->previous = head;                                              
400076c4:	88 00 60 48 	add  %g1, 0x48, %g4                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
400076c8:	86 00 60 58 	add  %g1, 0x58, %g3                            
  head->previous = NULL;                                              
  tail->previous = head;                                              
400076cc:	c4 20 60 5c 	st  %g2, [ %g1 + 0x5c ]                        
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
400076d0:	fa 20 60 48 	st  %i5, [ %g1 + 0x48 ]                        
  head->previous = NULL;                                              
400076d4:	c0 20 60 4c 	clr  [ %g1 + 0x4c ]                            
  tail->previous = head;                                              
400076d8:	c8 20 60 50 	st  %g4, [ %g1 + 0x50 ]                        
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
400076dc:	c6 20 60 54 	st  %g3, [ %g1 + 0x54 ]                        
  head->previous = NULL;                                              
400076e0:	c0 20 60 58 	clr  [ %g1 + 0x58 ]                            
  }                                                                   
                                                                      
  rtems_chain_initialize_empty (&aio_request_queue.work_req);         
  rtems_chain_initialize_empty (&aio_request_queue.idle_req);         
                                                                      
  aio_request_queue.active_threads = 0;                               
400076e4:	c0 20 60 64 	clr  [ %g1 + 0x64 ]                            
  aio_request_queue.idle_threads = 0;                                 
400076e8:	c0 20 60 68 	clr  [ %g1 + 0x68 ]                            
  aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;              
400076ec:	05 00 00 2c 	sethi  %hi(0xb000), %g2                        
400076f0:	84 10 a0 0b 	or  %g2, 0xb, %g2	! b00b <PROM_START+0xb00b>   
400076f4:	c4 20 60 60 	st  %g2, [ %g1 + 0x60 ]                        
                                                                      
  return result;                                                      
}                                                                     
400076f8:	81 c7 e0 08 	ret                                            
400076fc:	81 e8 00 00 	restore                                        
                                                                      
  result =                                                            
    pthread_attr_setdetachstate (&aio_request_queue.attr,             
                                 PTHREAD_CREATE_DETACHED);            
  if (result != 0)                                                    
    pthread_attr_destroy (&aio_request_queue.attr);                   
40007700:	40 00 03 68 	call  400084a0 <pthread_attr_destroy>          <== NOT EXECUTED
40007704:	90 17 63 fc 	or  %i5, 0x3fc, %o0                            <== NOT EXECUTED
                                                                      
                                                                      
  result = pthread_mutex_init (&aio_request_queue.mutex, NULL);       
40007708:	39 10 00 63 	sethi  %hi(0x40018c00), %i4                    <== NOT EXECUTED
4000770c:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
40007710:	40 00 02 9d 	call  40008184 <pthread_mutex_init>            <== NOT EXECUTED
40007714:	90 17 23 f4 	or  %i4, 0x3f4, %o0                            <== NOT EXECUTED
  if (result != 0)                                                    
40007718:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4000771c:	02 bf ff e1 	be  400076a0 <rtems_aio_init+0x48>             <== NOT EXECUTED
40007720:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
    pthread_attr_destroy (&aio_request_queue.attr);                   
40007724:	40 00 03 5f 	call  400084a0 <pthread_attr_destroy>          <== NOT EXECUTED
40007728:	90 17 63 fc 	or  %i5, 0x3fc, %o0                            <== NOT EXECUTED
                                                                      
                                                                      
  result = pthread_cond_init (&aio_request_queue.new_req, NULL);      
4000772c:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
40007730:	11 10 00 63 	sethi  %hi(0x40018c00), %o0                    <== NOT EXECUTED
40007734:	40 00 01 9b 	call  40007da0 <pthread_cond_init>             <== NOT EXECUTED
40007738:	90 12 23 f8 	or  %o0, 0x3f8, %o0	! 40018ff8 <aio_request_queue+0x4><== NOT EXECUTED
  if (result != 0) {                                                  
4000773c:	b0 92 20 00 	orcc  %o0, 0, %i0                              <== NOT EXECUTED
40007740:	22 bf ff df 	be,a   400076bc <rtems_aio_init+0x64>          <== NOT EXECUTED
40007744:	82 17 23 f4 	or  %i4, 0x3f4, %g1                            <== NOT EXECUTED
    pthread_mutex_destroy (&aio_request_queue.mutex);                 
40007748:	40 00 02 3c 	call  40008038 <pthread_mutex_destroy>         <== NOT EXECUTED
4000774c:	90 17 23 f4 	or  %i4, 0x3f4, %o0                            <== NOT EXECUTED
    pthread_attr_destroy (&aio_request_queue.attr);                   
40007750:	40 00 03 54 	call  400084a0 <pthread_attr_destroy>          <== NOT EXECUTED
40007754:	90 17 63 fc 	or  %i5, 0x3fc, %o0                            <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
40007758:	10 bf ff d9 	b  400076bc <rtems_aio_init+0x64>              <== NOT EXECUTED
4000775c:	82 17 23 f4 	or  %i4, 0x3f4, %g1                            <== NOT EXECUTED
                                                                      

400075ec <rtems_aio_insert_prio>:
400075ec:	c2 02 00 00 	ld  [ %o0 ], %g1                               
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
400075f0:	88 02 20 04 	add  %o0, 4, %g4                               
  rtems_chain_node *node;                                             
                                                                      
  AIO_printf ("FD exists \n");                                        
  node = rtems_chain_first (chain);                                   
                                                                      
  if (rtems_chain_is_empty (chain)) {                                 
400075f4:	80 a0 40 04 	cmp  %g1, %g4                                  
400075f8:	02 80 00 15 	be  4000764c <rtems_aio_insert_prio+0x60>      <== NEVER TAKEN
400075fc:	9a 10 00 09 	mov  %o1, %o5                                  
    rtems_chain_prepend (chain, &req->next_prio);                     
  } else {                                                            
    AIO_printf ("Add by priority \n");                                
    int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;     
                                                                      
    while (req->aiocbp->aio_reqprio > prio &&                         
40007600:	c6 02 60 14 	ld  [ %o1 + 0x14 ], %g3                        
  if (rtems_chain_is_empty (chain)) {                                 
    AIO_printf ("First in chain \n");                                 
    rtems_chain_prepend (chain, &req->next_prio);                     
  } else {                                                            
    AIO_printf ("Add by priority \n");                                
    int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;     
40007604:	c4 00 60 14 	ld  [ %g1 + 0x14 ], %g2                        
                                                                      
    while (req->aiocbp->aio_reqprio > prio &&                         
40007608:	c6 00 e0 18 	ld  [ %g3 + 0x18 ], %g3                        
4000760c:	c4 00 a0 18 	ld  [ %g2 + 0x18 ], %g2                        
40007610:	80 a0 80 03 	cmp  %g2, %g3                                  
40007614:	26 80 00 07 	bl,a   40007630 <rtems_aio_insert_prio+0x44>   <== NEVER TAKEN
40007618:	c2 00 40 00 	ld  [ %g1 ], %g1                               <== NOT EXECUTED
4000761c:	10 80 00 0b 	b  40007648 <rtems_aio_insert_prio+0x5c>       
40007620:	d0 00 60 04 	ld  [ %g1 + 4 ], %o0                           
40007624:	22 80 00 09 	be,a   40007648 <rtems_aio_insert_prio+0x5c>   <== NOT EXECUTED
40007628:	d0 00 60 04 	ld  [ %g1 + 4 ], %o0                           <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(                         
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  return the_node->next;                                              
4000762c:	c2 00 40 00 	ld  [ %g1 ], %g1                               <== NOT EXECUTED
           !rtems_chain_is_tail (chain, node)) {                      
      node = rtems_chain_next (node);                                 
      prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;       
40007630:	c4 00 60 14 	ld  [ %g1 + 0x14 ], %g2                        <== NOT EXECUTED
    rtems_chain_prepend (chain, &req->next_prio);                     
  } else {                                                            
    AIO_printf ("Add by priority \n");                                
    int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;     
                                                                      
    while (req->aiocbp->aio_reqprio > prio &&                         
40007634:	c4 00 a0 18 	ld  [ %g2 + 0x18 ], %g2                        <== NOT EXECUTED
40007638:	80 a0 80 03 	cmp  %g2, %g3                                  <== NOT EXECUTED
4000763c:	06 bf ff fa 	bl  40007624 <rtems_aio_insert_prio+0x38>      <== NOT EXECUTED
40007640:	80 a1 00 01 	cmp  %g4, %g1                                  <== NOT EXECUTED
40007644:	d0 00 60 04 	ld  [ %g1 + 4 ], %o0                           <== NOT EXECUTED
40007648:	92 10 00 0d 	mov  %o5, %o1                                  
4000764c:	82 13 c0 00 	mov  %o7, %g1                                  
40007650:	40 00 0a 2e 	call  40009f08 <_Chain_Insert>                 
40007654:	9e 10 40 00 	mov  %g1, %o7                                  
                                                                      

40007834 <rtems_aio_remove_fd>: * Output parameters: * NONE */ void rtems_aio_remove_fd (rtems_aio_request_chain *r_chain) {
40007834:	9d e3 bf a0 	save  %sp, -96, %sp                            
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return _Chain_Head( the_chain )->next;                              
40007838:	fa 06 20 08 	ld  [ %i0 + 8 ], %i5                           
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(                             
  const Chain_Control *the_chain,                                     
  const Chain_Node    *the_node                                       
)                                                                     
{                                                                     
  return (the_node == _Chain_Immutable_tail( the_chain ));            
4000783c:	b0 06 20 0c 	add  %i0, 0xc, %i0                             
  rtems_chain_control *chain;                                         
  rtems_chain_node *node;                                             
  chain = &r_chain->perfd;                                            
  node = rtems_chain_first (chain);                                   
                                                                      
  while (!rtems_chain_is_tail (chain, node))                          
40007840:	80 a7 40 18 	cmp  %i5, %i0                                  
40007844:	02 80 00 0e 	be  4000787c <rtems_aio_remove_fd+0x48>        <== NEVER TAKEN
40007848:	b6 10 20 8c 	mov  0x8c, %i3                                 
 */                                                                   
RTEMS_INLINE_ROUTINE void rtems_chain_extract(                        
  rtems_chain_node *the_node                                          
)                                                                     
{                                                                     
  _Chain_Extract( the_node );                                         
4000784c:	40 00 09 96 	call  40009ea4 <_Chain_Extract>                
40007850:	90 10 00 1d 	mov  %i5, %o0                                  
    {                                                                 
      rtems_chain_extract (node);                                     
      rtems_aio_request *req = (rtems_aio_request *) node;            
      node = rtems_chain_next (node);                                 
      req->aiocbp->error_code = ECANCELED;                            
40007854:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(                         
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  return the_node->next;                                              
40007858:	f8 07 40 00 	ld  [ %i5 ], %i4                               
      req->aiocbp->return_value = -1;                                 
4000785c:	84 10 3f ff 	mov  -1, %g2                                   
      free (req);                                                     
40007860:	90 10 00 1d 	mov  %i5, %o0                                  
  while (!rtems_chain_is_tail (chain, node))                          
    {                                                                 
      rtems_chain_extract (node);                                     
      rtems_aio_request *req = (rtems_aio_request *) node;            
      node = rtems_chain_next (node);                                 
      req->aiocbp->error_code = ECANCELED;                            
40007864:	f6 20 60 34 	st  %i3, [ %g1 + 0x34 ]                        
      req->aiocbp->return_value = -1;                                 
      free (req);                                                     
40007868:	7f ff ee a5 	call  400032fc <free>                          
4000786c:	c4 20 60 38 	st  %g2, [ %g1 + 0x38 ]                        
  rtems_chain_control *chain;                                         
  rtems_chain_node *node;                                             
  chain = &r_chain->perfd;                                            
  node = rtems_chain_first (chain);                                   
                                                                      
  while (!rtems_chain_is_tail (chain, node))                          
40007870:	80 a7 00 18 	cmp  %i4, %i0                                  
40007874:	12 bf ff f6 	bne  4000784c <rtems_aio_remove_fd+0x18>       
40007878:	ba 10 00 1c 	mov  %i4, %i5                                  
4000787c:	81 c7 e0 08 	ret                                            
40007880:	81 e8 00 00 	restore                                        
                                                                      

40007884 <rtems_aio_remove_req>: * AIO_NOTCANCELED - if request was not canceled * AIO_CANCELED - if request was canceled */ int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp) {
40007884:	9d e3 bf a0 	save  %sp, -96, %sp                            
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(        
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_head( the_chain )->next;                    
40007888:	fa 06 00 00 	ld  [ %i0 ], %i5                               
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
4000788c:	84 06 20 04 	add  %i0, 4, %g2                               
  if (rtems_chain_is_empty (chain))                                   
40007890:	80 a7 40 02 	cmp  %i5, %g2                                  
40007894:	12 80 00 06 	bne  400078ac <rtems_aio_remove_req+0x28>      
40007898:	b0 10 20 02 	mov  2, %i0                                    
4000789c:	30 80 00 12 	b,a   400078e4 <rtems_aio_remove_req+0x60>     
  rtems_chain_node *node = rtems_chain_first (chain);                 
  rtems_aio_request *current;                                         
                                                                      
  current = (rtems_aio_request *) node;                               
                                                                      
  while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
400078a0:	80 a0 80 1d 	cmp  %g2, %i5                                  <== NOT EXECUTED
400078a4:	02 80 00 12 	be  400078ec <rtems_aio_remove_req+0x68>       <== NOT EXECUTED
400078a8:	01 00 00 00 	nop                                            <== NOT EXECUTED
400078ac:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
400078b0:	80 a0 40 19 	cmp  %g1, %i1                                  
400078b4:	32 bf ff fb 	bne,a   400078a0 <rtems_aio_remove_req+0x1c>   <== NEVER TAKEN
400078b8:	fa 07 40 00 	ld  [ %i5 ], %i5                               <== NOT EXECUTED
400078bc:	40 00 09 7a 	call  40009ea4 <_Chain_Extract>                
400078c0:	90 10 00 1d 	mov  %i5, %o0                                  
  if (rtems_chain_is_tail (chain, node))                              
    return AIO_NOTCANCELED;                                           
  else                                                                
    {                                                                 
      rtems_chain_extract (node);                                     
      current->aiocbp->error_code = ECANCELED;                        
400078c4:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
      current->aiocbp->return_value = -1;                             
400078c8:	84 10 3f ff 	mov  -1, %g2                                   
400078cc:	c4 20 60 38 	st  %g2, [ %g1 + 0x38 ]                        
  if (rtems_chain_is_tail (chain, node))                              
    return AIO_NOTCANCELED;                                           
  else                                                                
    {                                                                 
      rtems_chain_extract (node);                                     
      current->aiocbp->error_code = ECANCELED;                        
400078d0:	84 10 20 8c 	mov  0x8c, %g2                                 
      current->aiocbp->return_value = -1;                             
      free (current);                                                 
400078d4:	90 10 00 1d 	mov  %i5, %o0                                  
  if (rtems_chain_is_tail (chain, node))                              
    return AIO_NOTCANCELED;                                           
  else                                                                
    {                                                                 
      rtems_chain_extract (node);                                     
      current->aiocbp->error_code = ECANCELED;                        
400078d8:	c4 20 60 34 	st  %g2, [ %g1 + 0x34 ]                        
      current->aiocbp->return_value = -1;                             
      free (current);                                                 
400078dc:	7f ff ee 88 	call  400032fc <free>                          
400078e0:	b0 10 20 00 	clr  %i0                                       
    }                                                                 
                                                                      
  return AIO_CANCELED;                                                
}                                                                     
400078e4:	81 c7 e0 08 	ret                                            
400078e8:	81 e8 00 00 	restore                                        
    node = rtems_chain_next (node);                                   
    current = (rtems_aio_request *) node;                             
  }                                                                   
                                                                      
  if (rtems_chain_is_tail (chain, node))                              
    return AIO_NOTCANCELED;                                           
400078ec:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400078f0:	91 e8 20 01 	restore  %g0, 1, %o0                           <== NOT EXECUTED
                                                                      

4000ec0c <rtems_assoc_local_by_remote_bitfield>: uint32_t rtems_assoc_local_by_remote_bitfield( const rtems_assoc_t *ap, uint32_t remote_value ) {
4000ec0c:	9d e3 bf a0 	save  %sp, -96, %sp                            
4000ec10:	b8 10 20 20 	mov  0x20, %i4                                 
  uint32_t   b;                                                       
  uint32_t   local_value = 0;                                         
4000ec14:	b6 10 20 00 	clr  %i3                                       
                                                                      
  for (b = 1; b; b <<= 1) {                                           
4000ec18:	10 80 00 04 	b  4000ec28 <rtems_assoc_local_by_remote_bitfield+0x1c>
4000ec1c:	ba 10 20 01 	mov  1, %i5                                    
4000ec20:	02 80 00 0c 	be  4000ec50 <rtems_assoc_local_by_remote_bitfield+0x44>
4000ec24:	bb 2f 60 01 	sll  %i5, 1, %i5                               
    if (b & remote_value)                                             
4000ec28:	80 8f 40 19 	btst  %i5, %i1                                 
4000ec2c:	22 bf ff fd 	be,a   4000ec20 <rtems_assoc_local_by_remote_bitfield+0x14>
4000ec30:	b8 87 3f ff 	addcc  %i4, -1, %i4                            
      local_value |= rtems_assoc_local_by_remote(ap, b);              
4000ec34:	92 10 00 1d 	mov  %i5, %o1                                  
4000ec38:	40 00 00 08 	call  4000ec58 <rtems_assoc_local_by_remote>   
4000ec3c:	90 10 00 18 	mov  %i0, %o0                                  
)                                                                     
{                                                                     
  uint32_t   b;                                                       
  uint32_t   local_value = 0;                                         
                                                                      
  for (b = 1; b; b <<= 1) {                                           
4000ec40:	bb 2f 60 01 	sll  %i5, 1, %i5                               
4000ec44:	b8 87 3f ff 	addcc  %i4, -1, %i4                            
4000ec48:	12 bf ff f8 	bne  4000ec28 <rtems_assoc_local_by_remote_bitfield+0x1c><== ALWAYS TAKEN
4000ec4c:	b6 16 c0 08 	or  %i3, %o0, %i3                              
    if (b & remote_value)                                             
      local_value |= rtems_assoc_local_by_remote(ap, b);              
  }                                                                   
                                                                      
  return local_value;                                                 
}                                                                     
4000ec50:	81 c7 e0 08 	ret                                            
4000ec54:	91 e8 00 1b 	restore  %g0, %i3, %o0                         
                                                                      

4000bc78 <rtems_assoc_ptr_by_local>: const rtems_assoc_t *rtems_assoc_ptr_by_local( const rtems_assoc_t *ap, uint32_t local_value ) {
4000bc78:	9d e3 bf a0 	save  %sp, -96, %sp                            
  const rtems_assoc_t *default_ap = 0;                                
                                                                      
  if (rtems_assoc_is_default(ap))                                     
4000bc7c:	d0 06 00 00 	ld  [ %i0 ], %o0                               
4000bc80:	80 a2 20 00 	cmp  %o0, 0                                    
4000bc84:	02 80 00 1d 	be  4000bcf8 <rtems_assoc_ptr_by_local+0x80>   
4000bc88:	13 10 00 74 	sethi  %hi(0x4001d000), %o1                    
4000bc8c:	40 00 12 47 	call  400105a8 <strcmp>                        
4000bc90:	92 12 63 20 	or  %o1, 0x320, %o1	! 4001d320 <IMFS_memfile_handlers+0x30>
4000bc94:	80 a2 20 00 	cmp  %o0, 0                                    
4000bc98:	22 80 00 12 	be,a   4000bce0 <rtems_assoc_ptr_by_local+0x68>
4000bc9c:	c4 06 20 0c 	ld  [ %i0 + 0xc ], %g2                         
const rtems_assoc_t *rtems_assoc_ptr_by_local(                        
  const rtems_assoc_t *ap,                                            
  uint32_t             local_value                                    
)                                                                     
{                                                                     
  const rtems_assoc_t *default_ap = 0;                                
4000bca0:	84 10 20 00 	clr  %g2                                       
                                                                      
  if (rtems_assoc_is_default(ap))                                     
    default_ap = ap++;                                                
                                                                      
  for ( ; ap->name; ap++)                                             
    if (ap->local_value == local_value)                               
4000bca4:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
4000bca8:	80 a0 40 19 	cmp  %g1, %i1                                  
4000bcac:	32 80 00 07 	bne,a   4000bcc8 <rtems_assoc_ptr_by_local+0x50>
4000bcb0:	b0 06 20 0c 	add  %i0, 0xc, %i0                             
4000bcb4:	30 80 00 13 	b,a   4000bd00 <rtems_assoc_ptr_by_local+0x88> 
4000bcb8:	80 a0 40 19 	cmp  %g1, %i1                                  
4000bcbc:	02 80 00 11 	be  4000bd00 <rtems_assoc_ptr_by_local+0x88>   
4000bcc0:	01 00 00 00 	nop                                            
  const rtems_assoc_t *default_ap = 0;                                
                                                                      
  if (rtems_assoc_is_default(ap))                                     
    default_ap = ap++;                                                
                                                                      
  for ( ; ap->name; ap++)                                             
4000bcc4:	b0 06 20 0c 	add  %i0, 0xc, %i0                             
4000bcc8:	c2 06 00 00 	ld  [ %i0 ], %g1                               
4000bccc:	80 a0 60 00 	cmp  %g1, 0                                    
4000bcd0:	32 bf ff fa 	bne,a   4000bcb8 <rtems_assoc_ptr_by_local+0x40>
4000bcd4:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
4000bcd8:	81 c7 e0 08 	ret                                            
4000bcdc:	91 e8 00 02 	restore  %g0, %g2, %o0                         
4000bce0:	80 a0 a0 00 	cmp  %g2, 0                                    
4000bce4:	02 80 00 07 	be  4000bd00 <rtems_assoc_ptr_by_local+0x88>   <== NEVER TAKEN
4000bce8:	82 06 20 0c 	add  %i0, 0xc, %g1                             
4000bcec:	84 10 00 18 	mov  %i0, %g2                                  
)                                                                     
{                                                                     
  const rtems_assoc_t *default_ap = 0;                                
                                                                      
  if (rtems_assoc_is_default(ap))                                     
    default_ap = ap++;                                                
4000bcf0:	10 bf ff ed 	b  4000bca4 <rtems_assoc_ptr_by_local+0x2c>    
4000bcf4:	b0 10 00 01 	mov  %g1, %i0                                  
  for ( ; ap->name; ap++)                                             
    if (ap->local_value == local_value)                               
      return ap;                                                      
                                                                      
  return default_ap;                                                  
}                                                                     
4000bcf8:	81 c7 e0 08 	ret                                            
4000bcfc:	91 e8 20 00 	restore  %g0, 0, %o0                           
4000bd00:	81 c7 e0 08 	ret                                            
4000bd04:	81 e8 00 00 	restore                                        
                                                                      

40003888 <rtems_assoc_ptr_by_name>: const rtems_assoc_t *rtems_assoc_ptr_by_name( const rtems_assoc_t *ap, const char *name ) {
40003888:	9d e3 bf a0 	save  %sp, -96, %sp                            
  const rtems_assoc_t *default_ap = 0;                                
                                                                      
  if (rtems_assoc_is_default(ap))                                     
4000388c:	fa 06 00 00 	ld  [ %i0 ], %i5                               
40003890:	80 a7 60 00 	cmp  %i5, 0                                    
40003894:	02 80 00 1e 	be  4000390c <rtems_assoc_ptr_by_name+0x84>    
40003898:	90 10 00 1d 	mov  %i5, %o0                                  
4000389c:	13 10 00 58 	sethi  %hi(0x40016000), %o1                    
400038a0:	40 00 34 96 	call  40010af8 <strcmp>                        
400038a4:	92 12 60 30 	or  %o1, 0x30, %o1	! 40016030 <_rodata_start+0x780>
400038a8:	80 a2 20 00 	cmp  %o0, 0                                    
400038ac:	22 80 00 10 	be,a   400038ec <rtems_assoc_ptr_by_name+0x64> 
400038b0:	fa 06 20 0c 	ld  [ %i0 + 0xc ], %i5                         
const rtems_assoc_t *rtems_assoc_ptr_by_name(                         
  const rtems_assoc_t *ap,                                            
  const char          *name                                           
)                                                                     
{                                                                     
  const rtems_assoc_t *default_ap = 0;                                
400038b4:	10 80 00 06 	b  400038cc <rtems_assoc_ptr_by_name+0x44>     
400038b8:	b8 10 20 00 	clr  %i4                                       
                                                                      
  if (rtems_assoc_is_default(ap))                                     
    default_ap = ap++;                                                
                                                                      
  for ( ; ap->name; ap++)                                             
400038bc:	fa 06 00 00 	ld  [ %i0 ], %i5                               
400038c0:	80 a7 60 00 	cmp  %i5, 0                                    
400038c4:	02 80 00 10 	be  40003904 <rtems_assoc_ptr_by_name+0x7c>    
400038c8:	01 00 00 00 	nop                                            
    if (strcmp(ap->name, name) == 0)                                  
400038cc:	90 10 00 1d 	mov  %i5, %o0                                  
400038d0:	40 00 34 8a 	call  40010af8 <strcmp>                        
400038d4:	92 10 00 19 	mov  %i1, %o1                                  
400038d8:	80 a2 20 00 	cmp  %o0, 0                                    
400038dc:	32 bf ff f8 	bne,a   400038bc <rtems_assoc_ptr_by_name+0x34>
400038e0:	b0 06 20 0c 	add  %i0, 0xc, %i0                             
	return ap;                                                           
                                                                      
  return default_ap;                                                  
}                                                                     
400038e4:	81 c7 e0 08 	ret                                            
400038e8:	81 e8 00 00 	restore                                        
  const rtems_assoc_t *default_ap = 0;                                
                                                                      
  if (rtems_assoc_is_default(ap))                                     
    default_ap = ap++;                                                
                                                                      
  for ( ; ap->name; ap++)                                             
400038ec:	80 a7 60 00 	cmp  %i5, 0                                    
400038f0:	02 bf ff fd 	be  400038e4 <rtems_assoc_ptr_by_name+0x5c>    <== NEVER TAKEN
400038f4:	82 06 20 0c 	add  %i0, 0xc, %g1                             
400038f8:	b8 10 00 18 	mov  %i0, %i4                                  
)                                                                     
{                                                                     
  const rtems_assoc_t *default_ap = 0;                                
                                                                      
  if (rtems_assoc_is_default(ap))                                     
    default_ap = ap++;                                                
400038fc:	10 bf ff f4 	b  400038cc <rtems_assoc_ptr_by_name+0x44>     
40003900:	b0 10 00 01 	mov  %g1, %i0                                  
                                                                      
  for ( ; ap->name; ap++)                                             
40003904:	81 c7 e0 08 	ret                                            
40003908:	91 e8 00 1c 	restore  %g0, %i4, %o0                         
const rtems_assoc_t *rtems_assoc_ptr_by_name(                         
  const rtems_assoc_t *ap,                                            
  const char          *name                                           
)                                                                     
{                                                                     
  const rtems_assoc_t *default_ap = 0;                                
4000390c:	81 c7 e0 08 	ret                                            
40003910:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

4000ec94 <rtems_assoc_ptr_by_remote>: const rtems_assoc_t *rtems_assoc_ptr_by_remote( const rtems_assoc_t *ap, uint32_t remote_value ) {
4000ec94:	9d e3 bf a0 	save  %sp, -96, %sp                            
  const rtems_assoc_t *default_ap = 0;                                
                                                                      
  if (rtems_assoc_is_default(ap))                                     
4000ec98:	d0 06 00 00 	ld  [ %i0 ], %o0                               
4000ec9c:	80 a2 20 00 	cmp  %o0, 0                                    
4000eca0:	02 80 00 1d 	be  4000ed14 <rtems_assoc_ptr_by_remote+0x80>  
4000eca4:	13 10 00 74 	sethi  %hi(0x4001d000), %o1                    
4000eca8:	40 00 06 40 	call  400105a8 <strcmp>                        
4000ecac:	92 12 63 20 	or  %o1, 0x320, %o1	! 4001d320 <IMFS_memfile_handlers+0x30>
4000ecb0:	80 a2 20 00 	cmp  %o0, 0                                    
4000ecb4:	22 80 00 12 	be,a   4000ecfc <rtems_assoc_ptr_by_remote+0x68>
4000ecb8:	c4 06 20 0c 	ld  [ %i0 + 0xc ], %g2                         
const rtems_assoc_t *rtems_assoc_ptr_by_remote(                       
  const rtems_assoc_t *ap,                                            
  uint32_t       remote_value                                         
)                                                                     
{                                                                     
  const rtems_assoc_t *default_ap = 0;                                
4000ecbc:	84 10 20 00 	clr  %g2                                       
                                                                      
  if (rtems_assoc_is_default(ap))                                     
    default_ap = ap++;                                                
                                                                      
  for ( ; ap->name; ap++)                                             
    if (ap->remote_value == remote_value)                             
4000ecc0:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
4000ecc4:	80 a0 40 19 	cmp  %g1, %i1                                  
4000ecc8:	32 80 00 07 	bne,a   4000ece4 <rtems_assoc_ptr_by_remote+0x50>
4000eccc:	b0 06 20 0c 	add  %i0, 0xc, %i0                             
4000ecd0:	30 80 00 13 	b,a   4000ed1c <rtems_assoc_ptr_by_remote+0x88>
4000ecd4:	80 a0 40 19 	cmp  %g1, %i1                                  
4000ecd8:	02 80 00 11 	be  4000ed1c <rtems_assoc_ptr_by_remote+0x88>  
4000ecdc:	01 00 00 00 	nop                                            
  const rtems_assoc_t *default_ap = 0;                                
                                                                      
  if (rtems_assoc_is_default(ap))                                     
    default_ap = ap++;                                                
                                                                      
  for ( ; ap->name; ap++)                                             
4000ece0:	b0 06 20 0c 	add  %i0, 0xc, %i0                             
4000ece4:	c2 06 00 00 	ld  [ %i0 ], %g1                               
4000ece8:	80 a0 60 00 	cmp  %g1, 0                                    
4000ecec:	32 bf ff fa 	bne,a   4000ecd4 <rtems_assoc_ptr_by_remote+0x40>
4000ecf0:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
4000ecf4:	81 c7 e0 08 	ret                                            
4000ecf8:	91 e8 00 02 	restore  %g0, %g2, %o0                         
4000ecfc:	80 a0 a0 00 	cmp  %g2, 0                                    
4000ed00:	02 80 00 07 	be  4000ed1c <rtems_assoc_ptr_by_remote+0x88>  <== NEVER TAKEN
4000ed04:	82 06 20 0c 	add  %i0, 0xc, %g1                             
4000ed08:	84 10 00 18 	mov  %i0, %g2                                  
)                                                                     
{                                                                     
  const rtems_assoc_t *default_ap = 0;                                
                                                                      
  if (rtems_assoc_is_default(ap))                                     
    default_ap = ap++;                                                
4000ed0c:	10 bf ff ed 	b  4000ecc0 <rtems_assoc_ptr_by_remote+0x2c>   
4000ed10:	b0 10 00 01 	mov  %g1, %i0                                  
  for ( ; ap->name; ap++)                                             
    if (ap->remote_value == remote_value)                             
      return ap;                                                      
                                                                      
  return default_ap;                                                  
}                                                                     
4000ed14:	81 c7 e0 08 	ret                                            
4000ed18:	91 e8 20 00 	restore  %g0, 0, %o0                           
4000ed1c:	81 c7 e0 08 	ret                                            
4000ed20:	81 e8 00 00 	restore                                        
                                                                      

400039a4 <rtems_assoc_remote_by_local_bitfield>: uint32_t rtems_assoc_remote_by_local_bitfield( const rtems_assoc_t *ap, uint32_t local_value ) {
400039a4:	9d e3 bf a0 	save  %sp, -96, %sp                            
400039a8:	b8 10 20 20 	mov  0x20, %i4                                 
  uint32_t   b;                                                       
  uint32_t   remote_value = 0;                                        
400039ac:	b6 10 20 00 	clr  %i3                                       
                                                                      
  for (b = 1; b; b <<= 1)                                             
400039b0:	10 80 00 04 	b  400039c0 <rtems_assoc_remote_by_local_bitfield+0x1c>
400039b4:	ba 10 20 01 	mov  1, %i5                                    
400039b8:	02 80 00 0c 	be  400039e8 <rtems_assoc_remote_by_local_bitfield+0x44>
400039bc:	bb 2f 60 01 	sll  %i5, 1, %i5                               
    if (b & local_value)                                              
400039c0:	80 8f 40 19 	btst  %i5, %i1                                 
400039c4:	22 bf ff fd 	be,a   400039b8 <rtems_assoc_remote_by_local_bitfield+0x14>
400039c8:	b8 87 3f ff 	addcc  %i4, -1, %i4                            
      remote_value |= rtems_assoc_remote_by_local(ap, b);             
400039cc:	92 10 00 1d 	mov  %i5, %o1                                  
400039d0:	40 00 00 08 	call  400039f0 <rtems_assoc_remote_by_local>   
400039d4:	90 10 00 18 	mov  %i0, %o0                                  
)                                                                     
{                                                                     
  uint32_t   b;                                                       
  uint32_t   remote_value = 0;                                        
                                                                      
  for (b = 1; b; b <<= 1)                                             
400039d8:	bb 2f 60 01 	sll  %i5, 1, %i5                               
400039dc:	b8 87 3f ff 	addcc  %i4, -1, %i4                            
400039e0:	12 bf ff f8 	bne  400039c0 <rtems_assoc_remote_by_local_bitfield+0x1c><== ALWAYS TAKEN
400039e4:	b6 16 c0 08 	or  %i3, %o0, %i3                              
    if (b & local_value)                                              
      remote_value |= rtems_assoc_remote_by_local(ap, b);             
                                                                      
  return remote_value;                                                
}                                                                     
400039e8:	81 c7 e0 08 	ret                                            
400039ec:	91 e8 00 1b 	restore  %g0, %i3, %o0                         
                                                                      

4000cc6c <rtems_bdbuf_add_to_modified_list_after_access>: } } static void rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd) {
4000cc6c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dd)   
4000cc70:	3b 10 00 6b 	sethi  %hi(0x4001ac00), %i5                    
4000cc74:	ba 17 63 34 	or  %i5, 0x334, %i5	! 4001af34 <bdbuf_cache>   
4000cc78:	c2 0f 60 30 	ldub  [ %i5 + 0x30 ], %g1                      
4000cc7c:	80 a0 60 00 	cmp  %g1, 0                                    
4000cc80:	22 80 00 08 	be,a   4000cca0 <rtems_bdbuf_add_to_modified_list_after_access+0x34><== ALWAYS TAKEN
4000cc84:	c2 06 20 20 	ld  [ %i0 + 0x20 ], %g1                        
4000cc88:	c4 07 60 38 	ld  [ %i5 + 0x38 ], %g2                        <== NOT EXECUTED
4000cc8c:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        <== NOT EXECUTED
4000cc90:	80 a0 80 01 	cmp  %g2, %g1                                  <== NOT EXECUTED
4000cc94:	02 80 00 2b 	be  4000cd40 <rtems_bdbuf_add_to_modified_list_after_access+0xd4><== NOT EXECUTED
4000cc98:	01 00 00 00 	nop                                            <== NOT EXECUTED
   * 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                    
4000cc9c:	c2 06 20 20 	ld  [ %i0 + 0x20 ], %g1                        <== NOT EXECUTED
4000cca0:	80 a0 60 05 	cmp  %g1, 5                                    
4000cca4:	22 80 00 16 	be,a   4000ccfc <rtems_bdbuf_add_to_modified_list_after_access+0x90>
4000cca8:	03 10 00 65 	sethi  %hi(0x40019400), %g1                    
4000ccac:	80 a0 60 03 	cmp  %g1, 3                                    
4000ccb0:	02 80 00 13 	be  4000ccfc <rtems_bdbuf_add_to_modified_list_after_access+0x90>
4000ccb4:	03 10 00 65 	sethi  %hi(0x40019400), %g1                    
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000ccb8:	84 10 20 07 	mov  7, %g2                                    
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
4000ccbc:	c2 07 60 54 	ld  [ %i5 + 0x54 ], %g1                        
4000ccc0:	c4 26 20 20 	st  %g2, [ %i0 + 0x20 ]                        
                                                                      
  the_node->next = tail;                                              
4000ccc4:	84 07 60 50 	add  %i5, 0x50, %g2                            
  tail->previous = the_node;                                          
4000ccc8:	f0 27 60 54 	st  %i0, [ %i5 + 0x54 ]                        
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
                                                                      
  the_node->next = tail;                                              
4000cccc:	c4 26 00 00 	st  %g2, [ %i0 ]                               
    bd->hold_timer = bdbuf_config.swap_block_hold;                    
                                                                      
  rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_MODIFIED);             
  rtems_chain_append_unprotected (&bdbuf_cache.modified, &bd->link);  
                                                                      
  if (bd->waiters)                                                    
4000ccd0:	c4 06 20 24 	ld  [ %i0 + 0x24 ], %g2                        
  tail->previous = the_node;                                          
  old_last->next = the_node;                                          
  the_node->previous = old_last;                                      
4000ccd4:	c2 26 20 04 	st  %g1, [ %i0 + 4 ]                           
4000ccd8:	80 a0 a0 00 	cmp  %g2, 0                                    
4000ccdc:	12 80 00 15 	bne  4000cd30 <rtems_bdbuf_add_to_modified_list_after_access+0xc4>
4000cce0:	f0 20 40 00 	st  %i0, [ %g1 ]                               
    rtems_bdbuf_wake (&bdbuf_cache.access_waiters);                   
  else if (rtems_bdbuf_has_buffer_waiters ())                         
4000cce4:	c2 07 60 74 	ld  [ %i5 + 0x74 ], %g1                        
4000cce8:	80 a0 60 00 	cmp  %g1, 0                                    
4000ccec:	12 80 00 13 	bne  4000cd38 <rtems_bdbuf_add_to_modified_list_after_access+0xcc>
4000ccf0:	01 00 00 00 	nop                                            
4000ccf4:	81 c7 e0 08 	ret                                            
4000ccf8:	81 e8 00 00 	restore                                        
   * 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)               
    bd->hold_timer = bdbuf_config.swap_block_hold;                    
4000ccfc:	c2 00 62 18 	ld  [ %g1 + 0x218 ], %g1                       
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000cd00:	84 10 20 07 	mov  7, %g2                                    
   * 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)               
    bd->hold_timer = bdbuf_config.swap_block_hold;                    
4000cd04:	c2 26 20 2c 	st  %g1, [ %i0 + 0x2c ]                        
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
4000cd08:	c2 07 60 54 	ld  [ %i5 + 0x54 ], %g1                        
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000cd0c:	c4 26 20 20 	st  %g2, [ %i0 + 0x20 ]                        
                                                                      
  the_node->next = tail;                                              
4000cd10:	84 07 60 50 	add  %i5, 0x50, %g2                            
  tail->previous = the_node;                                          
4000cd14:	f0 27 60 54 	st  %i0, [ %i5 + 0x54 ]                        
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
                                                                      
  the_node->next = tail;                                              
4000cd18:	c4 26 00 00 	st  %g2, [ %i0 ]                               
    bd->hold_timer = bdbuf_config.swap_block_hold;                    
                                                                      
  rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_MODIFIED);             
  rtems_chain_append_unprotected (&bdbuf_cache.modified, &bd->link);  
                                                                      
  if (bd->waiters)                                                    
4000cd1c:	c4 06 20 24 	ld  [ %i0 + 0x24 ], %g2                        
  tail->previous = the_node;                                          
  old_last->next = the_node;                                          
  the_node->previous = old_last;                                      
4000cd20:	c2 26 20 04 	st  %g1, [ %i0 + 4 ]                           
4000cd24:	80 a0 a0 00 	cmp  %g2, 0                                    
4000cd28:	02 bf ff ef 	be  4000cce4 <rtems_bdbuf_add_to_modified_list_after_access+0x78>
4000cd2c:	f0 20 40 00 	st  %i0, [ %g1 ]                               
    rtems_bdbuf_wake (&bdbuf_cache.access_waiters);                   
4000cd30:	7f ff ff c0 	call  4000cc30 <rtems_bdbuf_wake>              
4000cd34:	91 ef 60 64 	restore  %i5, 0x64, %o0                        
  else if (rtems_bdbuf_has_buffer_waiters ())                         
    rtems_bdbuf_wake_swapper ();                                      
4000cd38:	7f ff ff 23 	call  4000c9c4 <rtems_bdbuf_wake_swapper>      
4000cd3c:	81 e8 00 00 	restore                                        
static void                                                           
rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd)
{                                                                     
  if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dd)   
  {                                                                   
    rtems_bdbuf_unlock_cache ();                                      
4000cd40:	7f ff ff 1b 	call  4000c9ac <rtems_bdbuf_unlock_cache>      <== NOT EXECUTED
4000cd44:	01 00 00 00 	nop                                            <== 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_BDBUF_FATAL_SYNC_LOCK);
4000cd48:	d0 07 60 2c 	ld  [ %i5 + 0x2c ], %o0                        <== NOT EXECUTED
4000cd4c:	7f ff fe f5 	call  4000c920 <rtems_bdbuf_lock>              <== NOT EXECUTED
4000cd50:	92 10 20 19 	mov  0x19, %o1                                 <== NOT EXECUTED
 * Unlock the cache's sync lock. Any blocked writers are woken.       
 */                                                                   
static void                                                           
rtems_bdbuf_unlock_sync (void)                                        
{                                                                     
  rtems_bdbuf_unlock (bdbuf_cache.sync_lock,                          
4000cd54:	d0 07 60 2c 	ld  [ %i5 + 0x2c ], %o0                        <== NOT EXECUTED
4000cd58:	7f ff ff 0a 	call  4000c980 <rtems_bdbuf_unlock>            <== NOT EXECUTED
4000cd5c:	92 10 20 1a 	mov  0x1a, %o1                                 <== NOT EXECUTED
     * Wait for the sync lock.                                        
     */                                                               
    rtems_bdbuf_lock_sync ();                                         
                                                                      
    rtems_bdbuf_unlock_sync ();                                       
    rtems_bdbuf_lock_cache ();                                        
4000cd60:	7f ff fe fd 	call  4000c954 <rtems_bdbuf_lock_cache>        <== NOT EXECUTED
4000cd64:	01 00 00 00 	nop                                            <== NOT EXECUTED
   * 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                    
4000cd68:	10 bf ff ce 	b  4000cca0 <rtems_bdbuf_add_to_modified_list_after_access+0x34><== NOT EXECUTED
4000cd6c:	c2 06 20 20 	ld  [ %i0 + 0x20 ], %g1                        <== NOT EXECUTED
                                                                      

4000ca6c <rtems_bdbuf_anonymous_wait>: * 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) {
4000ca6c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_mode        prev_mode;                                        
                                                                      
  /*                                                                  
   * Indicate we are waiting.                                         
   */                                                                 
  ++waiters->count;                                                   
4000ca70:	c2 06 00 00 	ld  [ %i0 ], %g1                               
4000ca74:	82 00 60 01 	inc  %g1                                       
   * 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 ();                      
4000ca78:	7f ff ff e0 	call  4000c9f8 <rtems_bdbuf_disable_preemption>
4000ca7c:	c2 26 00 00 	st  %g1, [ %i0 ]                               
                                                                      
  /*                                                                  
   * Unlock the cache, wait, and lock the cache when we return.       
   */                                                                 
  rtems_bdbuf_unlock_cache ();                                        
4000ca80:	7f ff ff cb 	call  4000c9ac <rtems_bdbuf_unlock_cache>      
4000ca84:	ba 10 00 08 	mov  %o0, %i5                                  
                                                                      
  sc = rtems_semaphore_obtain (waiters->sema, RTEMS_WAIT, RTEMS_BDBUF_WAIT_TIMEOUT);
4000ca88:	d0 06 20 04 	ld  [ %i0 + 4 ], %o0                           
4000ca8c:	92 10 20 00 	clr  %o1                                       
4000ca90:	7f ff ee ee 	call  40008648 <rtems_semaphore_obtain>        
4000ca94:	94 10 20 00 	clr  %o2                                       
                                                                      
  if (sc == RTEMS_TIMEOUT)                                            
4000ca98:	80 a2 20 06 	cmp  %o0, 6                                    
4000ca9c:	02 80 00 0d 	be  4000cad0 <rtems_bdbuf_anonymous_wait+0x64> <== NEVER TAKEN
4000caa0:	80 a2 20 0d 	cmp  %o0, 0xd                                  
    rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAIT_TO);              
                                                                      
  if (sc != RTEMS_UNSATISFIED)                                        
4000caa4:	12 80 00 0d 	bne  4000cad8 <rtems_bdbuf_anonymous_wait+0x6c><== NEVER TAKEN
4000caa8:	01 00 00 00 	nop                                            
    rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAIT_2);               
                                                                      
  rtems_bdbuf_lock_cache ();                                          
4000caac:	7f ff ff aa 	call  4000c954 <rtems_bdbuf_lock_cache>        
4000cab0:	01 00 00 00 	nop                                            
                                                                      
  rtems_bdbuf_restore_preemption (prev_mode);                         
4000cab4:	7f ff ff df 	call  4000ca30 <rtems_bdbuf_restore_preemption>
4000cab8:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  --waiters->count;                                                   
4000cabc:	c2 06 00 00 	ld  [ %i0 ], %g1                               
4000cac0:	82 00 7f ff 	add  %g1, -1, %g1                              
4000cac4:	c2 26 00 00 	st  %g1, [ %i0 ]                               
4000cac8:	81 c7 e0 08 	ret                                            
4000cacc:	81 e8 00 00 	restore                                        
  rtems_bdbuf_unlock_cache ();                                        
                                                                      
  sc = rtems_semaphore_obtain (waiters->sema, RTEMS_WAIT, RTEMS_BDBUF_WAIT_TIMEOUT);
                                                                      
  if (sc == RTEMS_TIMEOUT)                                            
    rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAIT_TO);              
4000cad0:	7f ff ff 8f 	call  4000c90c <rtems_bdbuf_fatal>             <== NOT EXECUTED
4000cad4:	90 10 20 03 	mov  3, %o0                                    <== NOT EXECUTED
                                                                      
  if (sc != RTEMS_UNSATISFIED)                                        
    rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAIT_2);               
4000cad8:	7f ff ff 8d 	call  4000c90c <rtems_bdbuf_fatal>             <== NOT EXECUTED
4000cadc:	90 10 20 02 	mov  2, %o0                                    <== NOT EXECUTED
                                                                      

4000cd70 <rtems_bdbuf_create_task.constprop.9>: return NULL; } static rtems_status_code rtems_bdbuf_create_task(
4000cd70:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_task_argument arg,                                            
  rtems_id *id                                                        
)                                                                     
{                                                                     
  rtems_status_code sc;                                               
  size_t stack_size = bdbuf_config.task_stack_size ?                  
4000cd74:	03 10 00 65 	sethi  %hi(0x40019400), %g1                    
4000cd78:	d4 00 62 24 	ld  [ %g1 + 0x224 ], %o2	! 40019624 <rtems_bdbuf_configuration+0x1c>
    bdbuf_config.task_stack_size : RTEMS_BDBUF_TASK_STACK_SIZE_DEFAULT;
4000cd7c:	80 a2 a0 00 	cmp  %o2, 0                                    
4000cd80:	12 80 00 03 	bne  4000cd8c <rtems_bdbuf_create_task.constprop.9+0x1c><== ALWAYS TAKEN
4000cd84:	92 10 00 19 	mov  %i1, %o1                                  
4000cd88:	15 00 00 04 	sethi  %hi(0x1000), %o2                        <== NOT EXECUTED
                                                                      
  priority = priority != 0 ? priority : default_priority;             
4000cd8c:	80 a2 60 00 	cmp  %o1, 0                                    
4000cd90:	22 80 00 02 	be,a   4000cd98 <rtems_bdbuf_create_task.constprop.9+0x28><== NEVER TAKEN
4000cd94:	92 10 20 0f 	mov  0xf, %o1                                  <== NOT EXECUTED
                                                                      
  sc = rtems_task_create (name,                                       
4000cd98:	90 10 00 18 	mov  %i0, %o0                                  
4000cd9c:	96 10 24 00 	mov  0x400, %o3                                
4000cda0:	98 10 20 00 	clr  %o4                                       
4000cda4:	7f ff ee b8 	call  40008884 <rtems_task_create>             
4000cda8:	9a 10 00 1c 	mov  %i4, %o5                                  
                          stack_size,                                 
                          RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,
                          RTEMS_LOCAL | RTEMS_NO_FLOATING_POINT,      
                          id);                                        
                                                                      
  if (sc == RTEMS_SUCCESSFUL)                                         
4000cdac:	80 a2 20 00 	cmp  %o0, 0                                    
4000cdb0:	02 80 00 04 	be  4000cdc0 <rtems_bdbuf_create_task.constprop.9+0x50><== ALWAYS TAKEN
4000cdb4:	b0 10 00 08 	mov  %o0, %i0                                  
    sc = rtems_task_start (*id, entry, arg);                          
                                                                      
  return sc;                                                          
}                                                                     
4000cdb8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000cdbc:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                          RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,
                          RTEMS_LOCAL | RTEMS_NO_FLOATING_POINT,      
                          id);                                        
                                                                      
  if (sc == RTEMS_SUCCESSFUL)                                         
    sc = rtems_task_start (*id, entry, arg);                          
4000cdc0:	f0 07 00 00 	ld  [ %i4 ], %i0                               
4000cdc4:	b2 10 00 1a 	mov  %i2, %i1                                  
4000cdc8:	7f ff ef 3a 	call  40008ab0 <rtems_task_start>              
4000cdcc:	95 e8 00 1b 	restore  %g0, %i3, %o2                         
                                                                      

4000c9f8 <rtems_bdbuf_disable_preemption>: --bd->group->users; } static rtems_mode rtems_bdbuf_disable_preemption (void) {
4000c9f8:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_mode prev_mode = 0;                                           
                                                                      
  sc = rtems_task_mode (RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &prev_mode);
4000c9fc:	90 10 21 00 	mov  0x100, %o0                                
                                                                      
static rtems_mode                                                     
rtems_bdbuf_disable_preemption (void)                                 
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_mode prev_mode = 0;                                           
4000ca00:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
                                                                      
  sc = rtems_task_mode (RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &prev_mode);
4000ca04:	92 10 21 00 	mov  0x100, %o1                                
4000ca08:	40 00 12 4d 	call  4001133c <rtems_task_mode>               
4000ca0c:	94 07 bf fc 	add  %fp, -4, %o2                              
  if (sc != RTEMS_SUCCESSFUL)                                         
4000ca10:	80 a2 20 00 	cmp  %o0, 0                                    
4000ca14:	12 80 00 04 	bne  4000ca24 <rtems_bdbuf_disable_preemption+0x2c><== NEVER TAKEN
4000ca18:	f0 07 bf fc 	ld  [ %fp + -4 ], %i0                          
    rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_PREEMPT_DIS);                
                                                                      
  return prev_mode;                                                   
}                                                                     
4000ca1c:	81 c7 e0 08 	ret                                            
4000ca20:	81 e8 00 00 	restore                                        
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_mode prev_mode = 0;                                           
                                                                      
  sc = rtems_task_mode (RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &prev_mode);
  if (sc != RTEMS_SUCCESSFUL)                                         
    rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_PREEMPT_DIS);                
4000ca24:	7f ff ff ba 	call  4000c90c <rtems_bdbuf_fatal>             <== NOT EXECUTED
4000ca28:	90 10 20 05 	mov  5, %o0                                    <== NOT EXECUTED
                                                                      

4000d1f0 <rtems_bdbuf_discard_buffer_after_access>: return bdbuf_cache.max_bds_per_group / bds_per_size; } static void rtems_bdbuf_discard_buffer_after_access (rtems_bdbuf_buffer *bd) {
4000d1f0:	9d e3 bf a0 	save  %sp, -96, %sp                            
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)                    
{                                                                     
  --bd->group->users;                                                 
4000d1f4:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
static void                                                           
rtems_bdbuf_discard_buffer (rtems_bdbuf_buffer *bd)                   
{                                                                     
  rtems_bdbuf_make_empty (bd);                                        
                                                                      
  if (bd->waiters == 0)                                               
4000d1f8:	c4 06 20 24 	ld  [ %i0 + 0x24 ], %g2                        
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)                    
{                                                                     
  --bd->group->users;                                                 
4000d1fc:	c6 00 60 0c 	ld  [ %g1 + 0xc ], %g3                         
static void                                                           
rtems_bdbuf_discard_buffer (rtems_bdbuf_buffer *bd)                   
{                                                                     
  rtems_bdbuf_make_empty (bd);                                        
                                                                      
  if (bd->waiters == 0)                                               
4000d200:	80 a0 a0 00 	cmp  %g2, 0                                    
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)                    
{                                                                     
  --bd->group->users;                                                 
4000d204:	86 00 ff ff 	add  %g3, -1, %g3                              
4000d208:	c6 20 60 0c 	st  %g3, [ %g1 + 0xc ]                         
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000d20c:	82 10 20 01 	mov  1, %g1                                    
static void                                                           
rtems_bdbuf_discard_buffer (rtems_bdbuf_buffer *bd)                   
{                                                                     
  rtems_bdbuf_make_empty (bd);                                        
                                                                      
  if (bd->waiters == 0)                                               
4000d210:	02 80 00 05 	be  4000d224 <rtems_bdbuf_discard_buffer_after_access+0x34>
4000d214:	c2 26 20 20 	st  %g1, [ %i0 + 0x20 ]                        
{                                                                     
  rtems_bdbuf_group_release (bd);                                     
  rtems_bdbuf_discard_buffer (bd);                                    
                                                                      
  if (bd->waiters)                                                    
    rtems_bdbuf_wake (&bdbuf_cache.access_waiters);                   
4000d218:	31 10 00 6b 	sethi  %hi(0x4001ac00), %i0                    
4000d21c:	7f ff fe 85 	call  4000cc30 <rtems_bdbuf_wake>              
4000d220:	91 ee 23 98 	restore  %i0, 0x398, %o0                       
4000d224:	7f ff ff e6 	call  4000d1bc <rtems_bdbuf_discard_buffer.part.4>
4000d228:	90 10 00 18 	mov  %i0, %o0                                  
rtems_bdbuf_discard_buffer_after_access (rtems_bdbuf_buffer *bd)      
{                                                                     
  rtems_bdbuf_group_release (bd);                                     
  rtems_bdbuf_discard_buffer (bd);                                    
                                                                      
  if (bd->waiters)                                                    
4000d22c:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
4000d230:	80 a0 60 00 	cmp  %g1, 0                                    
4000d234:	32 bf ff fa 	bne,a   4000d21c <rtems_bdbuf_discard_buffer_after_access+0x2c><== NEVER TAKEN
4000d238:	31 10 00 6b 	sethi  %hi(0x4001ac00), %i0                    <== NOT EXECUTED
    rtems_bdbuf_wake (&bdbuf_cache.access_waiters);                   
  else                                                                
    rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);                   
4000d23c:	31 10 00 6b 	sethi  %hi(0x4001ac00), %i0                    
4000d240:	7f ff fe 7c 	call  4000cc30 <rtems_bdbuf_wake>              
4000d244:	91 ee 23 a8 	restore  %i0, 0x3a8, %o0                       
                                                                      

4000e0cc <rtems_bdbuf_execute_read_request>: static rtems_status_code rtems_bdbuf_execute_read_request (rtems_disk_device *dd, rtems_bdbuf_buffer *bd, uint32_t transfer_count) {
4000e0cc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  /*                                                                  
   * 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) +                  
4000e0d0:	83 2e a0 04 	sll  %i2, 4, %g1                               
4000e0d4:	82 00 60 20 	add  %g1, 0x20, %g1                            
4000e0d8:	9c 23 80 01 	sub  %sp, %g1, %sp                             
                     sizeof (rtems_blkdev_sg_buffer) * transfer_count);
                                                                      
  req->req = RTEMS_BLKDEV_REQ_READ;                                   
  req->done = rtems_bdbuf_transfer_done;                              
4000e0dc:	03 10 00 38 	sethi  %hi(0x4000e000), %g1                    
4000e0e0:	82 10 61 a0 	or  %g1, 0x1a0, %g1	! 4000e1a0 <rtems_bdbuf_transfer_done>
  /*                                                                  
   * 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) +                  
4000e0e4:	a2 03 a0 60 	add  %sp, 0x60, %l1                            
rtems_bdbuf_execute_read_request (rtems_disk_device  *dd,             
                                  rtems_bdbuf_buffer *bd,             
                                  uint32_t            transfer_count) 
{                                                                     
  rtems_blkdev_request *req = NULL;                                   
  rtems_blkdev_bnum media_block = bd->block;                          
4000e0e8:	f8 06 60 18 	ld  [ %i1 + 0x18 ], %i4                        
  uint32_t media_blocks_per_block = dd->media_blocks_per_block;       
  uint32_t block_size = dd->block_size;                               
4000e0ec:	e0 06 20 24 	ld  [ %i0 + 0x24 ], %l0                        
                                  rtems_bdbuf_buffer *bd,             
                                  uint32_t            transfer_count) 
{                                                                     
  rtems_blkdev_request *req = NULL;                                   
  rtems_blkdev_bnum media_block = bd->block;                          
  uint32_t media_blocks_per_block = dd->media_blocks_per_block;       
4000e0f0:	e4 06 20 2c 	ld  [ %i0 + 0x2c ], %l2                        
                                                                      
  req = bdbuf_alloc (sizeof (rtems_blkdev_request) +                  
                     sizeof (rtems_blkdev_sg_buffer) * transfer_count);
                                                                      
  req->req = RTEMS_BLKDEV_REQ_READ;                                   
  req->done = rtems_bdbuf_transfer_done;                              
4000e0f4:	c2 24 60 04 	st  %g1, [ %l1 + 4 ]                           
  req->io_task = rtems_task_self ();                                  
4000e0f8:	40 00 0c fd 	call  400114ec <rtems_task_self>               
4000e0fc:	c0 24 40 00 	clr  [ %l1 ]                                   
  rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);             
                                                                      
  req->bufs [0].user   = bd;                                          
  req->bufs [0].block  = media_block;                                 
  req->bufs [0].length = block_size;                                  
  req->bufs [0].buffer = bd->buffer;                                  
4000e100:	c2 06 60 1c 	ld  [ %i1 + 0x1c ], %g1                        
  req = bdbuf_alloc (sizeof (rtems_blkdev_request) +                  
                     sizeof (rtems_blkdev_sg_buffer) * transfer_count);
                                                                      
  req->req = RTEMS_BLKDEV_REQ_READ;                                   
  req->done = rtems_bdbuf_transfer_done;                              
  req->io_task = rtems_task_self ();                                  
4000e104:	d0 24 60 14 	st  %o0, [ %l1 + 0x14 ]                        
  req->bufnum = 0;                                                    
4000e108:	c0 24 60 10 	clr  [ %l1 + 0x10 ]                            
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000e10c:	84 10 20 09 	mov  9, %g2                                    
4000e110:	c4 26 60 20 	st  %g2, [ %i1 + 0x20 ]                        
  req->io_task = rtems_task_self ();                                  
  req->bufnum = 0;                                                    
                                                                      
  rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);             
                                                                      
  req->bufs [0].user   = bd;                                          
4000e114:	f2 24 60 24 	st  %i1, [ %l1 + 0x24 ]                        
  req->bufs [0].block  = media_block;                                 
4000e118:	f8 24 60 18 	st  %i4, [ %l1 + 0x18 ]                        
  req->bufs [0].length = block_size;                                  
4000e11c:	e0 24 60 1c 	st  %l0, [ %l1 + 0x1c ]                        
  req->bufs [0].buffer = bd->buffer;                                  
                                                                      
  if (rtems_bdbuf_tracer)                                             
    rtems_bdbuf_show_users ("read", bd);                              
                                                                      
  while (transfer_index < transfer_count)                             
4000e120:	80 a6 a0 01 	cmp  %i2, 1                                    
4000e124:	08 80 00 1d 	bleu  4000e198 <rtems_bdbuf_execute_read_request+0xcc>
4000e128:	c2 24 60 20 	st  %g1, [ %l1 + 0x20 ]                        
4000e12c:	ba 10 00 11 	mov  %l1, %i5                                  
{                                                                     
  rtems_blkdev_request *req = NULL;                                   
  rtems_blkdev_bnum media_block = bd->block;                          
  uint32_t media_blocks_per_block = dd->media_blocks_per_block;       
  uint32_t block_size = dd->block_size;                               
  uint32_t transfer_index = 1;                                        
4000e130:	b6 10 20 01 	mov  1, %i3                                    
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000e134:	10 80 00 0b 	b  4000e160 <rtems_bdbuf_execute_read_request+0x94>
4000e138:	b2 10 20 09 	mov  9, %i1                                    
    if (bd == NULL)                                                   
      break;                                                          
                                                                      
    rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);           
                                                                      
    req->bufs [transfer_index].user   = bd;                           
4000e13c:	d0 27 60 34 	st  %o0, [ %i5 + 0x34 ]                        
    req->bufs [transfer_index].block  = media_block;                  
4000e140:	f8 27 60 28 	st  %i4, [ %i5 + 0x28 ]                        
    req->bufs [transfer_index].length = block_size;                   
4000e144:	e0 27 60 2c 	st  %l0, [ %i5 + 0x2c ]                        
    req->bufs [transfer_index].buffer = bd->buffer;                   
4000e148:	c2 02 20 1c 	ld  [ %o0 + 0x1c ], %g1                        
                                                                      
    if (rtems_bdbuf_tracer)                                           
      rtems_bdbuf_show_users ("read", bd);                            
                                                                      
    ++transfer_index;                                                 
4000e14c:	b6 06 e0 01 	inc  %i3                                       
    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;                   
4000e150:	c2 27 60 30 	st  %g1, [ %i5 + 0x30 ]                        
  req->bufs [0].buffer = bd->buffer;                                  
                                                                      
  if (rtems_bdbuf_tracer)                                             
    rtems_bdbuf_show_users ("read", bd);                              
                                                                      
  while (transfer_index < transfer_count)                             
4000e154:	80 a6 c0 1a 	cmp  %i3, %i2                                  
4000e158:	02 80 00 09 	be  4000e17c <rtems_bdbuf_execute_read_request+0xb0>
4000e15c:	ba 07 60 10 	add  %i5, 0x10, %i5                            
  {                                                                   
    media_block += media_blocks_per_block;                            
4000e160:	b8 07 00 12 	add  %i4, %l2, %i4                             
                                                                      
    bd = rtems_bdbuf_get_buffer_for_read_ahead (dd, media_block);     
4000e164:	90 10 00 18 	mov  %i0, %o0                                  
4000e168:	7f ff fd 50 	call  4000d6a8 <rtems_bdbuf_get_buffer_for_read_ahead>
4000e16c:	92 10 00 1c 	mov  %i4, %o1                                  
                                                                      
    if (bd == NULL)                                                   
4000e170:	80 a2 20 00 	cmp  %o0, 0                                    
4000e174:	32 bf ff f2 	bne,a   4000e13c <rtems_bdbuf_execute_read_request+0x70><== ALWAYS TAKEN
4000e178:	f2 22 20 20 	st  %i1, [ %o0 + 0x20 ]                        
      rtems_bdbuf_show_users ("read", bd);                            
                                                                      
    ++transfer_index;                                                 
  }                                                                   
                                                                      
  req->bufnum = transfer_index;                                       
4000e17c:	f6 24 60 10 	st  %i3, [ %l1 + 0x10 ]                        
                                                                      
  return rtems_bdbuf_execute_transfer_request (dd, req, true);        
4000e180:	90 10 00 18 	mov  %i0, %o0                                  
4000e184:	92 10 00 11 	mov  %l1, %o1                                  
4000e188:	7f ff fd f5 	call  4000d95c <rtems_bdbuf_execute_transfer_request>
4000e18c:	94 10 20 01 	mov  1, %o2                                    
}                                                                     
4000e190:	81 c7 e0 08 	ret                                            
4000e194:	91 e8 00 08 	restore  %g0, %o0, %o0                         
{                                                                     
  rtems_blkdev_request *req = NULL;                                   
  rtems_blkdev_bnum media_block = bd->block;                          
  uint32_t media_blocks_per_block = dd->media_blocks_per_block;       
  uint32_t block_size = dd->block_size;                               
  uint32_t transfer_index = 1;                                        
4000e198:	10 bf ff f9 	b  4000e17c <rtems_bdbuf_execute_read_request+0xb0>
4000e19c:	b6 10 20 01 	mov  1, %i3                                    
                                                                      

4000d95c <rtems_bdbuf_execute_transfer_request>: static rtems_status_code rtems_bdbuf_execute_transfer_request (rtems_disk_device *dd, rtems_blkdev_request *req, bool cache_locked) {
4000d95c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  uint32_t transfer_index = 0;                                        
  bool wake_transfer_waiters = false;                                 
  bool wake_buffer_waiters = false;                                   
                                                                      
  if (cache_locked)                                                   
4000d960:	80 a6 a0 00 	cmp  %i2, 0                                    
4000d964:	12 80 00 6e 	bne  4000db1c <rtems_bdbuf_execute_transfer_request+0x1c0>
4000d968:	ba 10 00 18 	mov  %i0, %i5                                  
    rtems_bdbuf_unlock_cache ();                                      
                                                                      
  /* The return value will be ignored for transfer requests */        
  dd->ioctl (dd->phys_dev, RTEMS_BLKIO_REQUEST, req);                 
4000d96c:	c2 07 60 38 	ld  [ %i5 + 0x38 ], %g1                        
4000d970:	d0 07 60 08 	ld  [ %i5 + 8 ], %o0                           
4000d974:	94 10 00 19 	mov  %i1, %o2                                  
4000d978:	13 30 06 10 	sethi  %hi(0xc0184000), %o1                    
4000d97c:	9f c0 40 00 	call  %g1                                      
4000d980:	92 12 62 01 	or  %o1, 0x201, %o1	! c0184201 <LEON_REG+0x40184201>
                                                                      
  /* Wait for transfer request completion */                          
  rtems_bdbuf_wait_for_transient_event ();                            
4000d984:	7f ff ff e8 	call  4000d924 <rtems_bdbuf_wait_for_transient_event>
4000d988:	01 00 00 00 	nop                                            
  sc = req->status;                                                   
                                                                      
  rtems_bdbuf_lock_cache ();                                          
4000d98c:	7f ff fb f2 	call  4000c954 <rtems_bdbuf_lock_cache>        
4000d990:	f0 06 60 0c 	ld  [ %i1 + 0xc ], %i0                         
                                                                      
  /* Statistics */                                                    
  if (req->req == RTEMS_BLKDEV_REQ_READ)                              
4000d994:	c2 06 40 00 	ld  [ %i1 ], %g1                               
4000d998:	80 a0 60 00 	cmp  %g1, 0                                    
4000d99c:	12 80 00 47 	bne  4000dab8 <rtems_bdbuf_execute_transfer_request+0x15c>
4000d9a0:	c8 06 60 10 	ld  [ %i1 + 0x10 ], %g4                        
  {                                                                   
    dd->stats.read_blocks += req->bufnum;                             
4000d9a4:	c2 07 60 50 	ld  [ %i5 + 0x50 ], %g1                        
    if (sc != RTEMS_SUCCESSFUL)                                       
4000d9a8:	80 a6 20 00 	cmp  %i0, 0                                    
  rtems_bdbuf_lock_cache ();                                          
                                                                      
  /* Statistics */                                                    
  if (req->req == RTEMS_BLKDEV_REQ_READ)                              
  {                                                                   
    dd->stats.read_blocks += req->bufnum;                             
4000d9ac:	82 00 40 04 	add  %g1, %g4, %g1                             
    if (sc != RTEMS_SUCCESSFUL)                                       
4000d9b0:	12 80 00 57 	bne  4000db0c <rtems_bdbuf_execute_transfer_request+0x1b0>
4000d9b4:	c2 27 60 50 	st  %g1, [ %i5 + 0x50 ]                        
    ++dd->stats.write_transfers;                                      
    if (sc != RTEMS_SUCCESSFUL)                                       
      ++dd->stats.write_errors;                                       
  }                                                                   
                                                                      
  for (transfer_index = 0; transfer_index < req->bufnum; ++transfer_index)
4000d9b8:	80 a1 20 00 	cmp  %g4, 0                                    
4000d9bc:	02 80 00 35 	be  4000da90 <rtems_bdbuf_execute_transfer_request+0x134><== NEVER TAKEN
4000d9c0:	b6 10 20 00 	clr  %i3                                       
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
4000d9c4:	21 10 00 6b 	sethi  %hi(0x4001ac00), %l0                    
4000d9c8:	b8 10 00 19 	mov  %i1, %i4                                  
4000d9cc:	a0 14 23 34 	or  %l0, 0x334, %l0                            
4000d9d0:	a8 10 20 00 	clr  %l4                                       
4000d9d4:	ba 10 20 00 	clr  %i5                                       
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000d9d8:	a6 10 20 01 	mov  1, %l3                                    
4000d9dc:	a4 10 20 02 	mov  2, %l2                                    
                                                                      
  the_node->next = tail;                                              
4000d9e0:	10 80 00 16 	b  4000da38 <rtems_bdbuf_execute_transfer_request+0xdc>
4000d9e4:	a2 04 20 44 	add  %l0, 0x44, %l1                            
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)                    
{                                                                     
  --bd->group->users;                                                 
4000d9e8:	c2 02 20 28 	ld  [ %o0 + 0x28 ], %g1                        
    else                                                              
      wake_buffer_waiters = true;                                     
                                                                      
    rtems_bdbuf_group_release (bd);                                   
                                                                      
    if (sc == RTEMS_SUCCESSFUL && bd->state == RTEMS_BDBUF_STATE_TRANSFER)
4000d9ec:	80 a6 20 00 	cmp  %i0, 0                                    
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)                    
{                                                                     
  --bd->group->users;                                                 
4000d9f0:	c6 00 60 0c 	ld  [ %g1 + 0xc ], %g3                         
4000d9f4:	86 00 ff ff 	add  %g3, -1, %g3                              
    else                                                              
      wake_buffer_waiters = true;                                     
                                                                      
    rtems_bdbuf_group_release (bd);                                   
                                                                      
    if (sc == RTEMS_SUCCESSFUL && bd->state == RTEMS_BDBUF_STATE_TRANSFER)
4000d9f8:	12 80 00 06 	bne  4000da10 <rtems_bdbuf_execute_transfer_request+0xb4>
4000d9fc:	c6 20 60 0c 	st  %g3, [ %g1 + 0xc ]                         
4000da00:	c2 02 20 20 	ld  [ %o0 + 0x20 ], %g1                        
4000da04:	80 a0 60 09 	cmp  %g1, 9                                    
4000da08:	22 80 00 13 	be,a   4000da54 <rtems_bdbuf_execute_transfer_request+0xf8>
4000da0c:	c2 04 20 48 	ld  [ %l0 + 0x48 ], %g1                        
static void                                                           
rtems_bdbuf_discard_buffer (rtems_bdbuf_buffer *bd)                   
{                                                                     
  rtems_bdbuf_make_empty (bd);                                        
                                                                      
  if (bd->waiters == 0)                                               
4000da10:	80 a0 a0 00 	cmp  %g2, 0                                    
4000da14:	12 80 00 05 	bne  4000da28 <rtems_bdbuf_execute_transfer_request+0xcc>
4000da18:	e6 22 20 20 	st  %l3, [ %o0 + 0x20 ]                        
4000da1c:	7f ff fd e8 	call  4000d1bc <rtems_bdbuf_discard_buffer.part.4>
4000da20:	01 00 00 00 	nop                                            
4000da24:	c8 06 60 10 	ld  [ %i1 + 0x10 ], %g4                        
    ++dd->stats.write_transfers;                                      
    if (sc != RTEMS_SUCCESSFUL)                                       
      ++dd->stats.write_errors;                                       
  }                                                                   
                                                                      
  for (transfer_index = 0; transfer_index < req->bufnum; ++transfer_index)
4000da28:	ba 07 60 01 	inc  %i5                                       
4000da2c:	80 a1 00 1d 	cmp  %g4, %i5                                  
4000da30:	08 80 00 12 	bleu  4000da78 <rtems_bdbuf_execute_transfer_request+0x11c><== ALWAYS TAKEN
4000da34:	b8 07 20 10 	add  %i4, 0x10, %i4                            
  {                                                                   
    rtems_bdbuf_buffer *bd = req->bufs [transfer_index].user;         
4000da38:	d0 07 20 24 	ld  [ %i4 + 0x24 ], %o0                        
    bool waiters = bd->waiters;                                       
4000da3c:	c4 02 20 24 	ld  [ %o0 + 0x24 ], %g2                        
                                                                      
    if (waiters)                                                      
4000da40:	80 a0 a0 00 	cmp  %g2, 0                                    
4000da44:	32 bf ff e9 	bne,a   4000d9e8 <rtems_bdbuf_execute_transfer_request+0x8c>
4000da48:	a8 10 20 01 	mov  1, %l4                                    
      wake_transfer_waiters = true;                                   
    else                                                              
      wake_buffer_waiters = true;                                     
4000da4c:	10 bf ff e7 	b  4000d9e8 <rtems_bdbuf_execute_transfer_request+0x8c>
4000da50:	b6 10 20 01 	mov  1, %i3                                    
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000da54:	e4 22 20 20 	st  %l2, [ %o0 + 0x20 ]                        
4000da58:	e2 22 00 00 	st  %l1, [ %o0 ]                               
  tail->previous = the_node;                                          
4000da5c:	d0 24 20 48 	st  %o0, [ %l0 + 0x48 ]                        
  old_last->next = the_node;                                          
4000da60:	d0 20 40 00 	st  %o0, [ %g1 ]                               
  the_node->previous = old_last;                                      
4000da64:	c2 22 20 04 	st  %g1, [ %o0 + 4 ]                           
    ++dd->stats.write_transfers;                                      
    if (sc != RTEMS_SUCCESSFUL)                                       
      ++dd->stats.write_errors;                                       
  }                                                                   
                                                                      
  for (transfer_index = 0; transfer_index < req->bufnum; ++transfer_index)
4000da68:	ba 07 60 01 	inc  %i5                                       
4000da6c:	80 a1 00 1d 	cmp  %g4, %i5                                  
4000da70:	18 bf ff f2 	bgu  4000da38 <rtems_bdbuf_execute_transfer_request+0xdc>
4000da74:	b8 07 20 10 	add  %i4, 0x10, %i4                            
                                                                      
    if (rtems_bdbuf_tracer)                                           
      rtems_bdbuf_show_users ("transfer", bd);                        
  }                                                                   
                                                                      
  if (wake_transfer_waiters)                                          
4000da78:	80 8d 20 ff 	btst  0xff, %l4                                
4000da7c:	12 80 00 2c 	bne  4000db2c <rtems_bdbuf_execute_transfer_request+0x1d0>
4000da80:	11 10 00 6b 	sethi  %hi(0x4001ac00), %o0                    
    rtems_bdbuf_wake (&bdbuf_cache.transfer_waiters);                 
                                                                      
  if (wake_buffer_waiters)                                            
4000da84:	80 8e e0 ff 	btst  0xff, %i3                                
4000da88:	12 80 00 18 	bne  4000dae8 <rtems_bdbuf_execute_transfer_request+0x18c>
4000da8c:	11 10 00 6b 	sethi  %hi(0x4001ac00), %o0                    
    rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);                   
                                                                      
  if (!cache_locked)                                                  
4000da90:	80 a6 a0 00 	cmp  %i2, 0                                    
4000da94:	02 80 00 1a 	be  4000dafc <rtems_bdbuf_execute_transfer_request+0x1a0>
4000da98:	01 00 00 00 	nop                                            
    rtems_bdbuf_unlock_cache ();                                      
                                                                      
  if (sc == RTEMS_SUCCESSFUL || sc == RTEMS_UNSATISFIED)              
4000da9c:	80 a6 20 0d 	cmp  %i0, 0xd                                  
4000daa0:	02 80 00 04 	be  4000dab0 <rtems_bdbuf_execute_transfer_request+0x154>
4000daa4:	80 a6 20 00 	cmp  %i0, 0                                    
4000daa8:	32 80 00 02 	bne,a   4000dab0 <rtems_bdbuf_execute_transfer_request+0x154>
4000daac:	b0 10 20 1b 	mov  0x1b, %i0                                 
    return sc;                                                        
  else                                                                
    return RTEMS_IO_ERROR;                                            
}                                                                     
4000dab0:	81 c7 e0 08 	ret                                            
4000dab4:	81 e8 00 00 	restore                                        
    if (sc != RTEMS_SUCCESSFUL)                                       
      ++dd->stats.read_errors;                                        
  }                                                                   
  else                                                                
  {                                                                   
    dd->stats.write_blocks += req->bufnum;                            
4000dab8:	c4 07 60 5c 	ld  [ %i5 + 0x5c ], %g2                        
    ++dd->stats.write_transfers;                                      
4000dabc:	c2 07 60 58 	ld  [ %i5 + 0x58 ], %g1                        
    if (sc != RTEMS_SUCCESSFUL)                                       
      ++dd->stats.read_errors;                                        
  }                                                                   
  else                                                                
  {                                                                   
    dd->stats.write_blocks += req->bufnum;                            
4000dac0:	84 00 80 04 	add  %g2, %g4, %g2                             
    ++dd->stats.write_transfers;                                      
4000dac4:	82 00 60 01 	inc  %g1                                       
    if (sc != RTEMS_SUCCESSFUL)                                       
      ++dd->stats.read_errors;                                        
  }                                                                   
  else                                                                
  {                                                                   
    dd->stats.write_blocks += req->bufnum;                            
4000dac8:	c4 27 60 5c 	st  %g2, [ %i5 + 0x5c ]                        
    ++dd->stats.write_transfers;                                      
    if (sc != RTEMS_SUCCESSFUL)                                       
4000dacc:	80 a6 20 00 	cmp  %i0, 0                                    
4000dad0:	02 bf ff ba 	be  4000d9b8 <rtems_bdbuf_execute_transfer_request+0x5c>
4000dad4:	c2 27 60 58 	st  %g1, [ %i5 + 0x58 ]                        
      ++dd->stats.write_errors;                                       
4000dad8:	c2 07 60 60 	ld  [ %i5 + 0x60 ], %g1                        
4000dadc:	82 00 60 01 	inc  %g1                                       
4000dae0:	10 bf ff b6 	b  4000d9b8 <rtems_bdbuf_execute_transfer_request+0x5c>
4000dae4:	c2 27 60 60 	st  %g1, [ %i5 + 0x60 ]                        
                                                                      
  if (wake_transfer_waiters)                                          
    rtems_bdbuf_wake (&bdbuf_cache.transfer_waiters);                 
                                                                      
  if (wake_buffer_waiters)                                            
    rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);                   
4000dae8:	7f ff fc 52 	call  4000cc30 <rtems_bdbuf_wake>              
4000daec:	90 12 23 a8 	or  %o0, 0x3a8, %o0                            
                                                                      
  if (!cache_locked)                                                  
4000daf0:	80 a6 a0 00 	cmp  %i2, 0                                    
4000daf4:	32 bf ff eb 	bne,a   4000daa0 <rtems_bdbuf_execute_transfer_request+0x144>
4000daf8:	80 a6 20 0d 	cmp  %i0, 0xd                                  
    rtems_bdbuf_unlock_cache ();                                      
4000dafc:	7f ff fb ac 	call  4000c9ac <rtems_bdbuf_unlock_cache>      
4000db00:	01 00 00 00 	nop                                            
                                                                      
  if (sc == RTEMS_SUCCESSFUL || sc == RTEMS_UNSATISFIED)              
4000db04:	10 bf ff e7 	b  4000daa0 <rtems_bdbuf_execute_transfer_request+0x144>
4000db08:	80 a6 20 0d 	cmp  %i0, 0xd                                  
  /* Statistics */                                                    
  if (req->req == RTEMS_BLKDEV_REQ_READ)                              
  {                                                                   
    dd->stats.read_blocks += req->bufnum;                             
    if (sc != RTEMS_SUCCESSFUL)                                       
      ++dd->stats.read_errors;                                        
4000db0c:	c2 07 60 54 	ld  [ %i5 + 0x54 ], %g1                        
4000db10:	82 00 60 01 	inc  %g1                                       
4000db14:	10 bf ff a9 	b  4000d9b8 <rtems_bdbuf_execute_transfer_request+0x5c>
4000db18:	c2 27 60 54 	st  %g1, [ %i5 + 0x54 ]                        
  uint32_t transfer_index = 0;                                        
  bool wake_transfer_waiters = false;                                 
  bool wake_buffer_waiters = false;                                   
                                                                      
  if (cache_locked)                                                   
    rtems_bdbuf_unlock_cache ();                                      
4000db1c:	7f ff fb a4 	call  4000c9ac <rtems_bdbuf_unlock_cache>      
4000db20:	01 00 00 00 	nop                                            
                                                                      
  /* The return value will be ignored for transfer requests */        
  dd->ioctl (dd->phys_dev, RTEMS_BLKIO_REQUEST, req);                 
4000db24:	10 bf ff 93 	b  4000d970 <rtems_bdbuf_execute_transfer_request+0x14>
4000db28:	c2 07 60 38 	ld  [ %i5 + 0x38 ], %g1                        
    if (rtems_bdbuf_tracer)                                           
      rtems_bdbuf_show_users ("transfer", bd);                        
  }                                                                   
                                                                      
  if (wake_transfer_waiters)                                          
    rtems_bdbuf_wake (&bdbuf_cache.transfer_waiters);                 
4000db2c:	7f ff fc 41 	call  4000cc30 <rtems_bdbuf_wake>              
4000db30:	90 12 23 a0 	or  %o0, 0x3a0, %o0                            
                                                                      
  if (wake_buffer_waiters)                                            
4000db34:	10 bf ff d5 	b  4000da88 <rtems_bdbuf_execute_transfer_request+0x12c>
4000db38:	80 8e e0 ff 	btst  0xff, %i3                                
                                                                      

4000c90c <rtems_bdbuf_fatal>: #define RTEMS_BDBUF_AVL_MAX_HEIGHT (32) #endif static void rtems_bdbuf_fatal (rtems_fatal_code error) {
4000c90c:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
  rtems_fatal (RTEMS_FATAL_SOURCE_BDBUF, error);                      
4000c910:	90 10 20 03 	mov  3, %o0                                    <== NOT EXECUTED
4000c914:	7f ff f1 01 	call  40008d18 <rtems_fatal>                   <== NOT EXECUTED
4000c918:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
                                                                      

4000c96c <rtems_bdbuf_fatal_with_state>: } static void rtems_bdbuf_fatal_with_state (rtems_bdbuf_buf_state state, rtems_bdbuf_fatal_code error) {
4000c96c:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
  rtems_bdbuf_fatal ((((uint32_t) state) << 16) | error);             
4000c970:	b1 2e 20 10 	sll  %i0, 0x10, %i0                            <== NOT EXECUTED
4000c974:	7f ff ff e6 	call  4000c90c <rtems_bdbuf_fatal>             <== NOT EXECUTED
4000c978:	90 16 40 18 	or  %i1, %i0, %o0                              <== NOT EXECUTED
                                                                      

4000e73c <rtems_bdbuf_get>: rtems_status_code rtems_bdbuf_get (rtems_disk_device *dd, rtems_blkdev_bnum block, rtems_bdbuf_buffer **bd_ptr) {
4000e73c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code   sc = RTEMS_SUCCESSFUL;                          
  rtems_bdbuf_buffer *bd = NULL;                                      
  rtems_blkdev_bnum   media_block;                                    
                                                                      
  rtems_bdbuf_lock_cache ();                                          
4000e740:	7f ff f8 85 	call  4000c954 <rtems_bdbuf_lock_cache>        
4000e744:	b8 10 20 04 	mov  4, %i4                                    
                             rtems_blkdev_bnum        block,          
                             rtems_blkdev_bnum       *media_block_ptr)
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  if (block < dd->block_count)                                        
4000e748:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
4000e74c:	80 a6 40 01 	cmp  %i1, %g1                                  
4000e750:	0a 80 00 07 	bcs  4000e76c <rtems_bdbuf_get+0x30>           <== ALWAYS TAKEN
4000e754:	ba 10 20 00 	clr  %i5                                       
      rtems_bdbuf_show_users ("get", bd);                             
      rtems_bdbuf_show_usage ();                                      
    }                                                                 
  }                                                                   
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
4000e758:	7f ff f8 95 	call  4000c9ac <rtems_bdbuf_unlock_cache>      <== NOT EXECUTED
4000e75c:	b0 10 00 1c 	mov  %i4, %i0                                  <== NOT EXECUTED
                                                                      
  *bd_ptr = bd;                                                       
4000e760:	fa 26 80 00 	st  %i5, [ %i2 ]                               <== NOT EXECUTED
                                                                      
  return sc;                                                          
}                                                                     
4000e764:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000e768:	81 e8 00 00 	restore                                        <== NOT EXECUTED
}                                                                     
                                                                      
static rtems_blkdev_bnum                                              
rtems_bdbuf_media_block (const rtems_disk_device *dd, rtems_blkdev_bnum block)
{                                                                     
  if (dd->block_to_media_block_shift >= 0)                            
4000e76c:	d2 06 20 30 	ld  [ %i0 + 0x30 ], %o1                        
4000e770:	80 a2 60 00 	cmp  %o1, 0                                    
4000e774:	26 80 00 29 	bl,a   4000e818 <rtems_bdbuf_get+0xdc>         <== NEVER TAKEN
4000e778:	d6 06 20 24 	ld  [ %i0 + 0x24 ], %o3                        <== NOT EXECUTED
    return block << dd->block_to_media_block_shift;                   
4000e77c:	93 2e 40 09 	sll  %i1, %o1, %o1                             
    /*                                                                
     * Compute the media block number. Drivers work with media block number not
     * the block number a BD may have as this depends on the block size set by
     * the user.                                                      
     */                                                               
    *media_block_ptr = rtems_bdbuf_media_block (dd, block) + dd->start;
4000e780:	c2 06 20 18 	ld  [ %i0 + 0x18 ], %g1                        
     */                                                               
    if (rtems_bdbuf_tracer)                                           
      printf ("bdbuf:get: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",  
              media_block, block, (unsigned) dd->dev);                
                                                                      
    bd = rtems_bdbuf_get_buffer_for_access (dd, media_block);         
4000e784:	90 10 00 18 	mov  %i0, %o0                                  
4000e788:	7f ff fb df 	call  4000d704 <rtems_bdbuf_get_buffer_for_access>
4000e78c:	92 02 40 01 	add  %o1, %g1, %o1                             
4000e790:	ba 10 00 08 	mov  %o0, %i5                                  
                                                                      
    switch (bd->state)                                                
4000e794:	d0 02 20 20 	ld  [ %o0 + 0x20 ], %o0                        
4000e798:	80 a2 20 02 	cmp  %o0, 2                                    
4000e79c:	02 80 00 17 	be  4000e7f8 <rtems_bdbuf_get+0xbc>            
4000e7a0:	80 a2 20 07 	cmp  %o0, 7                                    
4000e7a4:	02 80 00 06 	be  4000e7bc <rtems_bdbuf_get+0x80>            
4000e7a8:	80 a2 20 01 	cmp  %o0, 1                                    
4000e7ac:	02 80 00 0c 	be  4000e7dc <rtems_bdbuf_get+0xa0>            <== ALWAYS TAKEN
4000e7b0:	82 10 20 05 	mov  5, %g1                                    
         * record of this so just gets the block to fill.             
         */                                                           
        rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_MODIFIED);
        break;                                                        
      default:                                                        
        rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_2);
4000e7b4:	7f ff f8 6e 	call  4000c96c <rtems_bdbuf_fatal_with_state>  <== NOT EXECUTED
4000e7b8:	92 10 20 0f 	mov  0xf, %o1                                  <== NOT EXECUTED
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000e7bc:	82 10 20 04 	mov  4, %g1                                    
4000e7c0:	b8 10 20 00 	clr  %i4                                       
4000e7c4:	c2 27 60 20 	st  %g1, [ %i5 + 0x20 ]                        
      rtems_bdbuf_show_users ("get", bd);                             
      rtems_bdbuf_show_usage ();                                      
    }                                                                 
  }                                                                   
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
4000e7c8:	7f ff f8 79 	call  4000c9ac <rtems_bdbuf_unlock_cache>      
4000e7cc:	b0 10 00 1c 	mov  %i4, %i0                                  
                                                                      
  *bd_ptr = bd;                                                       
4000e7d0:	fa 26 80 00 	st  %i5, [ %i2 ]                               
                                                                      
  return sc;                                                          
}                                                                     
4000e7d4:	81 c7 e0 08 	ret                                            
4000e7d8:	81 e8 00 00 	restore                                        
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000e7dc:	b8 10 20 00 	clr  %i4                                       
4000e7e0:	c2 27 60 20 	st  %g1, [ %i5 + 0x20 ]                        
      rtems_bdbuf_show_users ("get", bd);                             
      rtems_bdbuf_show_usage ();                                      
    }                                                                 
  }                                                                   
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
4000e7e4:	7f ff f8 72 	call  4000c9ac <rtems_bdbuf_unlock_cache>      
4000e7e8:	b0 10 00 1c 	mov  %i4, %i0                                  
                                                                      
  *bd_ptr = bd;                                                       
4000e7ec:	fa 26 80 00 	st  %i5, [ %i2 ]                               
                                                                      
  return sc;                                                          
}                                                                     
4000e7f0:	81 c7 e0 08 	ret                                            
4000e7f4:	81 e8 00 00 	restore                                        
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000e7f8:	82 10 20 03 	mov  3, %g1                                    
4000e7fc:	b8 10 20 00 	clr  %i4                                       
4000e800:	c2 27 60 20 	st  %g1, [ %i5 + 0x20 ]                        
      rtems_bdbuf_show_users ("get", bd);                             
      rtems_bdbuf_show_usage ();                                      
    }                                                                 
  }                                                                   
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
4000e804:	7f ff f8 6a 	call  4000c9ac <rtems_bdbuf_unlock_cache>      
4000e808:	b0 10 00 1c 	mov  %i4, %i0                                  
                                                                      
  *bd_ptr = bd;                                                       
4000e80c:	fa 26 80 00 	st  %i5, [ %i2 ]                               
                                                                      
  return sc;                                                          
}                                                                     
4000e810:	81 c7 e0 08 	ret                                            
4000e814:	81 e8 00 00 	restore                                        
    /*                                                                
     * Change the block number for the block size to the block number for the media
     * block size. We have to use 64bit maths. There is no short cut here.
     */                                                               
    return (rtems_blkdev_bnum)                                        
      ((((uint64_t) block) * dd->block_size) / dd->media_block_size); 
4000e818:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
4000e81c:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
4000e820:	40 00 24 5e 	call  40017998 <__muldi3>                      <== NOT EXECUTED
4000e824:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4000e828:	d6 06 20 20 	ld  [ %i0 + 0x20 ], %o3                        <== NOT EXECUTED
4000e82c:	40 00 26 6c 	call  400181dc <__udivdi3>                     <== NOT EXECUTED
4000e830:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
    /*                                                                
     * Compute the media block number. Drivers work with media block number not
     * the block number a BD may have as this depends on the block size set by
     * the user.                                                      
     */                                                               
    *media_block_ptr = rtems_bdbuf_media_block (dd, block) + dd->start;
4000e834:	10 bf ff d4 	b  4000e784 <rtems_bdbuf_get+0x48>             <== NOT EXECUTED
4000e838:	c2 06 20 18 	ld  [ %i0 + 0x18 ], %g1                        <== NOT EXECUTED
                                                                      

4000d704 <rtems_bdbuf_get_buffer_for_access>: static rtems_bdbuf_buffer * rtems_bdbuf_get_buffer_for_access (rtems_disk_device *dd, rtems_blkdev_bnum block) {
4000d704:	9d e3 bf a0 	save  %sp, -96, %sp                            
4000d708:	3b 10 00 6b 	sethi  %hi(0x4001ac00), %i5                    
4000d70c:	b8 10 00 18 	mov  %i0, %i4                                  
4000d710:	ba 17 63 34 	or  %i5, 0x334, %i5                            
  rtems_bdbuf_buffer *bd = NULL;                                      
                                                                      
  do                                                                  
  {                                                                   
    bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);       
4000d714:	a6 10 00 1d 	mov  %i5, %l3                                  
        rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);           
        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);         
4000d718:	a0 07 60 6c 	add  %i5, 0x6c, %l0                            
        }                                                             
      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);           
4000d71c:	b4 07 60 64 	add  %i5, 0x64, %i2                            
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
4000d720:	b6 07 60 40 	add  %i5, 0x40, %i3                            
           * It is essential that we wait here without a special wait count and
           * without the group in use.  Otherwise we could trigger a wait ping
           * pong with another recycle waiter.  The state of the buffer is
           * arbitrary afterwards.                                    
           */                                                         
          rtems_bdbuf_anonymous_wait (&bdbuf_cache.buffer_waiters);   
4000d724:	a2 07 60 74 	add  %i5, 0x74, %l1                            
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_wait_for_buffer (void)                                    
{                                                                     
  if (!rtems_chain_is_empty (&bdbuf_cache.modified))                  
4000d728:	a4 07 60 50 	add  %i5, 0x50, %l2                            
{                                                                     
  rtems_bdbuf_buffer *bd = NULL;                                      
                                                                      
  do                                                                  
  {                                                                   
    bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);       
4000d72c:	d0 07 60 3c 	ld  [ %i5 + 0x3c ], %o0                        
4000d730:	92 10 00 1c 	mov  %i4, %o1                                  
4000d734:	7f ff fd 26 	call  4000cbcc <rtems_bdbuf_avl_search.isra.0> 
4000d738:	94 10 00 19 	mov  %i1, %o2                                  
                                                                      
    if (bd != NULL)                                                   
4000d73c:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4000d740:	02 80 00 34 	be  4000d810 <rtems_bdbuf_get_buffer_for_access+0x10c>
4000d744:	90 10 00 1c 	mov  %i4, %o0                                  
    {                                                                 
      if (bd->group->bds_per_group != dd->bds_per_group)              
4000d748:	c4 06 20 28 	ld  [ %i0 + 0x28 ], %g2                        
4000d74c:	c2 07 20 34 	ld  [ %i4 + 0x34 ], %g1                        
4000d750:	c4 00 a0 08 	ld  [ %g2 + 8 ], %g2                           
4000d754:	80 a0 80 01 	cmp  %g2, %g1                                  
4000d758:	12 80 00 0c 	bne  4000d788 <rtems_bdbuf_get_buffer_for_access+0x84>
4000d75c:	2d 10 00 31 	sethi  %hi(0x4000c400), %l6                    
        rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);           
        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);         
4000d760:	3b 10 00 6b 	sethi  %hi(0x4001ac00), %i5                    
static void                                                           
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)                  
{                                                                     
  while (true)                                                        
  {                                                                   
    switch (bd->state)                                                
4000d764:	39 10 00 31 	sethi  %hi(0x4000c400), %i4                    
        rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);           
        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);         
4000d768:	ba 17 63 a0 	or  %i5, 0x3a0, %i5                            
        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);           
4000d76c:	b6 07 7f f8 	add  %i5, -8, %i3                              
static void                                                           
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)                  
{                                                                     
  while (true)                                                        
  {                                                                   
    switch (bd->state)                                                
4000d770:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        
4000d774:	80 a2 20 0a 	cmp  %o0, 0xa                                  
4000d778:	08 80 00 4c 	bleu  4000d8a8 <rtems_bdbuf_get_buffer_for_access+0x1a4><== ALWAYS TAKEN
4000d77c:	84 17 23 04 	or  %i4, 0x304, %g2                            
      case RTEMS_BDBUF_STATE_TRANSFER:                                
      case RTEMS_BDBUF_STATE_TRANSFER_PURGED:                         
        rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);         
        break;                                                        
      default:                                                        
        rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_7);
4000d780:	7f ff fc 7b 	call  4000c96c <rtems_bdbuf_fatal_with_state>  <== NOT EXECUTED
4000d784:	92 10 20 13 	mov  0x13, %o1                                 <== NOT EXECUTED
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000d788:	aa 10 20 08 	mov  8, %l5                                    
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
                                                                      
  the_node->next = tail;                                              
4000d78c:	a8 07 60 5c 	add  %i5, 0x5c, %l4                            
static bool                                                           
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)                 
{                                                                     
  while (true)                                                        
  {                                                                   
    switch (bd->state)                                                
4000d790:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        
4000d794:	80 a2 20 0a 	cmp  %o0, 0xa                                  
4000d798:	08 80 00 04 	bleu  4000d7a8 <rtems_bdbuf_get_buffer_for_access+0xa4><== ALWAYS TAKEN
4000d79c:	82 15 a3 30 	or  %l6, 0x330, %g1                            
      case RTEMS_BDBUF_STATE_TRANSFER:                                
      case RTEMS_BDBUF_STATE_TRANSFER_PURGED:                         
        rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);         
        break;                                                        
      default:                                                        
        rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_8);
4000d7a0:	7f ff fc 73 	call  4000c96c <rtems_bdbuf_fatal_with_state>  <== NOT EXECUTED
4000d7a4:	92 10 20 14 	mov  0x14, %o1                                 <== NOT EXECUTED
static bool                                                           
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)                 
{                                                                     
  while (true)                                                        
  {                                                                   
    switch (bd->state)                                                
4000d7a8:	91 2a 20 02 	sll  %o0, 2, %o0                               
4000d7ac:	c2 00 40 08 	ld  [ %g1 + %o0 ], %g1                         
4000d7b0:	81 c0 40 00 	jmp  %g1                                       
4000d7b4:	01 00 00 00 	nop                                            
      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)                                         
4000d7b8:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
4000d7bc:	80 a0 60 00 	cmp  %g1, 0                                    
4000d7c0:	12 80 00 1f 	bne  4000d83c <rtems_bdbuf_get_buffer_for_access+0x138><== ALWAYS TAKEN
4000d7c4:	01 00 00 00 	nop                                            
    {                                                                 
      if (bd->group->bds_per_group != dd->bds_per_group)              
      {                                                               
        if (rtems_bdbuf_wait_for_recycle (bd))                        
        {                                                             
          rtems_bdbuf_remove_from_tree_and_lru_list (bd);             
4000d7c8:	7f ff fe a0 	call  4000d248 <rtems_bdbuf_remove_from_tree_and_lru_list><== NOT EXECUTED
4000d7cc:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
4000d7d0:	c2 07 60 40 	ld  [ %i5 + 0x40 ], %g1                        <== NOT EXECUTED
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000d7d4:	c0 26 20 20 	clr  [ %i0 + 0x20 ]                            <== NOT EXECUTED
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
4000d7d8:	f6 26 20 04 	st  %i3, [ %i0 + 4 ]                           <== NOT EXECUTED
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
4000d7dc:	f0 27 60 40 	st  %i0, [ %i5 + 0x40 ]                        <== NOT EXECUTED
  the_node->next        = before_node;                                
4000d7e0:	c2 26 00 00 	st  %g1, [ %i0 ]                               <== NOT EXECUTED
  before_node->previous = the_node;                                   
4000d7e4:	f0 20 60 04 	st  %i0, [ %g1 + 4 ]                           <== 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);             
4000d7e8:	7f ff fd 12 	call  4000cc30 <rtems_bdbuf_wake>              <== NOT EXECUTED
4000d7ec:	90 07 60 74 	add  %i5, 0x74, %o0                            <== NOT EXECUTED
{                                                                     
  rtems_bdbuf_buffer *bd = NULL;                                      
                                                                      
  do                                                                  
  {                                                                   
    bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);       
4000d7f0:	d0 07 60 3c 	ld  [ %i5 + 0x3c ], %o0                        <== NOT EXECUTED
4000d7f4:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
4000d7f8:	7f ff fc f5 	call  4000cbcc <rtems_bdbuf_avl_search.isra.0> <== NOT EXECUTED
4000d7fc:	94 10 00 19 	mov  %i1, %o2                                  <== NOT EXECUTED
                                                                      
    if (bd != NULL)                                                   
4000d800:	b0 92 20 00 	orcc  %o0, 0, %i0                              <== NOT EXECUTED
4000d804:	32 bf ff d2 	bne,a   4000d74c <rtems_bdbuf_get_buffer_for_access+0x48><== NOT EXECUTED
4000d808:	c4 06 20 28 	ld  [ %i0 + 0x28 ], %g2                        <== NOT EXECUTED
        bd = NULL;                                                    
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      bd = rtems_bdbuf_get_buffer_from_lru_list (dd, block);          
4000d80c:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
4000d810:	7f ff fe a0 	call  4000d290 <rtems_bdbuf_get_buffer_from_lru_list>
4000d814:	92 10 00 19 	mov  %i1, %o1                                  
                                                                      
      if (bd == NULL)                                                 
4000d818:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4000d81c:	32 bf ff d2 	bne,a   4000d764 <rtems_bdbuf_get_buffer_for_access+0x60>
4000d820:	3b 10 00 6b 	sethi  %hi(0x4001ac00), %i5                    
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_wait_for_buffer (void)                                    
{                                                                     
  if (!rtems_chain_is_empty (&bdbuf_cache.modified))                  
4000d824:	c2 04 e0 4c 	ld  [ %l3 + 0x4c ], %g1                        
4000d828:	80 a0 40 12 	cmp  %g1, %l2                                  
4000d82c:	02 80 00 04 	be  4000d83c <rtems_bdbuf_get_buffer_for_access+0x138>
4000d830:	01 00 00 00 	nop                                            
    rtems_bdbuf_wake_swapper ();                                      
4000d834:	7f ff fc 64 	call  4000c9c4 <rtems_bdbuf_wake_swapper>      
4000d838:	01 00 00 00 	nop                                            
           * It is essential that we wait here without a special wait count and
           * without the group in use.  Otherwise we could trigger a wait ping
           * pong with another recycle waiter.  The state of the buffer is
           * arbitrary afterwards.                                    
           */                                                         
          rtems_bdbuf_anonymous_wait (&bdbuf_cache.buffer_waiters);   
4000d83c:	7f ff fc 8c 	call  4000ca6c <rtems_bdbuf_anonymous_wait>    
4000d840:	90 10 00 11 	mov  %l1, %o0                                  
{                                                                     
  rtems_bdbuf_buffer *bd = NULL;                                      
                                                                      
  do                                                                  
  {                                                                   
    bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);       
4000d844:	10 bf ff bb 	b  4000d730 <rtems_bdbuf_get_buffer_for_access+0x2c>
4000d848:	d0 07 60 3c 	ld  [ %i5 + 0x3c ], %o0                        
        rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);           
        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);         
4000d84c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4000d850:	7f ff fc a5 	call  4000cae4 <rtems_bdbuf_wait>              <== NOT EXECUTED
4000d854:	92 10 00 10 	mov  %l0, %o1                                  <== NOT EXECUTED
static bool                                                           
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)                 
{                                                                     
  while (true)                                                        
  {                                                                   
    switch (bd->state)                                                
4000d858:	10 bf ff cf 	b  4000d794 <rtems_bdbuf_get_buffer_for_access+0x90><== NOT EXECUTED
4000d85c:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        <== NOT EXECUTED
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
4000d860:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
4000d864:	c4 06 00 00 	ld  [ %i0 ], %g2                               <== NOT EXECUTED
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000d868:	ea 26 20 20 	st  %l5, [ %i0 + 0x20 ]                        <== NOT EXECUTED
  previous       = the_node->previous;                                
  next->previous = previous;                                          
4000d86c:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]                           <== NOT EXECUTED
  previous->next = next;                                              
4000d870:	c4 20 40 00 	st  %g2, [ %g1 ]                               <== NOT EXECUTED
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
4000d874:	c2 07 60 60 	ld  [ %i5 + 0x60 ], %g1                        <== NOT EXECUTED
                                                                      
  the_node->next = tail;                                              
4000d878:	e8 26 00 00 	st  %l4, [ %i0 ]                               <== NOT EXECUTED
  tail->previous = the_node;                                          
4000d87c:	f0 27 60 60 	st  %i0, [ %i5 + 0x60 ]                        <== NOT EXECUTED
  old_last->next = the_node;                                          
4000d880:	f0 20 40 00 	st  %i0, [ %g1 ]                               <== 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_unprotected (&bd->link);                        
  rtems_chain_append_unprotected (&bdbuf_cache.sync, &bd->link);      
  rtems_bdbuf_wake_swapper ();                                        
4000d884:	7f ff fc 50 	call  4000c9c4 <rtems_bdbuf_wake_swapper>      <== NOT EXECUTED
4000d888:	c2 26 20 04 	st  %g1, [ %i0 + 4 ]                           <== NOT EXECUTED
static bool                                                           
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)                 
{                                                                     
  while (true)                                                        
  {                                                                   
    switch (bd->state)                                                
4000d88c:	10 bf ff c2 	b  4000d794 <rtems_bdbuf_get_buffer_for_access+0x90><== NOT EXECUTED
4000d890:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        <== NOT EXECUTED
        }                                                             
      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);           
4000d894:	90 10 00 18 	mov  %i0, %o0                                  
4000d898:	7f ff fc 93 	call  4000cae4 <rtems_bdbuf_wait>              
4000d89c:	92 10 00 1a 	mov  %i2, %o1                                  
static bool                                                           
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)                 
{                                                                     
  while (true)                                                        
  {                                                                   
    switch (bd->state)                                                
4000d8a0:	10 bf ff bd 	b  4000d794 <rtems_bdbuf_get_buffer_for_access+0x90>
4000d8a4:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        
static void                                                           
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)                  
{                                                                     
  while (true)                                                        
  {                                                                   
    switch (bd->state)                                                
4000d8a8:	83 2a 20 02 	sll  %o0, 2, %g1                               
4000d8ac:	c2 00 80 01 	ld  [ %g2 + %g1 ], %g1                         
4000d8b0:	81 c0 40 00 	jmp  %g1                                       
4000d8b4:	01 00 00 00 	nop                                            
        rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);           
        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);         
4000d8b8:	90 10 00 18 	mov  %i0, %o0                                  
4000d8bc:	7f ff fc 8a 	call  4000cae4 <rtems_bdbuf_wait>              
4000d8c0:	92 10 00 1d 	mov  %i5, %o1                                  
static void                                                           
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)                  
{                                                                     
  while (true)                                                        
  {                                                                   
    switch (bd->state)                                                
4000d8c4:	10 bf ff ac 	b  4000d774 <rtems_bdbuf_get_buffer_for_access+0x70>
4000d8c8:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)                    
{                                                                     
  --bd->group->users;                                                 
4000d8cc:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
4000d8d0:	c4 00 60 0c 	ld  [ %g1 + 0xc ], %g2                         
4000d8d4:	84 00 bf ff 	add  %g2, -1, %g2                              
4000d8d8:	c4 20 60 0c 	st  %g2, [ %g1 + 0xc ]                         
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
4000d8dc:	c6 06 00 00 	ld  [ %i0 ], %g3                               
  previous       = the_node->previous;                                
4000d8e0:	c4 06 20 04 	ld  [ %i0 + 4 ], %g2                           
  next->previous = previous;                                          
4000d8e4:	c4 20 e0 04 	st  %g2, [ %g3 + 4 ]                           
  previous->next = next;                                              
4000d8e8:	c6 20 80 00 	st  %g3, [ %g2 ]                               
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)                     
{                                                                     
  ++bd->group->users;                                                 
4000d8ec:	c4 00 60 0c 	ld  [ %g1 + 0xc ], %g2                         
4000d8f0:	84 00 a0 01 	inc  %g2                                       
4000d8f4:	c4 20 60 0c 	st  %g2, [ %g1 + 0xc ]                         
4000d8f8:	81 c7 e0 08 	ret                                            
4000d8fc:	81 e8 00 00 	restore                                        
        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);           
4000d900:	90 10 00 18 	mov  %i0, %o0                                  
4000d904:	7f ff fc 78 	call  4000cae4 <rtems_bdbuf_wait>              
4000d908:	92 10 00 1b 	mov  %i3, %o1                                  
static void                                                           
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)                  
{                                                                     
  while (true)                                                        
  {                                                                   
    switch (bd->state)                                                
4000d90c:	10 bf ff 9a 	b  4000d774 <rtems_bdbuf_get_buffer_for_access+0x70>
4000d910:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        
4000d914:	10 bf ff f2 	b  4000d8dc <rtems_bdbuf_get_buffer_for_access+0x1d8>
4000d918:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
4000d91c:	10 bf ff f4 	b  4000d8ec <rtems_bdbuf_get_buffer_for_access+0x1e8>
4000d920:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
                                                                      

4000d6a8 <rtems_bdbuf_get_buffer_for_read_ahead>: } static rtems_bdbuf_buffer * rtems_bdbuf_get_buffer_for_read_ahead (rtems_disk_device *dd, rtems_blkdev_bnum block) {
4000d6a8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_bdbuf_buffer *bd = NULL;                                      
                                                                      
  bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);         
4000d6ac:	03 10 00 6b 	sethi  %hi(0x4001ac00), %g1                    
4000d6b0:	d0 00 63 70 	ld  [ %g1 + 0x370 ], %o0	! 4001af70 <bdbuf_cache+0x3c>
4000d6b4:	92 10 00 18 	mov  %i0, %o1                                  
4000d6b8:	7f ff fd 45 	call  4000cbcc <rtems_bdbuf_avl_search.isra.0> 
4000d6bc:	94 10 00 19 	mov  %i1, %o2                                  
                                                                      
  if (bd == NULL)                                                     
4000d6c0:	80 a2 20 00 	cmp  %o0, 0                                    
4000d6c4:	02 80 00 04 	be  4000d6d4 <rtems_bdbuf_get_buffer_for_read_ahead+0x2c><== ALWAYS TAKEN
4000d6c8:	82 10 20 00 	clr  %g1                                       
     * thus no need for a read ahead.                                 
     */                                                               
    bd = NULL;                                                        
                                                                      
  return bd;                                                          
}                                                                     
4000d6cc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000d6d0:	91 e8 00 01 	restore  %g0, %g1, %o0                         <== NOT EXECUTED
                                                                      
  bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);         
                                                                      
  if (bd == NULL)                                                     
  {                                                                   
    bd = rtems_bdbuf_get_buffer_from_lru_list (dd, block);            
4000d6d4:	90 10 00 18 	mov  %i0, %o0                                  
4000d6d8:	7f ff fe ee 	call  4000d290 <rtems_bdbuf_get_buffer_from_lru_list>
4000d6dc:	92 10 00 19 	mov  %i1, %o1                                  
                                                                      
    if (bd != NULL)                                                   
4000d6e0:	82 92 20 00 	orcc  %o0, 0, %g1                              
4000d6e4:	02 bf ff fa 	be  4000d6cc <rtems_bdbuf_get_buffer_for_read_ahead+0x24><== NEVER TAKEN
4000d6e8:	01 00 00 00 	nop                                            
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)                     
{                                                                     
  ++bd->group->users;                                                 
4000d6ec:	c4 00 60 28 	ld  [ %g1 + 0x28 ], %g2                        
4000d6f0:	c6 00 a0 0c 	ld  [ %g2 + 0xc ], %g3                         
4000d6f4:	86 00 e0 01 	inc  %g3                                       
4000d6f8:	c6 20 a0 0c 	st  %g3, [ %g2 + 0xc ]                         
     * thus no need for a read ahead.                                 
     */                                                               
    bd = NULL;                                                        
                                                                      
  return bd;                                                          
}                                                                     
4000d6fc:	81 c7 e0 08 	ret                                            
4000d700:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      

4000d290 <rtems_bdbuf_get_buffer_from_lru_list>: } static rtems_bdbuf_buffer * rtems_bdbuf_get_buffer_from_lru_list (rtems_disk_device *dd, rtems_blkdev_bnum block) {
4000d290:	9d e3 bf 20 	save  %sp, -224, %sp                           
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return _Chain_Head( the_chain )->next;                              
4000d294:	35 10 00 6b 	sethi  %hi(0x4001ac00), %i2                    
4000d298:	b4 16 a3 34 	or  %i2, 0x334, %i2	! 4001af34 <bdbuf_cache>   
4000d29c:	fa 06 a0 40 	ld  [ %i2 + 0x40 ], %i5                        
  rtems_chain_node *node = rtems_chain_first (&bdbuf_cache.lru);      
                                                                      
  while (!rtems_chain_is_tail (&bdbuf_cache.lru, node))               
4000d2a0:	a4 06 a0 44 	add  %i2, 0x44, %l2                            
4000d2a4:	a6 06 a0 40 	add  %i2, 0x40, %l3                            
4000d2a8:	80 a7 40 12 	cmp  %i5, %l2                                  
4000d2ac:	12 80 00 07 	bne  4000d2c8 <rtems_bdbuf_get_buffer_from_lru_list+0x38>
4000d2b0:	a8 06 a0 74 	add  %i2, 0x74, %l4                            
    }                                                                 
                                                                      
    node = rtems_chain_next (node);                                   
  }                                                                   
                                                                      
  return NULL;                                                        
4000d2b4:	10 80 00 6c 	b  4000d464 <rtems_bdbuf_get_buffer_from_lru_list+0x1d4>
4000d2b8:	ba 10 20 00 	clr  %i5                                       
rtems_bdbuf_get_buffer_from_lru_list (rtems_disk_device *dd,          
                                      rtems_blkdev_bnum  block)       
{                                                                     
  rtems_chain_node *node = rtems_chain_first (&bdbuf_cache.lru);      
                                                                      
  while (!rtems_chain_is_tail (&bdbuf_cache.lru, node))               
4000d2bc:	80 a7 40 12 	cmp  %i5, %l2                                  
4000d2c0:	22 80 00 69 	be,a   4000d464 <rtems_bdbuf_get_buffer_from_lru_list+0x1d4>
4000d2c4:	ba 10 20 00 	clr  %i5                                       
              bd->group->bds_per_group, dd->bds_per_group);           
                                                                      
    /*                                                                
     * If nobody waits for this BD, we may recycle it.                
     */                                                               
    if (bd->waiters == 0)                                             
4000d2c8:	c2 07 60 24 	ld  [ %i5 + 0x24 ], %g1                        
4000d2cc:	80 a0 60 00 	cmp  %g1, 0                                    
4000d2d0:	32 bf ff fb 	bne,a   4000d2bc <rtems_bdbuf_get_buffer_from_lru_list+0x2c>
4000d2d4:	fa 07 40 00 	ld  [ %i5 ], %i5                               
    {                                                                 
      if (bd->group->bds_per_group == dd->bds_per_group)              
4000d2d8:	e0 07 60 28 	ld  [ %i5 + 0x28 ], %l0                        
4000d2dc:	e2 06 20 34 	ld  [ %i0 + 0x34 ], %l1                        
4000d2e0:	f6 04 20 08 	ld  [ %l0 + 8 ], %i3                           
4000d2e4:	80 a6 c0 11 	cmp  %i3, %l1                                  
4000d2e8:	02 80 00 37 	be  4000d3c4 <rtems_bdbuf_get_buffer_from_lru_list+0x134>
4000d2ec:	01 00 00 00 	nop                                            
      {                                                               
        rtems_bdbuf_remove_from_tree_and_lru_list (bd);               
                                                                      
        empty_bd = bd;                                                
      }                                                               
      else if (bd->group->users == 0)                                 
4000d2f0:	c2 04 20 0c 	ld  [ %l0 + 0xc ], %g1                         
4000d2f4:	80 a0 60 00 	cmp  %g1, 0                                    
4000d2f8:	32 bf ff f1 	bne,a   4000d2bc <rtems_bdbuf_get_buffer_from_lru_list+0x2c>
4000d2fc:	fa 07 40 00 	ld  [ %i5 ], %i5                               
  if (rtems_bdbuf_tracer)                                             
    printf ("bdbuf:realloc: %tu: %zd -> %zd\n",                       
            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; 
4000d300:	ec 06 a0 20 	ld  [ %i2 + 0x20 ], %l6                        
4000d304:	92 10 00 1b 	mov  %i3, %o1                                  
4000d308:	40 00 28 4c 	call  40017438 <.udiv>                         
4000d30c:	90 10 00 16 	mov  %l6, %o0                                  
                                                                      
  for (b = 0, bd = group->bdbuf;                                      
4000d310:	80 a6 e0 00 	cmp  %i3, 0                                    
4000d314:	02 80 00 0f 	be  4000d350 <rtems_bdbuf_get_buffer_from_lru_list+0xc0><== NEVER TAKEN
4000d318:	f8 04 20 10 	ld  [ %l0 + 0x10 ], %i4                        
4000d31c:	83 2a 20 03 	sll  %o0, 3, %g1                               
4000d320:	ab 2a 20 06 	sll  %o0, 6, %l5                               
4000d324:	b6 10 20 00 	clr  %i3                                       
4000d328:	aa 25 40 01 	sub  %l5, %g1, %l5                             
       b < group->bds_per_group;                                      
       b++, bd += bufs_per_bd)                                        
    rtems_bdbuf_remove_from_tree_and_lru_list (bd);                   
4000d32c:	7f ff ff c7 	call  4000d248 <rtems_bdbuf_remove_from_tree_and_lru_list>
4000d330:	90 10 00 1c 	mov  %i4, %o0                                  
            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;                                      
4000d334:	c2 04 20 08 	ld  [ %l0 + 8 ], %g1                           
       b < group->bds_per_group;                                      
       b++, bd += bufs_per_bd)                                        
4000d338:	b6 06 e0 01 	inc  %i3                                       
            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;                                      
4000d33c:	80 a6 c0 01 	cmp  %i3, %g1                                  
4000d340:	0a bf ff fb 	bcs  4000d32c <rtems_bdbuf_get_buffer_from_lru_list+0x9c>
4000d344:	b8 07 00 15 	add  %i4, %l5, %i4                             
4000d348:	ec 06 a0 20 	ld  [ %i2 + 0x20 ], %l6                        
4000d34c:	f8 04 20 10 	ld  [ %l0 + 0x10 ], %i4                        
       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;                           
4000d350:	e2 24 20 08 	st  %l1, [ %l0 + 8 ]                           
  bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;    
4000d354:	90 10 00 16 	mov  %l6, %o0                                  
4000d358:	40 00 28 38 	call  40017438 <.udiv>                         
4000d35c:	92 10 00 11 	mov  %l1, %o1                                  
                                                                      
  for (b = 1, bd = group->bdbuf + bufs_per_bd;                        
4000d360:	83 2a 20 03 	sll  %o0, 3, %g1                               
4000d364:	89 2a 20 06 	sll  %o0, 6, %g4                               
4000d368:	80 a4 60 01 	cmp  %l1, 1                                    
4000d36c:	88 21 00 01 	sub  %g4, %g1, %g4                             
4000d370:	08 80 00 10 	bleu  4000d3b0 <rtems_bdbuf_get_buffer_from_lru_list+0x120>
4000d374:	82 07 00 04 	add  %i4, %g4, %g1                             
4000d378:	84 10 20 01 	mov  1, %g2                                    
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000d37c:	c0 20 60 20 	clr  [ %g1 + 0x20 ]                            
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
4000d380:	c6 06 a0 40 	ld  [ %i2 + 0x40 ], %g3                        
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
4000d384:	e6 20 60 04 	st  %l3, [ %g1 + 4 ]                           
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
4000d388:	c2 26 a0 40 	st  %g1, [ %i2 + 0x40 ]                        
  the_node->next        = before_node;                                
4000d38c:	c6 20 40 00 	st  %g3, [ %g1 ]                               
  before_node->previous = the_node;                                   
4000d390:	c2 20 e0 04 	st  %g1, [ %g3 + 4 ]                           
  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)                                        
4000d394:	84 00 a0 01 	inc  %g2                                       
    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;                        
4000d398:	80 a0 80 11 	cmp  %g2, %l1                                  
4000d39c:	12 bf ff f8 	bne  4000d37c <rtems_bdbuf_get_buffer_from_lru_list+0xec>
4000d3a0:	82 00 40 04 	add  %g1, %g4, %g1                             
       b < group->bds_per_group;                                      
       b++, bd += bufs_per_bd)                                        
    rtems_bdbuf_make_free_and_add_to_lru_list (bd);                   
                                                                      
  if (b > 1)                                                          
    rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);                   
4000d3a4:	7f ff fe 23 	call  4000cc30 <rtems_bdbuf_wake>              
4000d3a8:	90 10 00 14 	mov  %l4, %o0                                  
4000d3ac:	f8 04 20 10 	ld  [ %l0 + 0x10 ], %i4                        
      }                                                               
      else if (bd->group->users == 0)                                 
        empty_bd = rtems_bdbuf_group_realloc (bd->group, dd->bds_per_group);
    }                                                                 
                                                                      
    if (empty_bd != NULL)                                             
4000d3b0:	80 a7 20 00 	cmp  %i4, 0                                    
4000d3b4:	22 bf ff c2 	be,a   4000d2bc <rtems_bdbuf_get_buffer_from_lru_list+0x2c><== NEVER TAKEN
4000d3b8:	fa 07 40 00 	ld  [ %i5 ], %i5                               <== NOT EXECUTED
    rtems_bdbuf_make_free_and_add_to_lru_list (bd);                   
                                                                      
  if (b > 1)                                                          
    rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);                   
                                                                      
  return group->bdbuf;                                                
4000d3bc:	10 80 00 04 	b  4000d3cc <rtems_bdbuf_get_buffer_from_lru_list+0x13c>
4000d3c0:	ba 10 00 1c 	mov  %i4, %i5                                  
     */                                                               
    if (bd->waiters == 0)                                             
    {                                                                 
      if (bd->group->bds_per_group == dd->bds_per_group)              
      {                                                               
        rtems_bdbuf_remove_from_tree_and_lru_list (bd);               
4000d3c4:	7f ff ff a1 	call  4000d248 <rtems_bdbuf_remove_from_tree_and_lru_list>
4000d3c8:	90 10 00 1d 	mov  %i5, %o0                                  
static void                                                           
rtems_bdbuf_setup_empty_buffer (rtems_bdbuf_buffer *bd,               
                                rtems_disk_device  *dd,               
                                rtems_blkdev_bnum   block)            
{                                                                     
  bd->dd        = dd ;                                                
4000d3cc:	f0 27 60 14 	st  %i0, [ %i5 + 0x14 ]                        
  bd->block     = block;                                              
  bd->avl.left  = NULL;                                               
4000d3d0:	c0 27 60 08 	clr  [ %i5 + 8 ]                               
  bd->avl.right = NULL;                                               
4000d3d4:	c0 27 60 0c 	clr  [ %i5 + 0xc ]                             
                       rtems_bdbuf_buffer*  node)                     
{                                                                     
  const rtems_disk_device *dd = node->dd;                             
  rtems_blkdev_bnum block = node->block;                              
                                                                      
  rtems_bdbuf_buffer*  p = *root;                                     
4000d3d8:	c2 06 a0 3c 	ld  [ %i2 + 0x3c ], %g1                        
rtems_bdbuf_setup_empty_buffer (rtems_bdbuf_buffer *bd,               
                                rtems_disk_device  *dd,               
                                rtems_blkdev_bnum   block)            
{                                                                     
  bd->dd        = dd ;                                                
  bd->block     = block;                                              
4000d3dc:	f2 27 60 18 	st  %i1, [ %i5 + 0x18 ]                        
  rtems_bdbuf_buffer*  buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];         
  rtems_bdbuf_buffer** buf_prev = buf_stack;                          
                                                                      
  bool modified = false;                                              
                                                                      
  if (p == NULL)                                                      
4000d3e0:	80 a0 60 00 	cmp  %g1, 0                                    
4000d3e4:	02 80 00 5c 	be  4000d554 <rtems_bdbuf_get_buffer_from_lru_list+0x2c4>
4000d3e8:	c0 27 60 24 	clr  [ %i5 + 0x24 ]                            
                                                                      
  while (p != NULL)                                                   
  {                                                                   
    *buf_prev++ = p;                                                  
                                                                      
    if (((uintptr_t) p->dd < (uintptr_t) dd)                          
4000d3ec:	c6 00 60 14 	ld  [ %g1 + 0x14 ], %g3                        
  rtems_bdbuf_buffer*  p = *root;                                     
  rtems_bdbuf_buffer*  q;                                             
  rtems_bdbuf_buffer*  p1;                                            
  rtems_bdbuf_buffer*  p2;                                            
  rtems_bdbuf_buffer*  buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];         
  rtems_bdbuf_buffer** buf_prev = buf_stack;                          
4000d3f0:	9e 07 bf 80 	add  %fp, -128, %o7                            
4000d3f4:	84 10 00 0f 	mov  %o7, %g2                                  
    return 0;                                                         
  }                                                                   
                                                                      
  while (p != NULL)                                                   
  {                                                                   
    *buf_prev++ = p;                                                  
4000d3f8:	c2 20 80 00 	st  %g1, [ %g2 ]                               
                                                                      
    if (((uintptr_t) p->dd < (uintptr_t) dd)                          
        || ((p->dd == dd) && (p->block < block)))                     
    {                                                                 
      p->avl.cache = 1;                                               
4000d3fc:	b8 10 20 01 	mov  1, %i4                                    
        break;                                                        
      }                                                               
    }                                                                 
    else if ((p->dd != dd) || (p->block != block))                    
    {                                                                 
      p->avl.cache = -1;                                              
4000d400:	b6 10 3f ff 	mov  -1, %i3                                   
                                                                      
  while (p != NULL)                                                   
  {                                                                   
    *buf_prev++ = p;                                                  
                                                                      
    if (((uintptr_t) p->dd < (uintptr_t) dd)                          
4000d404:	80 a0 c0 18 	cmp  %g3, %i0                                  
4000d408:	1a 80 00 0d 	bcc  4000d43c <rtems_bdbuf_get_buffer_from_lru_list+0x1ac><== ALWAYS TAKEN
4000d40c:	88 00 a0 04 	add  %g2, 4, %g4                               
        || ((p->dd == dd) && (p->block < block)))                     
    {                                                                 
      p->avl.cache = 1;                                               
      q = p->avl.right;                                               
4000d410:	c6 00 60 0c 	ld  [ %g1 + 0xc ], %g3                         <== NOT EXECUTED
      if (q == NULL)                                                  
4000d414:	80 a0 e0 00 	cmp  %g3, 0                                    
4000d418:	02 80 00 1d 	be  4000d48c <rtems_bdbuf_get_buffer_from_lru_list+0x1fc>
4000d41c:	f8 28 60 10 	stb  %i4, [ %g1 + 0x10 ]                       
  rtems_bdbuf_buffer*  buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];         
  rtems_bdbuf_buffer** buf_prev = buf_stack;                          
                                                                      
  bool modified = false;                                              
                                                                      
  if (p == NULL)                                                      
4000d420:	82 10 00 03 	mov  %g3, %g1                                  
                                                                      
  while (p != NULL)                                                   
  {                                                                   
    *buf_prev++ = p;                                                  
                                                                      
    if (((uintptr_t) p->dd < (uintptr_t) dd)                          
4000d424:	c6 00 60 14 	ld  [ %g1 + 0x14 ], %g3                        
4000d428:	84 10 00 04 	mov  %g4, %g2                                  
    return 0;                                                         
  }                                                                   
                                                                      
  while (p != NULL)                                                   
  {                                                                   
    *buf_prev++ = p;                                                  
4000d42c:	c2 20 80 00 	st  %g1, [ %g2 ]                               
                                                                      
    if (((uintptr_t) p->dd < (uintptr_t) dd)                          
4000d430:	80 a0 c0 18 	cmp  %g3, %i0                                  
4000d434:	0a bf ff f7 	bcs  4000d410 <rtems_bdbuf_get_buffer_from_lru_list+0x180><== NEVER TAKEN
4000d438:	88 00 a0 04 	add  %g2, 4, %g4                               
        || ((p->dd == dd) && (p->block < block)))                     
4000d43c:	80 a6 00 03 	cmp  %i0, %g3                                  
4000d440:	22 80 00 0b 	be,a   4000d46c <rtems_bdbuf_get_buffer_from_lru_list+0x1dc><== ALWAYS TAKEN
4000d444:	c6 00 60 18 	ld  [ %g1 + 0x18 ], %g3                        
      }                                                               
    }                                                                 
    else if ((p->dd != dd) || (p->block != block))                    
    {                                                                 
      p->avl.cache = -1;                                              
      q = p->avl.left;                                                
4000d448:	c6 00 60 08 	ld  [ %g1 + 8 ], %g3                           <== NOT EXECUTED
      if (q == NULL)                                                  
4000d44c:	80 a0 e0 00 	cmp  %g3, 0                                    
4000d450:	12 bf ff f4 	bne  4000d420 <rtems_bdbuf_get_buffer_from_lru_list+0x190>
4000d454:	f6 28 60 10 	stb  %i3, [ %g1 + 0x10 ]                       
      {                                                               
        q = node;                                                     
        p->avl.left = q;                                              
4000d458:	fa 20 60 08 	st  %i5, [ %g1 + 8 ]                           
4000d45c:	10 80 00 0e 	b  4000d494 <rtems_bdbuf_get_buffer_from_lru_list+0x204>
4000d460:	88 10 3f ff 	mov  -1, %g4                                   
                                                                      
    node = rtems_chain_next (node);                                   
  }                                                                   
                                                                      
  return NULL;                                                        
}                                                                     
4000d464:	81 c7 e0 08 	ret                                            
4000d468:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
  while (p != NULL)                                                   
  {                                                                   
    *buf_prev++ = p;                                                  
                                                                      
    if (((uintptr_t) p->dd < (uintptr_t) dd)                          
        || ((p->dd == dd) && (p->block < block)))                     
4000d46c:	80 a6 40 03 	cmp  %i1, %g3                                  
4000d470:	38 bf ff e9 	bgu,a   4000d414 <rtems_bdbuf_get_buffer_from_lru_list+0x184>
4000d474:	c6 00 60 0c 	ld  [ %g1 + 0xc ], %g3                         
        q = node;                                                     
        p->avl.right = q = node;                                      
        break;                                                        
      }                                                               
    }                                                                 
    else if ((p->dd != dd) || (p->block != block))                    
4000d478:	80 a6 40 03 	cmp  %i1, %g3                                  
4000d47c:	32 bf ff f4 	bne,a   4000d44c <rtems_bdbuf_get_buffer_from_lru_list+0x1bc><== ALWAYS TAKEN
4000d480:	c6 00 60 08 	ld  [ %g1 + 8 ], %g3                           
  bd->avl.left  = NULL;                                               
  bd->avl.right = NULL;                                               
  bd->waiters   = 0;                                                  
                                                                      
  if (rtems_bdbuf_avl_insert (&bdbuf_cache.tree, bd) != 0)            
    rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_RECYCLE);                    
4000d484:	7f ff fd 22 	call  4000c90c <rtems_bdbuf_fatal>             <== NOT EXECUTED
4000d488:	90 10 20 08 	mov  8, %o0                                    <== NOT EXECUTED
      p->avl.cache = 1;                                               
      q = p->avl.right;                                               
      if (q == NULL)                                                  
      {                                                               
        q = node;                                                     
        p->avl.right = q = node;                                      
4000d48c:	fa 20 60 0c 	st  %i5, [ %g1 + 0xc ]                         
4000d490:	88 10 20 01 	mov  1, %g4                                    
    }                                                                 
                                                                      
    p = q;                                                            
  }                                                                   
                                                                      
  q->avl.left = q->avl.right = NULL;                                  
4000d494:	c0 27 60 0c 	clr  [ %i5 + 0xc ]                             
4000d498:	c0 27 60 08 	clr  [ %i5 + 8 ]                               
  q->avl.bal = 0;                                                     
4000d49c:	c0 2f 60 11 	clrb  [ %i5 + 0x11 ]                           
4000d4a0:	89 29 20 18 	sll  %g4, 0x18, %g4                            
          p->avl.bal = 0;                                             
          modified = false;                                           
          break;                                                      
                                                                      
        case 0:                                                       
          p->avl.bal = 1;                                             
4000d4a4:	b2 10 20 01 	mov  1, %i1                                    
            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;
4000d4a8:	10 80 00 12 	b  4000d4f0 <rtems_bdbuf_get_buffer_from_lru_list+0x260>
4000d4ac:	b0 10 3f ff 	mov  -1, %i0                                   
          p->avl.bal = 0;                                             
          modified = false;                                           
          break;                                                      
                                                                      
        case 0:                                                       
          p->avl.bal = 1;                                             
4000d4b0:	86 10 00 01 	mov  %g1, %g3                                  
4000d4b4:	b8 10 20 01 	mov  1, %i4                                    
        default:                                                      
          break;                                                      
      }                                                               
    }                                                                 
    q = p;                                                            
    if (buf_prev > buf_stack)                                         
4000d4b8:	80 a0 80 0f 	cmp  %g2, %o7                                  
4000d4bc:	28 80 00 1e 	bleu,a   4000d534 <rtems_bdbuf_get_buffer_from_lru_list+0x2a4>
4000d4c0:	c6 26 a0 3c 	st  %g3, [ %i2 + 0x3c ]                        
    {                                                                 
      p = *--buf_prev;                                                
4000d4c4:	c2 00 bf fc 	ld  [ %g2 + -4 ], %g1                          
                                                                      
      if (p->avl.cache == -1)                                         
4000d4c8:	c8 08 60 10 	ldub  [ %g1 + 0x10 ], %g4                      
4000d4cc:	89 29 20 18 	sll  %g4, 0x18, %g4                            
4000d4d0:	b7 39 20 18 	sra  %g4, 0x18, %i3                            
4000d4d4:	80 a6 ff ff 	cmp  %i3, -1                                   
4000d4d8:	22 80 00 03 	be,a   4000d4e4 <rtems_bdbuf_get_buffer_from_lru_list+0x254>
4000d4dc:	c6 20 60 08 	st  %g3, [ %g1 + 8 ]                           
      {                                                               
        p->avl.left = q;                                              
      }                                                               
      else                                                            
      {                                                               
        p->avl.right = q;                                             
4000d4e0:	c6 20 60 0c 	st  %g3, [ %g1 + 0xc ]                         
  q->avl.left = q->avl.right = NULL;                                  
  q->avl.bal = 0;                                                     
  modified = true;                                                    
  buf_prev--;                                                         
                                                                      
  while (modified)                                                    
4000d4e4:	80 8f 20 ff 	btst  0xff, %i4                                
4000d4e8:	02 80 00 13 	be  4000d534 <rtems_bdbuf_get_buffer_from_lru_list+0x2a4>
4000d4ec:	84 00 bf fc 	add  %g2, -4, %g2                              
  {                                                                   
    if (p->avl.cache == -1)                                           
4000d4f0:	89 39 20 18 	sra  %g4, 0x18, %g4                            
4000d4f4:	80 a1 3f ff 	cmp  %g4, -1                                   
4000d4f8:	02 80 00 1e 	be  4000d570 <rtems_bdbuf_get_buffer_from_lru_list+0x2e0>
4000d4fc:	c6 48 60 11 	ldsb  [ %g1 + 0x11 ], %g3                      
          break;                                                      
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      switch (p->avl.bal)                                             
4000d500:	80 a0 e0 00 	cmp  %g3, 0                                    
4000d504:	22 bf ff eb 	be,a   4000d4b0 <rtems_bdbuf_get_buffer_from_lru_list+0x220>
4000d508:	f2 28 60 11 	stb  %i1, [ %g1 + 0x11 ]                       
4000d50c:	80 a0 e0 01 	cmp  %g3, 1                                    
4000d510:	02 80 00 1f 	be  4000d58c <rtems_bdbuf_get_buffer_from_lru_list+0x2fc>
4000d514:	80 a0 ff ff 	cmp  %g3, -1                                   
4000d518:	22 80 00 0c 	be,a   4000d548 <rtems_bdbuf_get_buffer_from_lru_list+0x2b8><== ALWAYS TAKEN
4000d51c:	c0 28 60 11 	clrb  [ %g1 + 0x11 ]                           
4000d520:	86 10 00 01 	mov  %g1, %g3                                  <== NOT EXECUTED
        default:                                                      
          break;                                                      
      }                                                               
    }                                                                 
    q = p;                                                            
    if (buf_prev > buf_stack)                                         
4000d524:	80 a0 80 0f 	cmp  %g2, %o7                                  <== NOT EXECUTED
4000d528:	18 bf ff e7 	bgu  4000d4c4 <rtems_bdbuf_get_buffer_from_lru_list+0x234><== NOT EXECUTED
4000d52c:	b8 10 20 01 	mov  1, %i4                                    <== NOT EXECUTED
        p->avl.right = q;                                             
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      *root = p;                                                      
4000d530:	c6 26 a0 3c 	st  %g3, [ %i2 + 0x3c ]                        <== NOT EXECUTED
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000d534:	82 10 20 01 	mov  1, %g1                                    
4000d538:	c2 27 60 20 	st  %g1, [ %i5 + 0x20 ]                        
                                                                      
    node = rtems_chain_next (node);                                   
  }                                                                   
                                                                      
  return NULL;                                                        
}                                                                     
4000d53c:	81 c7 e0 08 	ret                                            
4000d540:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
    else                                                              
    {                                                                 
      switch (p->avl.bal)                                             
      {                                                               
        case -1:                                                      
          p->avl.bal = 0;                                             
4000d544:	c0 28 60 11 	clrb  [ %g1 + 0x11 ]                           
4000d548:	86 10 00 01 	mov  %g1, %g3                                  
          modified = false;                                           
4000d54c:	10 bf ff db 	b  4000d4b8 <rtems_bdbuf_get_buffer_from_lru_list+0x228>
4000d550:	b8 10 20 00 	clr  %i4                                       
                                                                      
  bool modified = false;                                              
                                                                      
  if (p == NULL)                                                      
  {                                                                   
    *root = node;                                                     
4000d554:	fa 26 a0 3c 	st  %i5, [ %i2 + 0x3c ]                        
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000d558:	82 10 20 01 	mov  1, %g1                                    
  bool modified = false;                                              
                                                                      
  if (p == NULL)                                                      
  {                                                                   
    *root = node;                                                     
    node->avl.left = NULL;                                            
4000d55c:	c0 27 60 08 	clr  [ %i5 + 8 ]                               
    node->avl.right = NULL;                                           
4000d560:	c0 27 60 0c 	clr  [ %i5 + 0xc ]                             
    node->avl.bal = 0;                                                
4000d564:	c0 2f 60 11 	clrb  [ %i5 + 0x11 ]                           
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000d568:	10 bf ff f5 	b  4000d53c <rtems_bdbuf_get_buffer_from_lru_list+0x2ac>
4000d56c:	c2 27 60 20 	st  %g1, [ %i5 + 0x20 ]                        
                                                                      
  while (modified)                                                    
  {                                                                   
    if (p->avl.cache == -1)                                           
    {                                                                 
      switch (p->avl.bal)                                             
4000d570:	80 a0 e0 00 	cmp  %g3, 0                                    
4000d574:	12 80 00 20 	bne  4000d5f4 <rtems_bdbuf_get_buffer_from_lru_list+0x364>
4000d578:	80 a0 e0 01 	cmp  %g3, 1                                    
          p->avl.bal = 0;                                             
          modified = false;                                           
          break;                                                      
                                                                      
        case 0:                                                       
          p->avl.bal = -1;                                            
4000d57c:	c8 28 60 11 	stb  %g4, [ %g1 + 0x11 ]                       
4000d580:	86 10 00 01 	mov  %g1, %g3                                  
4000d584:	10 bf ff cd 	b  4000d4b8 <rtems_bdbuf_get_buffer_from_lru_list+0x228>
4000d588:	b8 10 20 01 	mov  1, %i4                                    
        case 0:                                                       
          p->avl.bal = 1;                                             
          break;                                                      
                                                                      
        case 1:                                                       
          p1 = p->avl.right;                                          
4000d58c:	c8 00 60 0c 	ld  [ %g1 + 0xc ], %g4                         
          if (p1->avl.bal == 1) /* simple RR-turn */                  
4000d590:	c6 49 20 11 	ldsb  [ %g4 + 0x11 ], %g3                      
4000d594:	80 a0 e0 01 	cmp  %g3, 1                                    
4000d598:	02 80 00 32 	be  4000d660 <rtems_bdbuf_get_buffer_from_lru_list+0x3d0>
4000d59c:	c6 01 20 08 	ld  [ %g4 + 8 ], %g3                           
            p = p1;                                                   
          }                                                           
          else /* double RL-turn */                                   
          {                                                           
            p2 = p1->avl.left;                                        
            p1->avl.left = p2->avl.right;                             
4000d5a0:	f6 00 e0 0c 	ld  [ %g3 + 0xc ], %i3                         
            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;
4000d5a4:	f8 48 e0 11 	ldsb  [ %g3 + 0x11 ], %i4                      
            p = p1;                                                   
          }                                                           
          else /* double RL-turn */                                   
          {                                                           
            p2 = p1->avl.left;                                        
            p1->avl.left = p2->avl.right;                             
4000d5a8:	f6 21 20 08 	st  %i3, [ %g4 + 8 ]                           
            p2->avl.right = p1;                                       
            p->avl.right = p2->avl.left;                              
4000d5ac:	f6 00 e0 08 	ld  [ %g3 + 8 ], %i3                           
          }                                                           
          else /* double RL-turn */                                   
          {                                                           
            p2 = p1->avl.left;                                        
            p1->avl.left = p2->avl.right;                             
            p2->avl.right = p1;                                       
4000d5b0:	c8 20 e0 0c 	st  %g4, [ %g3 + 0xc ]                         
            p->avl.right = p2->avl.left;                              
4000d5b4:	f6 20 60 0c 	st  %i3, [ %g1 + 0xc ]                         
            p2->avl.left = p;                                         
            if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
4000d5b8:	80 a7 20 01 	cmp  %i4, 1                                    
4000d5bc:	02 80 00 30 	be  4000d67c <rtems_bdbuf_get_buffer_from_lru_list+0x3ec><== NEVER TAKEN
4000d5c0:	c2 20 e0 08 	st  %g1, [ %g3 + 8 ]                           
4000d5c4:	c0 28 60 11 	clrb  [ %g1 + 0x11 ]                           
            if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
4000d5c8:	c2 48 e0 11 	ldsb  [ %g3 + 0x11 ], %g1                      
4000d5cc:	80 a0 7f ff 	cmp  %g1, -1                                   
4000d5d0:	22 80 00 06 	be,a   4000d5e8 <rtems_bdbuf_get_buffer_from_lru_list+0x358><== NEVER TAKEN
4000d5d4:	f2 29 20 11 	stb  %i1, [ %g4 + 0x11 ]                       <== NOT EXECUTED
4000d5d8:	c0 29 20 11 	clrb  [ %g4 + 0x11 ]                           
            p = p2;                                                   
          }                                                           
          p->avl.bal = 0;                                             
4000d5dc:	c0 28 e0 11 	clrb  [ %g3 + 0x11 ]                           
          modified = false;                                           
4000d5e0:	10 bf ff b6 	b  4000d4b8 <rtems_bdbuf_get_buffer_from_lru_list+0x228>
4000d5e4:	b8 10 20 00 	clr  %i4                                       
            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;                                             
4000d5e8:	c0 28 e0 11 	clrb  [ %g3 + 0x11 ]                           <== NOT EXECUTED
          modified = false;                                           
4000d5ec:	10 bf ff b3 	b  4000d4b8 <rtems_bdbuf_get_buffer_from_lru_list+0x228><== NOT EXECUTED
4000d5f0:	b8 10 20 00 	clr  %i4                                       <== NOT EXECUTED
                                                                      
  while (modified)                                                    
  {                                                                   
    if (p->avl.cache == -1)                                           
    {                                                                 
      switch (p->avl.bal)                                             
4000d5f4:	02 bf ff d4 	be  4000d544 <rtems_bdbuf_get_buffer_from_lru_list+0x2b4>
4000d5f8:	80 a0 ff ff 	cmp  %g3, -1                                   
4000d5fc:	32 bf ff ca 	bne,a   4000d524 <rtems_bdbuf_get_buffer_from_lru_list+0x294><== NEVER TAKEN
4000d600:	86 10 00 01 	mov  %g1, %g3                                  <== NOT EXECUTED
        case 0:                                                       
          p->avl.bal = -1;                                            
          break;                                                      
                                                                      
        case -1:                                                      
          p1 = p->avl.left;                                           
4000d604:	c8 00 60 08 	ld  [ %g1 + 8 ], %g4                           
          if (p1->avl.bal == -1) /* simple LL-turn */                 
4000d608:	c6 49 20 11 	ldsb  [ %g4 + 0x11 ], %g3                      
4000d60c:	80 a0 ff ff 	cmp  %g3, -1                                   
4000d610:	02 80 00 1d 	be  4000d684 <rtems_bdbuf_get_buffer_from_lru_list+0x3f4>
4000d614:	c6 01 20 0c 	ld  [ %g4 + 0xc ], %g3                         
            p = p1;                                                   
          }                                                           
          else /* double LR-turn */                                   
          {                                                           
            p2 = p1->avl.right;                                       
            p1->avl.right = p2->avl.left;                             
4000d618:	f6 00 e0 08 	ld  [ %g3 + 8 ], %i3                           
            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;
4000d61c:	f8 48 e0 11 	ldsb  [ %g3 + 0x11 ], %i4                      
            p = p1;                                                   
          }                                                           
          else /* double LR-turn */                                   
          {                                                           
            p2 = p1->avl.right;                                       
            p1->avl.right = p2->avl.left;                             
4000d620:	f6 21 20 0c 	st  %i3, [ %g4 + 0xc ]                         
            p2->avl.left = p1;                                        
            p->avl.left = p2->avl.right;                              
4000d624:	f6 00 e0 0c 	ld  [ %g3 + 0xc ], %i3                         
          }                                                           
          else /* double LR-turn */                                   
          {                                                           
            p2 = p1->avl.right;                                       
            p1->avl.right = p2->avl.left;                             
            p2->avl.left = p1;                                        
4000d628:	c8 20 e0 08 	st  %g4, [ %g3 + 8 ]                           
            p->avl.left = p2->avl.right;                              
4000d62c:	f6 20 60 08 	st  %i3, [ %g1 + 8 ]                           
            p2->avl.right = p;                                        
            if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
4000d630:	80 a7 3f ff 	cmp  %i4, -1                                   
4000d634:	02 80 00 1b 	be  4000d6a0 <rtems_bdbuf_get_buffer_from_lru_list+0x410>
4000d638:	c2 20 e0 0c 	st  %g1, [ %g3 + 0xc ]                         
4000d63c:	c0 28 60 11 	clrb  [ %g1 + 0x11 ]                           
            if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
4000d640:	c2 48 e0 11 	ldsb  [ %g3 + 0x11 ], %g1                      
4000d644:	80 a0 60 01 	cmp  %g1, 1                                    
4000d648:	32 bf ff e5 	bne,a   4000d5dc <rtems_bdbuf_get_buffer_from_lru_list+0x34c>
4000d64c:	c0 29 20 11 	clrb  [ %g4 + 0x11 ]                           
4000d650:	f0 29 20 11 	stb  %i0, [ %g4 + 0x11 ]                       
            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;                                             
4000d654:	c0 28 e0 11 	clrb  [ %g3 + 0x11 ]                           
          modified = false;                                           
4000d658:	10 bf ff 98 	b  4000d4b8 <rtems_bdbuf_get_buffer_from_lru_list+0x228>
4000d65c:	b8 10 20 00 	clr  %i4                                       
                                                                      
        case 1:                                                       
          p1 = p->avl.right;                                          
          if (p1->avl.bal == 1) /* simple RR-turn */                  
          {                                                           
            p->avl.right = p1->avl.left;                              
4000d660:	c6 20 60 0c 	st  %g3, [ %g1 + 0xc ]                         
            p1->avl.left = p;                                         
            p->avl.bal = 0;                                           
4000d664:	c0 28 60 11 	clrb  [ %g1 + 0x11 ]                           
        case 1:                                                       
          p1 = p->avl.right;                                          
          if (p1->avl.bal == 1) /* simple RR-turn */                  
          {                                                           
            p->avl.right = p1->avl.left;                              
            p1->avl.left = p;                                         
4000d668:	c2 21 20 08 	st  %g1, [ %g4 + 8 ]                           
            p->avl.bal = 0;                                           
4000d66c:	86 10 00 04 	mov  %g4, %g3                                  
            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;                                             
          modified = false;                                           
4000d670:	b8 10 20 00 	clr  %i4                                       
            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;                                             
4000d674:	10 bf ff 91 	b  4000d4b8 <rtems_bdbuf_get_buffer_from_lru_list+0x228>
4000d678:	c0 28 e0 11 	clrb  [ %g3 + 0x11 ]                           
            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;
4000d67c:	10 bf ff d3 	b  4000d5c8 <rtems_bdbuf_get_buffer_from_lru_list+0x338><== NOT EXECUTED
4000d680:	f0 28 60 11 	stb  %i0, [ %g1 + 0x11 ]                       <== NOT EXECUTED
                                                                      
        case -1:                                                      
          p1 = p->avl.left;                                           
          if (p1->avl.bal == -1) /* simple LL-turn */                 
          {                                                           
            p->avl.left = p1->avl.right;                              
4000d684:	c6 20 60 08 	st  %g3, [ %g1 + 8 ]                           
            p1->avl.right = p;                                        
            p->avl.bal = 0;                                           
4000d688:	c0 28 60 11 	clrb  [ %g1 + 0x11 ]                           
        case -1:                                                      
          p1 = p->avl.left;                                           
          if (p1->avl.bal == -1) /* simple LL-turn */                 
          {                                                           
            p->avl.left = p1->avl.right;                              
            p1->avl.right = p;                                        
4000d68c:	c2 21 20 0c 	st  %g1, [ %g4 + 0xc ]                         
            p->avl.bal = 0;                                           
4000d690:	86 10 00 04 	mov  %g4, %g3                                  
            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;                                             
          modified = false;                                           
4000d694:	b8 10 20 00 	clr  %i4                                       
            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;                                             
4000d698:	10 bf ff 88 	b  4000d4b8 <rtems_bdbuf_get_buffer_from_lru_list+0x228>
4000d69c:	c0 28 e0 11 	clrb  [ %g3 + 0x11 ]                           
            p2 = p1->avl.right;                                       
            p1->avl.right = p2->avl.left;                             
            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;
4000d6a0:	10 bf ff e8 	b  4000d640 <rtems_bdbuf_get_buffer_from_lru_list+0x3b0>
4000d6a4:	f2 28 60 11 	stb  %i1, [ %g1 + 0x11 ]                       
                                                                      

4000e310 <rtems_bdbuf_init>: * * @return rtems_status_code The initialisation status. */ rtems_status_code rtems_bdbuf_init (void) {
4000e310:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_mode          prev_mode;                                      
                                                                      
  if (rtems_bdbuf_tracer)                                             
    printf ("bdbuf:init\n");                                          
                                                                      
  if (rtems_interrupt_is_in_progress())                               
4000e314:	03 10 00 6d 	sethi  %hi(0x4001b400), %g1                    
4000e318:	c2 00 63 e8 	ld  [ %g1 + 0x3e8 ], %g1	! 4001b7e8 <_Per_CPU_Information+0x8>
4000e31c:	80 a0 60 00 	cmp  %g1, 0                                    
4000e320:	12 80 00 16 	bne  4000e378 <rtems_bdbuf_init+0x68>          <== NEVER TAKEN
4000e324:	b0 10 20 12 	mov  0x12, %i0                                 
    return RTEMS_CALLED_FROM_ISR;                                     
                                                                      
  /*                                                                  
   * Check the configuration table values.                            
   */                                                                 
  if ((bdbuf_config.buffer_max % bdbuf_config.buffer_min) != 0)       
4000e328:	3b 10 00 65 	sethi  %hi(0x40019400), %i5                    
4000e32c:	ba 17 62 08 	or  %i5, 0x208, %i5	! 40019608 <rtems_bdbuf_configuration>
4000e330:	f4 07 60 28 	ld  [ %i5 + 0x28 ], %i2                        
4000e334:	f6 07 60 24 	ld  [ %i5 + 0x24 ], %i3                        
4000e338:	90 10 00 1a 	mov  %i2, %o0                                  
4000e33c:	92 10 00 1b 	mov  %i3, %o1                                  
4000e340:	40 00 24 ea 	call  400176e8 <.urem>                         
4000e344:	b0 10 20 0a 	mov  0xa, %i0                                  
4000e348:	80 a2 20 00 	cmp  %o0, 0                                    
4000e34c:	12 80 00 fa 	bne  4000e734 <rtems_bdbuf_init+0x424>         <== NEVER TAKEN
4000e350:	01 00 00 00 	nop                                            
  /*                                                                  
   * 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 ();                      
4000e354:	7f ff f9 a9 	call  4000c9f8 <rtems_bdbuf_disable_preemption>
4000e358:	33 10 00 6b 	sethi  %hi(0x4001ac00), %i1                    
  if (bdbuf_cache.initialised)                                        
4000e35c:	b8 16 63 34 	or  %i1, 0x334, %i4	! 4001af34 <bdbuf_cache>   
4000e360:	c2 0f 20 95 	ldub  [ %i4 + 0x95 ], %g1                      
4000e364:	80 a0 60 00 	cmp  %g1, 0                                    
4000e368:	02 80 00 06 	be  4000e380 <rtems_bdbuf_init+0x70>           <== ALWAYS TAKEN
4000e36c:	b0 10 00 08 	mov  %o0, %i0                                  
  {                                                                   
    rtems_bdbuf_restore_preemption (prev_mode);                       
4000e370:	7f ff f9 b0 	call  4000ca30 <rtems_bdbuf_restore_preemption><== NOT EXECUTED
4000e374:	b0 10 20 0c 	mov  0xc, %i0                                  <== NOT EXECUTED
    return RTEMS_RESOURCE_IN_USE;                                     
4000e378:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000e37c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  memset(&bdbuf_cache, 0, sizeof(bdbuf_cache));                       
4000e380:	92 10 20 00 	clr  %o1                                       
4000e384:	94 10 20 98 	mov  0x98, %o2                                 
4000e388:	40 00 19 17 	call  400147e4 <memset>                        
4000e38c:	90 10 00 1c 	mov  %i4, %o0                                  
  bdbuf_cache.initialised = true;                                     
4000e390:	82 10 20 01 	mov  1, %g1                                    
  rtems_bdbuf_restore_preemption (prev_mode);                         
4000e394:	90 10 00 18 	mov  %i0, %o0                                  
4000e398:	7f ff f9 a6 	call  4000ca30 <rtems_bdbuf_restore_preemption>
4000e39c:	c2 2f 20 95 	stb  %g1, [ %i4 + 0x95 ]                       
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
4000e3a0:	82 07 20 0c 	add  %i4, 0xc, %g1                             
4000e3a4:	c2 27 20 08 	st  %g1, [ %i4 + 8 ]                           
  head->previous = NULL;                                              
  tail->previous = head;                                              
4000e3a8:	82 07 20 08 	add  %i4, 8, %g1                               
4000e3ac:	c2 27 20 10 	st  %g1, [ %i4 + 0x10 ]                        
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
4000e3b0:	82 07 20 50 	add  %i4, 0x50, %g1                            
  head->previous = NULL;                                              
  tail->previous = head;                                              
4000e3b4:	84 07 20 40 	add  %i4, 0x40, %g2                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
4000e3b8:	c2 27 20 4c 	st  %g1, [ %i4 + 0x4c ]                        
4000e3bc:	82 07 20 5c 	add  %i4, 0x5c, %g1                            
  head->previous = NULL;                                              
  tail->previous = head;                                              
4000e3c0:	c4 27 20 48 	st  %g2, [ %i4 + 0x48 ]                        
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
4000e3c4:	c2 27 20 58 	st  %g1, [ %i4 + 0x58 ]                        
  head->previous = NULL;                                              
  tail->previous = head;                                              
4000e3c8:	84 07 20 4c 	add  %i4, 0x4c, %g2                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
4000e3cc:	82 07 20 8c 	add  %i4, 0x8c, %g1                            
  head->previous = NULL;                                              
  tail->previous = head;                                              
4000e3d0:	c4 27 20 54 	st  %g2, [ %i4 + 0x54 ]                        
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
4000e3d4:	c2 27 20 88 	st  %g1, [ %i4 + 0x88 ]                        
  head->previous = NULL;                                              
  tail->previous = head;                                              
4000e3d8:	84 07 20 58 	add  %i4, 0x58, %g2                            
4000e3dc:	82 07 20 88 	add  %i4, 0x88, %g1                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
4000e3e0:	a0 07 20 44 	add  %i4, 0x44, %l0                            
   */                                                                 
  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;                        
4000e3e4:	c0 27 20 38 	clr  [ %i4 + 0x38 ]                            
  head->previous = NULL;                                              
4000e3e8:	c0 27 20 0c 	clr  [ %i4 + 0xc ]                             
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
4000e3ec:	e0 27 20 40 	st  %l0, [ %i4 + 0x40 ]                        
  head->previous = NULL;                                              
4000e3f0:	c0 27 20 44 	clr  [ %i4 + 0x44 ]                            
4000e3f4:	c0 27 20 50 	clr  [ %i4 + 0x50 ]                            
4000e3f8:	c0 27 20 5c 	clr  [ %i4 + 0x5c ]                            
  tail->previous = head;                                              
4000e3fc:	c4 27 20 60 	st  %g2, [ %i4 + 0x60 ]                        
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
4000e400:	c0 27 20 8c 	clr  [ %i4 + 0x8c ]                            
  rtems_chain_initialize_empty (&bdbuf_cache.read_ahead_chain);       
                                                                      
  /*                                                                  
   * Create the locks for the cache.                                  
   */                                                                 
  sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'l'), 
4000e404:	31 10 91 10 	sethi  %hi(0x42444000), %i0                    
  tail->previous = head;                                              
4000e408:	c2 27 20 90 	st  %g1, [ %i4 + 0x90 ]                        
4000e40c:	90 16 23 6c 	or  %i0, 0x36c, %o0                            
4000e410:	92 10 20 01 	mov  1, %o1                                    
4000e414:	94 10 20 54 	mov  0x54, %o2                                 
4000e418:	96 10 20 00 	clr  %o3                                       
4000e41c:	7f ff e7 e3 	call  400083a8 <rtems_semaphore_create>        
4000e420:	98 07 20 28 	add  %i4, 0x28, %o4                            
                               1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,  
                               &bdbuf_cache.lock);                    
  if (sc != RTEMS_SUCCESSFUL)                                         
4000e424:	80 a2 20 00 	cmp  %o0, 0                                    
4000e428:	02 80 00 2d 	be  4000e4dc <rtems_bdbuf_init+0x1cc>          <== ALWAYS TAKEN
4000e42c:	01 00 00 00 	nop                                            
                                                                      
  return RTEMS_SUCCESSFUL;                                            
                                                                      
error:                                                                
                                                                      
  if (bdbuf_cache.read_ahead_task != 0)                               
4000e430:	d0 07 20 84 	ld  [ %i4 + 0x84 ], %o0                        <== NOT EXECUTED
4000e434:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4000e438:	12 80 00 25 	bne  4000e4cc <rtems_bdbuf_init+0x1bc>         <== NOT EXECUTED
4000e43c:	01 00 00 00 	nop                                            <== NOT EXECUTED
    rtems_task_delete (bdbuf_cache.read_ahead_task);                  
                                                                      
  if (bdbuf_cache.swapout != 0)                                       
4000e440:	d0 06 63 34 	ld  [ %i1 + 0x334 ], %o0                       <== NOT EXECUTED
4000e444:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4000e448:	12 80 00 1e 	bne  4000e4c0 <rtems_bdbuf_init+0x1b0>         <== NOT EXECUTED
4000e44c:	01 00 00 00 	nop                                            <== NOT EXECUTED
    rtems_task_delete (bdbuf_cache.swapout);                          
                                                                      
  free (bdbuf_cache.buffers);                                         
4000e450:	7f ff d7 00 	call  40004050 <free>                          <== NOT EXECUTED
4000e454:	d0 07 20 18 	ld  [ %i4 + 0x18 ], %o0                        <== NOT EXECUTED
  free (bdbuf_cache.groups);                                          
4000e458:	7f ff d6 fe 	call  40004050 <free>                          <== NOT EXECUTED
4000e45c:	d0 07 20 80 	ld  [ %i4 + 0x80 ], %o0                        <== NOT EXECUTED
  free (bdbuf_cache.bds);                                             
4000e460:	7f ff d6 fc 	call  40004050 <free>                          <== NOT EXECUTED
4000e464:	d0 07 20 14 	ld  [ %i4 + 0x14 ], %o0                        <== NOT EXECUTED
                                                                      
  rtems_semaphore_delete (bdbuf_cache.buffer_waiters.sema);           
4000e468:	7f ff e8 41 	call  4000856c <rtems_semaphore_delete>        <== NOT EXECUTED
4000e46c:	d0 07 20 78 	ld  [ %i4 + 0x78 ], %o0                        <== NOT EXECUTED
  rtems_semaphore_delete (bdbuf_cache.access_waiters.sema);           
4000e470:	7f ff e8 3f 	call  4000856c <rtems_semaphore_delete>        <== NOT EXECUTED
4000e474:	d0 07 20 68 	ld  [ %i4 + 0x68 ], %o0                        <== NOT EXECUTED
  rtems_semaphore_delete (bdbuf_cache.transfer_waiters.sema);         
4000e478:	7f ff e8 3d 	call  4000856c <rtems_semaphore_delete>        <== NOT EXECUTED
4000e47c:	d0 07 20 70 	ld  [ %i4 + 0x70 ], %o0                        <== NOT EXECUTED
  rtems_semaphore_delete (bdbuf_cache.sync_lock);                     
4000e480:	7f ff e8 3b 	call  4000856c <rtems_semaphore_delete>        <== NOT EXECUTED
4000e484:	d0 07 20 2c 	ld  [ %i4 + 0x2c ], %o0                        <== NOT EXECUTED
                                                                      
  if (bdbuf_cache.lock != 0)                                          
4000e488:	c2 07 20 28 	ld  [ %i4 + 0x28 ], %g1                        <== NOT EXECUTED
4000e48c:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4000e490:	12 80 00 05 	bne  4000e4a4 <rtems_bdbuf_init+0x194>         <== NOT EXECUTED
4000e494:	01 00 00 00 	nop                                            <== NOT EXECUTED
  {                                                                   
    rtems_bdbuf_unlock_cache ();                                      
    rtems_semaphore_delete (bdbuf_cache.lock);                        
  }                                                                   
                                                                      
  bdbuf_cache.initialised = false;                                    
4000e498:	c0 2f 20 95 	clrb  [ %i4 + 0x95 ]                           <== NOT EXECUTED
                                                                      
  return RTEMS_UNSATISFIED;                                           
}                                                                     
4000e49c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000e4a0:	91 e8 20 0d 	restore  %g0, 0xd, %o0                         <== NOT EXECUTED
  rtems_semaphore_delete (bdbuf_cache.transfer_waiters.sema);         
  rtems_semaphore_delete (bdbuf_cache.sync_lock);                     
                                                                      
  if (bdbuf_cache.lock != 0)                                          
  {                                                                   
    rtems_bdbuf_unlock_cache ();                                      
4000e4a4:	7f ff f9 42 	call  4000c9ac <rtems_bdbuf_unlock_cache>      <== NOT EXECUTED
4000e4a8:	b0 10 20 0d 	mov  0xd, %i0                                  <== NOT EXECUTED
    rtems_semaphore_delete (bdbuf_cache.lock);                        
4000e4ac:	7f ff e8 30 	call  4000856c <rtems_semaphore_delete>        <== NOT EXECUTED
4000e4b0:	d0 07 20 28 	ld  [ %i4 + 0x28 ], %o0                        <== NOT EXECUTED
4000e4b4:	c0 2f 20 95 	clrb  [ %i4 + 0x95 ]                           <== NOT EXECUTED
4000e4b8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000e4bc:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
  if (bdbuf_cache.read_ahead_task != 0)                               
    rtems_task_delete (bdbuf_cache.read_ahead_task);                  
                                                                      
  if (bdbuf_cache.swapout != 0)                                       
    rtems_task_delete (bdbuf_cache.swapout);                          
4000e4c0:	7f ff e9 3a 	call  400089a8 <rtems_task_delete>             <== NOT EXECUTED
4000e4c4:	01 00 00 00 	nop                                            <== NOT EXECUTED
4000e4c8:	30 bf ff e2 	b,a   4000e450 <rtems_bdbuf_init+0x140>        <== NOT EXECUTED
  return RTEMS_SUCCESSFUL;                                            
                                                                      
error:                                                                
                                                                      
  if (bdbuf_cache.read_ahead_task != 0)                               
    rtems_task_delete (bdbuf_cache.read_ahead_task);                  
4000e4cc:	7f ff e9 37 	call  400089a8 <rtems_task_delete>             <== NOT EXECUTED
4000e4d0:	01 00 00 00 	nop                                            <== NOT EXECUTED
                                                                      
  if (bdbuf_cache.swapout != 0)                                       
4000e4d4:	10 bf ff dc 	b  4000e444 <rtems_bdbuf_init+0x134>           <== NOT EXECUTED
4000e4d8:	d0 06 63 34 	ld  [ %i1 + 0x334 ], %o0                       <== NOT EXECUTED
                               1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,  
                               &bdbuf_cache.lock);                    
  if (sc != RTEMS_SUCCESSFUL)                                         
    goto error;                                                       
                                                                      
  rtems_bdbuf_lock_cache ();                                          
4000e4dc:	7f ff f9 1e 	call  4000c954 <rtems_bdbuf_lock_cache>        
4000e4e0:	01 00 00 00 	nop                                            
                                                                      
  sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 's'), 
4000e4e4:	90 16 23 73 	or  %i0, 0x373, %o0                            
4000e4e8:	92 10 20 01 	mov  1, %o1                                    
4000e4ec:	94 10 20 54 	mov  0x54, %o2                                 
4000e4f0:	96 10 20 00 	clr  %o3                                       
4000e4f4:	7f ff e7 ad 	call  400083a8 <rtems_semaphore_create>        
4000e4f8:	98 07 20 2c 	add  %i4, 0x2c, %o4                            
                               1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,  
                               &bdbuf_cache.sync_lock);               
  if (sc != RTEMS_SUCCESSFUL)                                         
4000e4fc:	80 a2 20 00 	cmp  %o0, 0                                    
4000e500:	32 bf ff cd 	bne,a   4000e434 <rtems_bdbuf_init+0x124>      <== NEVER TAKEN
4000e504:	d0 07 20 84 	ld  [ %i4 + 0x84 ], %o0                        <== NOT EXECUTED
    goto error;                                                       
                                                                      
  sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'a'), 
4000e508:	90 16 23 61 	or  %i0, 0x361, %o0                            
4000e50c:	92 10 20 00 	clr  %o1                                       
4000e510:	94 10 20 24 	mov  0x24, %o2                                 
4000e514:	96 10 20 00 	clr  %o3                                       
4000e518:	7f ff e7 a4 	call  400083a8 <rtems_semaphore_create>        
4000e51c:	98 07 20 68 	add  %i4, 0x68, %o4                            
                               0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
                               &bdbuf_cache.access_waiters.sema);     
  if (sc != RTEMS_SUCCESSFUL)                                         
4000e520:	80 a2 20 00 	cmp  %o0, 0                                    
4000e524:	32 bf ff c4 	bne,a   4000e434 <rtems_bdbuf_init+0x124>      <== NEVER TAKEN
4000e528:	d0 07 20 84 	ld  [ %i4 + 0x84 ], %o0                        <== NOT EXECUTED
    goto error;                                                       
                                                                      
  sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 't'), 
4000e52c:	90 16 23 74 	or  %i0, 0x374, %o0                            
4000e530:	92 10 20 00 	clr  %o1                                       
4000e534:	94 10 20 24 	mov  0x24, %o2                                 
4000e538:	96 10 20 00 	clr  %o3                                       
4000e53c:	7f ff e7 9b 	call  400083a8 <rtems_semaphore_create>        
4000e540:	98 07 20 70 	add  %i4, 0x70, %o4                            
                               0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
                               &bdbuf_cache.transfer_waiters.sema);   
  if (sc != RTEMS_SUCCESSFUL)                                         
4000e544:	80 a2 20 00 	cmp  %o0, 0                                    
4000e548:	32 bf ff bb 	bne,a   4000e434 <rtems_bdbuf_init+0x124>      <== NEVER TAKEN
4000e54c:	d0 07 20 84 	ld  [ %i4 + 0x84 ], %o0                        <== NOT EXECUTED
    goto error;                                                       
                                                                      
  sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'b'), 
4000e550:	90 16 23 62 	or  %i0, 0x362, %o0                            
4000e554:	92 10 20 00 	clr  %o1                                       
4000e558:	94 10 20 24 	mov  0x24, %o2                                 
4000e55c:	96 10 20 00 	clr  %o3                                       
4000e560:	7f ff e7 92 	call  400083a8 <rtems_semaphore_create>        
4000e564:	98 07 20 78 	add  %i4, 0x78, %o4                            
                               0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
                               &bdbuf_cache.buffer_waiters.sema);     
  if (sc != RTEMS_SUCCESSFUL)                                         
4000e568:	80 a2 20 00 	cmp  %o0, 0                                    
4000e56c:	32 bf ff b2 	bne,a   4000e434 <rtems_bdbuf_init+0x124>      <== NEVER TAKEN
4000e570:	d0 07 20 84 	ld  [ %i4 + 0x84 ], %o0                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Compute the various number of elements in the cache.             
   */                                                                 
  bdbuf_cache.buffer_min_count =                                      
    bdbuf_config.size / bdbuf_config.buffer_min;                      
4000e574:	d0 07 60 20 	ld  [ %i5 + 0x20 ], %o0                        
4000e578:	40 00 23 b0 	call  40017438 <.udiv>                         
4000e57c:	92 10 00 1b 	mov  %i3, %o1                                  
  bdbuf_cache.max_bds_per_group =                                     
    bdbuf_config.buffer_max / bdbuf_config.buffer_min;                
4000e580:	92 10 00 1b 	mov  %i3, %o1                                  
                                                                      
  /*                                                                  
   * Compute the various number of elements in the cache.             
   */                                                                 
  bdbuf_cache.buffer_min_count =                                      
    bdbuf_config.size / bdbuf_config.buffer_min;                      
4000e584:	b0 10 00 08 	mov  %o0, %i0                                  
    goto error;                                                       
                                                                      
  /*                                                                  
   * Compute the various number of elements in the cache.             
   */                                                                 
  bdbuf_cache.buffer_min_count =                                      
4000e588:	d0 27 20 1c 	st  %o0, [ %i4 + 0x1c ]                        
    bdbuf_config.size / bdbuf_config.buffer_min;                      
  bdbuf_cache.max_bds_per_group =                                     
    bdbuf_config.buffer_max / bdbuf_config.buffer_min;                
4000e58c:	40 00 23 ab 	call  40017438 <.udiv>                         
4000e590:	90 10 00 1a 	mov  %i2, %o0                                  
4000e594:	82 10 00 08 	mov  %o0, %g1                                  
  bdbuf_cache.group_count =                                           
    bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;     
4000e598:	90 10 00 18 	mov  %i0, %o0                                  
4000e59c:	92 10 00 01 	mov  %g1, %o1                                  
4000e5a0:	40 00 23 a6 	call  40017438 <.udiv>                         
4000e5a4:	c2 27 20 20 	st  %g1, [ %i4 + 0x20 ]                        
                                                                      
  /*                                                                  
   * Allocate the memory for the buffer descriptors.                  
   */                                                                 
  bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),              
4000e5a8:	92 10 00 18 	mov  %i0, %o1                                  
   */                                                                 
  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 =                                           
4000e5ac:	d0 27 20 7c 	st  %o0, [ %i4 + 0x7c ]                        
    bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;     
4000e5b0:	b4 10 00 08 	mov  %o0, %i2                                  
                                                                      
  /*                                                                  
   * Allocate the memory for the buffer descriptors.                  
   */                                                                 
  bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),              
4000e5b4:	7f ff d6 70 	call  40003f74 <calloc>                        
4000e5b8:	90 10 20 38 	mov  0x38, %o0                                 
                            bdbuf_cache.buffer_min_count);            
  if (!bdbuf_cache.bds)                                               
4000e5bc:	80 a2 20 00 	cmp  %o0, 0                                    
4000e5c0:	02 bf ff 9c 	be  4000e430 <rtems_bdbuf_init+0x120>          <== NEVER TAKEN
4000e5c4:	d0 27 20 14 	st  %o0, [ %i4 + 0x14 ]                        
    goto error;                                                       
                                                                      
  /*                                                                  
   * Allocate the memory for the buffer descriptors.                  
   */                                                                 
  bdbuf_cache.groups = calloc (sizeof (rtems_bdbuf_group),            
4000e5c8:	90 10 20 14 	mov  0x14, %o0                                 
4000e5cc:	7f ff d6 6a 	call  40003f74 <calloc>                        
4000e5d0:	92 10 00 1a 	mov  %i2, %o1                                  
                               bdbuf_cache.group_count);              
  if (!bdbuf_cache.groups)                                            
4000e5d4:	80 a2 20 00 	cmp  %o0, 0                                    
4000e5d8:	02 bf ff 96 	be  4000e430 <rtems_bdbuf_init+0x120>          <== NEVER TAKEN
4000e5dc:	d0 27 20 80 	st  %o0, [ %i4 + 0x80 ]                        
   *                                                                  
   * The memory allocate allows a                                     
   */                                                                 
  if (rtems_memalign ((void **) &bdbuf_cache.buffers,                 
                      cache_aligment,                                 
                      bdbuf_cache.buffer_min_count * bdbuf_config.buffer_min) != 0)
4000e5e0:	92 10 00 1b 	mov  %i3, %o1                                  
4000e5e4:	40 00 23 5b 	call  40017350 <.umul>                         
4000e5e8:	90 10 00 18 	mov  %i0, %o0                                  
   * 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,                 
4000e5ec:	92 10 20 20 	mov  0x20, %o1                                 
                      cache_aligment,                                 
                      bdbuf_cache.buffer_min_count * bdbuf_config.buffer_min) != 0)
4000e5f0:	94 10 00 08 	mov  %o0, %o2                                  
   * 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,                 
4000e5f4:	11 10 00 6b 	sethi  %hi(0x4001ac00), %o0                    
4000e5f8:	40 00 07 73 	call  400103c4 <rtems_memalign>                
4000e5fc:	90 12 23 4c 	or  %o0, 0x34c, %o0	! 4001af4c <bdbuf_cache+0x18>
4000e600:	80 a2 20 00 	cmp  %o0, 0                                    
4000e604:	32 bf ff 8c 	bne,a   4000e434 <rtems_bdbuf_init+0x124>      <== NEVER TAKEN
4000e608:	d0 07 20 84 	ld  [ %i4 + 0x84 ], %o0                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   * 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,                             
4000e60c:	f0 07 20 80 	ld  [ %i4 + 0x80 ], %i0                        
         bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;          
4000e610:	e2 07 20 14 	ld  [ %i4 + 0x14 ], %l1                        
    bd->group  = group;                                               
    bd->buffer = buffer;                                              
                                                                      
    rtems_chain_append_unprotected (&bdbuf_cache.lru, &bd->link);     
                                                                      
    if ((b % bdbuf_cache.max_bds_per_group) ==                        
4000e614:	ea 07 20 20 	ld  [ %i4 + 0x20 ], %l5                        
  /*                                                                  
   * 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;          
4000e618:	e8 07 20 18 	ld  [ %i4 + 0x18 ], %l4                        
       b < bdbuf_cache.buffer_min_count;                              
4000e61c:	ee 07 20 1c 	ld  [ %i4 + 0x1c ], %l7                        
    bd->buffer = buffer;                                              
                                                                      
    rtems_chain_append_unprotected (&bdbuf_cache.lru, &bd->link);     
                                                                      
    if ((b % bdbuf_cache.max_bds_per_group) ==                        
        (bdbuf_cache.max_bds_per_group - 1))                          
4000e620:	ac 05 7f ff 	add  %l5, -1, %l6                              
  /*                                                                  
   * 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;          
4000e624:	b4 10 00 11 	mov  %l1, %i2                                  
                                                                      
  /*                                                                  
   * 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,                             
4000e628:	a6 10 00 18 	mov  %i0, %l3                                  
4000e62c:	a4 10 20 00 	clr  %l2                                       
4000e630:	80 a4 80 17 	cmp  %l2, %l7                                  
4000e634:	02 80 00 13 	be  4000e680 <rtems_bdbuf_init+0x370>          
4000e638:	90 10 00 12 	mov  %l2, %o0                                  
         bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;          
       b < bdbuf_cache.buffer_min_count;                              
       b++, bd++, buffer += bdbuf_config.buffer_min)                  
  {                                                                   
    bd->dd    = BDBUF_INVALID_DEV;                                    
    bd->group  = group;                                               
4000e63c:	e6 26 a0 28 	st  %l3, [ %i2 + 0x28 ]                        
    bd->buffer = buffer;                                              
4000e640:	e8 26 a0 1c 	st  %l4, [ %i2 + 0x1c ]                        
  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)                  
  {                                                                   
    bd->dd    = BDBUF_INVALID_DEV;                                    
4000e644:	c0 26 a0 14 	clr  [ %i2 + 0x14 ]                            
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
4000e648:	c2 07 20 48 	ld  [ %i4 + 0x48 ], %g1                        
                                                                      
  the_node->next = tail;                                              
4000e64c:	e0 26 80 00 	st  %l0, [ %i2 ]                               
  tail->previous = the_node;                                          
4000e650:	f4 27 20 48 	st  %i2, [ %i4 + 0x48 ]                        
  old_last->next = the_node;                                          
4000e654:	f4 20 40 00 	st  %i2, [ %g1 ]                               
  the_node->previous = old_last;                                      
4000e658:	c2 26 a0 04 	st  %g1, [ %i2 + 4 ]                           
    bd->group  = group;                                               
    bd->buffer = buffer;                                              
                                                                      
    rtems_chain_append_unprotected (&bdbuf_cache.lru, &bd->link);     
                                                                      
    if ((b % bdbuf_cache.max_bds_per_group) ==                        
4000e65c:	40 00 24 23 	call  400176e8 <.urem>                         
4000e660:	92 10 00 15 	mov  %l5, %o1                                  
4000e664:	80 a2 00 16 	cmp  %o0, %l6                                  
4000e668:	22 80 00 02 	be,a   4000e670 <rtems_bdbuf_init+0x360>       
4000e66c:	a6 04 e0 14 	add  %l3, 0x14, %l3                            
   * 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)                  
4000e670:	a4 04 a0 01 	inc  %l2                                       
4000e674:	b4 06 a0 38 	add  %i2, 0x38, %i2                            
4000e678:	10 bf ff ee 	b  4000e630 <rtems_bdbuf_init+0x320>           
4000e67c:	a8 05 00 1b 	add  %l4, %i3, %l4                             
       b < bdbuf_cache.group_count;                                   
       b++,                                                           
         group++,                                                     
         bd += bdbuf_cache.max_bds_per_group)                         
  {                                                                   
    group->bds_per_group = bdbuf_cache.max_bds_per_group;             
4000e680:	c4 07 20 20 	ld  [ %i4 + 0x20 ], %g2                        
  }                                                                   
                                                                      
  for (b = 0,                                                         
         group = bdbuf_cache.groups,                                  
         bd = bdbuf_cache.bds;                                        
       b < bdbuf_cache.group_count;                                   
4000e684:	f6 07 20 7c 	ld  [ %i4 + 0x7c ], %i3                        
       b++,                                                           
         group++,                                                     
         bd += bdbuf_cache.max_bds_per_group)                         
4000e688:	87 28 a0 03 	sll  %g2, 3, %g3                               
4000e68c:	89 28 a0 06 	sll  %g2, 6, %g4                               
4000e690:	82 10 20 00 	clr  %g1                                       
4000e694:	86 21 00 03 	sub  %g4, %g3, %g3                             
    if ((b % bdbuf_cache.max_bds_per_group) ==                        
        (bdbuf_cache.max_bds_per_group - 1))                          
      group++;                                                        
  }                                                                   
                                                                      
  for (b = 0,                                                         
4000e698:	80 a0 40 1b 	cmp  %g1, %i3                                  
4000e69c:	02 80 00 07 	be  4000e6b8 <rtems_bdbuf_init+0x3a8>          
4000e6a0:	82 00 60 01 	inc  %g1                                       
       b++,                                                           
         group++,                                                     
         bd += bdbuf_cache.max_bds_per_group)                         
  {                                                                   
    group->bds_per_group = bdbuf_cache.max_bds_per_group;             
    group->bdbuf = bd;                                                
4000e6a4:	e2 26 20 10 	st  %l1, [ %i0 + 0x10 ]                        
       b < bdbuf_cache.group_count;                                   
       b++,                                                           
         group++,                                                     
         bd += bdbuf_cache.max_bds_per_group)                         
  {                                                                   
    group->bds_per_group = bdbuf_cache.max_bds_per_group;             
4000e6a8:	c4 26 20 08 	st  %g2, [ %i0 + 8 ]                           
  for (b = 0,                                                         
         group = bdbuf_cache.groups,                                  
         bd = bdbuf_cache.bds;                                        
       b < bdbuf_cache.group_count;                                   
       b++,                                                           
         group++,                                                     
4000e6ac:	b0 06 20 14 	add  %i0, 0x14, %i0                            
         bd += bdbuf_cache.max_bds_per_group)                         
4000e6b0:	10 bf ff fa 	b  4000e698 <rtems_bdbuf_init+0x388>           
4000e6b4:	a2 04 40 03 	add  %l1, %g3, %l1                             
   * Create and start swapout task. This task will create and manage the worker
   * threads.                                                         
   */                                                                 
  bdbuf_cache.swapout_enabled = true;                                 
                                                                      
  sc = rtems_bdbuf_create_task (rtems_build_name('B', 'S', 'W', 'P'), 
4000e6b8:	d2 07 60 08 	ld  [ %i5 + 8 ], %o1                           
                                                                      
  /*                                                                  
   * Create and start swapout task. This task will create and manage the worker
   * threads.                                                         
   */                                                                 
  bdbuf_cache.swapout_enabled = true;                                 
4000e6bc:	b6 10 20 01 	mov  1, %i3                                    
                                                                      
  sc = rtems_bdbuf_create_task (rtems_build_name('B', 'S', 'W', 'P'), 
4000e6c0:	11 10 94 d5 	sethi  %hi(0x42535400), %o0                    
                                                                      
  /*                                                                  
   * Create and start swapout task. This task will create and manage the worker
   * threads.                                                         
   */                                                                 
  bdbuf_cache.swapout_enabled = true;                                 
4000e6c4:	f6 2f 20 04 	stb  %i3, [ %i4 + 4 ]                          
                                                                      
  sc = rtems_bdbuf_create_task (rtems_build_name('B', 'S', 'W', 'P'), 
4000e6c8:	90 12 23 50 	or  %o0, 0x350, %o0                            
4000e6cc:	96 10 20 00 	clr  %o3                                       
4000e6d0:	15 10 00 37 	sethi  %hi(0x4000dc00), %o2                    
4000e6d4:	98 10 00 1c 	mov  %i4, %o4                                  
4000e6d8:	7f ff f9 a6 	call  4000cd70 <rtems_bdbuf_create_task.constprop.9>
4000e6dc:	94 12 a0 a4 	or  %o2, 0xa4, %o2                             
                                bdbuf_config.swapout_priority,        
                                RTEMS_BDBUF_SWAPOUT_TASK_PRIORITY_DEFAULT,
                                rtems_bdbuf_swapout_task,             
                                0,                                    
                                &bdbuf_cache.swapout);                
  if (sc != RTEMS_SUCCESSFUL)                                         
4000e6e0:	80 a2 20 00 	cmp  %o0, 0                                    
4000e6e4:	32 bf ff 54 	bne,a   4000e434 <rtems_bdbuf_init+0x124>      <== NEVER TAKEN
4000e6e8:	d0 07 20 84 	ld  [ %i4 + 0x84 ], %o0                        <== NOT EXECUTED
    goto error;                                                       
                                                                      
  if (bdbuf_config.max_read_ahead_blocks > 0)                         
4000e6ec:	03 10 00 65 	sethi  %hi(0x40019400), %g1                    
4000e6f0:	c2 00 62 08 	ld  [ %g1 + 0x208 ], %g1	! 40019608 <rtems_bdbuf_configuration>
4000e6f4:	80 a0 60 00 	cmp  %g1, 0                                    
4000e6f8:	02 80 00 0d 	be  4000e72c <rtems_bdbuf_init+0x41c>          
4000e6fc:	11 10 94 91 	sethi  %hi(0x42524400), %o0                    
  {                                                                   
    bdbuf_cache.read_ahead_enabled = true;                            
    sc = rtems_bdbuf_create_task (rtems_build_name('B', 'R', 'D', 'A'),
4000e700:	d2 07 60 2c 	ld  [ %i5 + 0x2c ], %o1                        
  if (sc != RTEMS_SUCCESSFUL)                                         
    goto error;                                                       
                                                                      
  if (bdbuf_config.max_read_ahead_blocks > 0)                         
  {                                                                   
    bdbuf_cache.read_ahead_enabled = true;                            
4000e704:	f6 2f 20 94 	stb  %i3, [ %i4 + 0x94 ]                       
    sc = rtems_bdbuf_create_task (rtems_build_name('B', 'R', 'D', 'A'),
4000e708:	15 10 00 38 	sethi  %hi(0x4000e000), %o2                    
4000e70c:	90 12 20 41 	or  %o0, 0x41, %o0                             
4000e710:	94 12 a1 bc 	or  %o2, 0x1bc, %o2                            
4000e714:	96 10 20 00 	clr  %o3                                       
4000e718:	7f ff f9 96 	call  4000cd70 <rtems_bdbuf_create_task.constprop.9>
4000e71c:	98 07 20 84 	add  %i4, 0x84, %o4                            
                                  bdbuf_config.read_ahead_priority,   
                                  RTEMS_BDBUF_READ_AHEAD_TASK_PRIORITY_DEFAULT,
                                  rtems_bdbuf_read_ahead_task,        
                                  0,                                  
                                  &bdbuf_cache.read_ahead_task);      
    if (sc != RTEMS_SUCCESSFUL)                                       
4000e720:	80 a2 20 00 	cmp  %o0, 0                                    
4000e724:	32 bf ff 44 	bne,a   4000e434 <rtems_bdbuf_init+0x124>      <== NEVER TAKEN
4000e728:	d0 07 20 84 	ld  [ %i4 + 0x84 ], %o0                        <== NOT EXECUTED
      goto error;                                                     
  }                                                                   
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
4000e72c:	7f ff f8 a0 	call  4000c9ac <rtems_bdbuf_unlock_cache>      
4000e730:	b0 10 20 00 	clr  %i0                                       
                                                                      
  return RTEMS_SUCCESSFUL;                                            
4000e734:	81 c7 e0 08 	ret                                            
4000e738:	81 e8 00 00 	restore                                        
                                                                      

4000c920 <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) {
4000c920:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc = rtems_semaphore_obtain (lock,                
4000c924:	92 10 20 00 	clr  %o1                                       
4000c928:	90 10 00 18 	mov  %i0, %o0                                  
4000c92c:	7f ff ef 47 	call  40008648 <rtems_semaphore_obtain>        
4000c930:	94 10 20 00 	clr  %o2                                       
                                                 RTEMS_WAIT,          
                                                 RTEMS_NO_TIMEOUT);   
  if (sc != RTEMS_SUCCESSFUL)                                         
4000c934:	80 a2 20 00 	cmp  %o0, 0                                    
4000c938:	12 80 00 04 	bne  4000c948 <rtems_bdbuf_lock+0x28>          <== NEVER TAKEN
4000c93c:	01 00 00 00 	nop                                            
4000c940:	81 c7 e0 08 	ret                                            
4000c944:	81 e8 00 00 	restore                                        
    rtems_bdbuf_fatal (fatal_error_code);                             
4000c948:	7f ff ff f1 	call  4000c90c <rtems_bdbuf_fatal>             <== NOT EXECUTED
4000c94c:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
                                                                      

4000ed54 <rtems_bdbuf_purge_dev>: } } void rtems_bdbuf_purge_dev (rtems_disk_device *dd) {
4000ed54:	9d e3 bf 10 	save  %sp, -240, %sp                           
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
4000ed58:	b4 07 bf 74 	add  %fp, -140, %i2                            
4000ed5c:	b6 07 bf 78 	add  %fp, -136, %i3                            
  head->previous = NULL;                                              
4000ed60:	c0 27 bf 78 	clr  [ %fp + -136 ]                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
4000ed64:	f6 27 bf 74 	st  %i3, [ %fp + -140 ]                        
  rtems_chain_control purge_list;                                     
                                                                      
  rtems_chain_initialize_empty (&purge_list);                         
  rtems_bdbuf_lock_cache ();                                          
4000ed68:	7f ff f6 fb 	call  4000c954 <rtems_bdbuf_lock_cache>        
4000ed6c:	f4 27 bf 7c 	st  %i2, [ %fp + -132 ]                        
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(                   
  const Chain_Node *node                                              
)                                                                     
{                                                                     
  return (node->next == NULL) && (node->previous == NULL);            
4000ed70:	c2 06 20 64 	ld  [ %i0 + 0x64 ], %g1                        
4000ed74:	80 a0 60 00 	cmp  %g1, 0                                    
4000ed78:	02 80 00 70 	be  4000ef38 <rtems_bdbuf_purge_dev+0x1e4>     <== ALWAYS TAKEN
4000ed7c:	c4 06 20 68 	ld  [ %i0 + 0x68 ], %g2                        
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
  next->previous = previous;                                          
4000ed80:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           <== NOT EXECUTED
  previous->next = next;                                              
4000ed84:	c2 20 80 00 	st  %g1, [ %g2 ]                               <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(                       
  Chain_Node *node                                                    
)                                                                     
{                                                                     
  node->next = node->previous = NULL;                                 
4000ed88:	c0 26 20 68 	clr  [ %i0 + 0x68 ]                            <== NOT EXECUTED
4000ed8c:	c0 26 20 64 	clr  [ %i0 + 0x64 ]                            <== NOT EXECUTED
rtems_bdbuf_gather_for_purge (rtems_chain_control *purge_list,        
                              const rtems_disk_device *dd)            
{                                                                     
  rtems_bdbuf_buffer *stack [RTEMS_BDBUF_AVL_MAX_HEIGHT];             
  rtems_bdbuf_buffer **prev = stack;                                  
  rtems_bdbuf_buffer *cur = bdbuf_cache.tree;                         
4000ed90:	03 10 00 6b 	sethi  %hi(0x4001ac00), %g1                    <== NOT EXECUTED
4000ed94:	82 10 63 34 	or  %g1, 0x334, %g1	! 4001af34 <bdbuf_cache>   
4000ed98:	fa 00 60 3c 	ld  [ %g1 + 0x3c ], %i5                        
                                                                      
static void                                                           
rtems_bdbuf_read_ahead_reset (rtems_disk_device *dd)                  
{                                                                     
  rtems_bdbuf_read_ahead_cancel (dd);                                 
  dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;          
4000ed9c:	84 10 3f ff 	mov  -1, %g2                                   
{                                                                     
  rtems_bdbuf_buffer *stack [RTEMS_BDBUF_AVL_MAX_HEIGHT];             
  rtems_bdbuf_buffer **prev = stack;                                  
  rtems_bdbuf_buffer *cur = bdbuf_cache.tree;                         
                                                                      
  *prev = NULL;                                                       
4000eda0:	c0 27 bf 80 	clr  [ %fp + -128 ]                            
                                                                      
static void                                                           
rtems_bdbuf_read_ahead_reset (rtems_disk_device *dd)                  
{                                                                     
  rtems_bdbuf_read_ahead_cancel (dd);                                 
  dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;          
4000eda4:	c4 26 20 6c 	st  %g2, [ %i0 + 0x6c ]                        
  rtems_bdbuf_buffer **prev = stack;                                  
  rtems_bdbuf_buffer *cur = bdbuf_cache.tree;                         
                                                                      
  *prev = NULL;                                                       
                                                                      
  while (cur != NULL)                                                 
4000eda8:	80 a7 60 00 	cmp  %i5, 0                                    
4000edac:	02 80 00 2e 	be  4000ee64 <rtems_bdbuf_purge_dev+0x110>     
4000edb0:	b8 07 bf 80 	add  %fp, -128, %i4                            
  {                                                                   
    if (cur->dd == dd)                                                
    {                                                                 
      switch (cur->state)                                             
4000edb4:	33 10 00 31 	sethi  %hi(0x4000c400), %i1                    
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000edb8:	a2 10 20 06 	mov  6, %l1                                    
                                                                      
  while (cur != NULL)                                                 
  {                                                                   
    if (cur->dd == dd)                                                
    {                                                                 
      switch (cur->state)                                             
4000edbc:	b2 16 63 5c 	or  %i1, 0x35c, %i1                            
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000edc0:	a4 10 20 0a 	mov  0xa, %l2                                  
        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);           
4000edc4:	10 80 00 09 	b  4000ede8 <rtems_bdbuf_purge_dev+0x94>       
4000edc8:	a0 00 60 6c 	add  %g1, 0x6c, %l0                            
        default:                                                      
          rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_STATE_11);             
      }                                                               
    }                                                                 
                                                                      
    if (cur->avl.left != NULL)                                        
4000edcc:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
4000edd0:	80 a0 60 00 	cmp  %g1, 0                                    
4000edd4:	22 80 00 0f 	be,a   4000ee10 <rtems_bdbuf_purge_dev+0xbc>   
4000edd8:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
    }                                                                 
    else if (cur->avl.right != NULL)                                  
    {                                                                 
      /* Right */                                                     
      ++prev;                                                         
      *prev = cur;                                                    
4000eddc:	fa 27 20 04 	st  %i5, [ %i4 + 4 ]                           
4000ede0:	ba 10 00 01 	mov  %g1, %i5                                  
      cur = cur->avl.left;                                            
    }                                                                 
    else if (cur->avl.right != NULL)                                  
    {                                                                 
      /* Right */                                                     
      ++prev;                                                         
4000ede4:	b8 07 20 04 	add  %i4, 4, %i4                               
                                                                      
  *prev = NULL;                                                       
                                                                      
  while (cur != NULL)                                                 
  {                                                                   
    if (cur->dd == dd)                                                
4000ede8:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
4000edec:	80 a6 00 01 	cmp  %i0, %g1                                  
4000edf0:	32 bf ff f8 	bne,a   4000edd0 <rtems_bdbuf_purge_dev+0x7c>  
4000edf4:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
    {                                                                 
      switch (cur->state)                                             
4000edf8:	c2 07 60 20 	ld  [ %i5 + 0x20 ], %g1                        
4000edfc:	80 a0 60 0a 	cmp  %g1, 0xa                                  
4000ee00:	28 80 00 34 	bleu,a   4000eed0 <rtems_bdbuf_purge_dev+0x17c><== ALWAYS TAKEN
4000ee04:	83 28 60 02 	sll  %g1, 2, %g1                               
        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_bdbuf_fatal (RTEMS_BDBUF_FATAL_STATE_11);             
4000ee08:	7f ff f6 c1 	call  4000c90c <rtems_bdbuf_fatal>             <== NOT EXECUTED
4000ee0c:	90 10 20 17 	mov  0x17, %o0                                 <== NOT EXECUTED
      /* Left */                                                      
      ++prev;                                                         
      *prev = cur;                                                    
      cur = cur->avl.left;                                            
    }                                                                 
    else if (cur->avl.right != NULL)                                  
4000ee10:	80 a0 60 00 	cmp  %g1, 0                                    
4000ee14:	32 bf ff f3 	bne,a   4000ede0 <rtems_bdbuf_purge_dev+0x8c>  
4000ee18:	fa 27 20 04 	st  %i5, [ %i4 + 4 ]                           
      *prev = cur;                                                    
      cur = cur->avl.right;                                           
    }                                                                 
    else                                                              
    {                                                                 
      while (*prev != NULL                                            
4000ee1c:	c2 07 00 00 	ld  [ %i4 ], %g1                               
4000ee20:	80 a0 60 00 	cmp  %g1, 0                                    
4000ee24:	32 80 00 06 	bne,a   4000ee3c <rtems_bdbuf_purge_dev+0xe8>  
4000ee28:	c4 00 60 0c 	ld  [ %g1 + 0xc ], %g2                         
4000ee2c:	10 80 00 0f 	b  4000ee68 <rtems_bdbuf_purge_dev+0x114>      
4000ee30:	d0 07 bf 74 	ld  [ %fp + -140 ], %o0                        
4000ee34:	82 10 00 02 	mov  %g2, %g1                                  
             && (cur == (*prev)->avl.right || (*prev)->avl.right == NULL))
4000ee38:	c4 00 60 0c 	ld  [ %g1 + 0xc ], %g2                         
4000ee3c:	80 a0 80 1d 	cmp  %g2, %i5                                  
4000ee40:	02 80 00 04 	be  4000ee50 <rtems_bdbuf_purge_dev+0xfc>      
4000ee44:	80 a0 a0 00 	cmp  %g2, 0                                    
4000ee48:	32 bf ff e8 	bne,a   4000ede8 <rtems_bdbuf_purge_dev+0x94>  
4000ee4c:	ba 10 00 02 	mov  %g2, %i5                                  
      {                                                               
        /* Up */                                                      
        cur = *prev;                                                  
        --prev;                                                       
4000ee50:	b8 07 3f fc 	add  %i4, -4, %i4                              
      *prev = cur;                                                    
      cur = cur->avl.right;                                           
    }                                                                 
    else                                                              
    {                                                                 
      while (*prev != NULL                                            
4000ee54:	c4 07 00 00 	ld  [ %i4 ], %g2                               
4000ee58:	80 a0 a0 00 	cmp  %g2, 0                                    
4000ee5c:	12 bf ff f6 	bne  4000ee34 <rtems_bdbuf_purge_dev+0xe0>     
4000ee60:	ba 10 00 01 	mov  %g1, %i5                                  
4000ee64:	d0 07 bf 74 	ld  [ %fp + -140 ], %o0                        
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_purge_list (rtems_chain_control *purge_list)              
{                                                                     
  bool wake_buffer_waiters = false;                                   
4000ee68:	86 10 20 00 	clr  %g3                                       
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000ee6c:	ba 10 20 01 	mov  1, %i5                                    
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(              
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  if ( !_Chain_Is_empty(the_chain))                                   
4000ee70:	80 a2 00 1b 	cmp  %o0, %i3                                  
4000ee74:	02 80 00 0f 	be  4000eeb0 <rtems_bdbuf_purge_dev+0x15c>     
4000ee78:	80 88 e0 ff 	btst  0xff, %g3                                
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *old_first = head->next;                                 
  Chain_Node *new_first = old_first->next;                            
4000ee7c:	c2 02 00 00 	ld  [ %o0 ], %g1                               
                                                                      
  while ((node = rtems_chain_get_unprotected (purge_list)) != NULL)   
  {                                                                   
    rtems_bdbuf_buffer *bd = (rtems_bdbuf_buffer *) node;             
                                                                      
    if (bd->waiters == 0)                                             
4000ee80:	c4 02 20 24 	ld  [ %o0 + 0x24 ], %g2                        
                                                                      
  head->next = new_first;                                             
4000ee84:	c2 27 bf 74 	st  %g1, [ %fp + -140 ]                        
4000ee88:	80 a0 a0 00 	cmp  %g2, 0                                    
4000ee8c:	12 80 00 28 	bne  4000ef2c <rtems_bdbuf_purge_dev+0x1d8>    
4000ee90:	f4 20 60 04 	st  %i2, [ %g1 + 4 ]                           
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000ee94:	7f ff f8 ca 	call  4000d1bc <rtems_bdbuf_discard_buffer.part.4>
4000ee98:	fa 22 20 20 	st  %i5, [ %o0 + 0x20 ]                        
4000ee9c:	d0 07 bf 74 	ld  [ %fp + -140 ], %o0                        
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(              
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  if ( !_Chain_Is_empty(the_chain))                                   
4000eea0:	80 a2 00 1b 	cmp  %o0, %i3                                  
4000eea4:	12 bf ff f6 	bne  4000ee7c <rtems_bdbuf_purge_dev+0x128>    
4000eea8:	86 10 20 01 	mov  1, %g3                                    
      wake_buffer_waiters = true;                                     
                                                                      
    rtems_bdbuf_discard_buffer (bd);                                  
  }                                                                   
                                                                      
  if (wake_buffer_waiters)                                            
4000eeac:	80 88 e0 ff 	btst  0xff, %g3                                
4000eeb0:	02 80 00 04 	be  4000eec0 <rtems_bdbuf_purge_dev+0x16c>     
4000eeb4:	11 10 00 6b 	sethi  %hi(0x4001ac00), %o0                    
    rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);                   
4000eeb8:	7f ff f7 5e 	call  4000cc30 <rtems_bdbuf_wake>              
4000eebc:	90 12 23 a8 	or  %o0, 0x3a8, %o0	! 4001afa8 <bdbuf_cache+0x74>
  rtems_chain_initialize_empty (&purge_list);                         
  rtems_bdbuf_lock_cache ();                                          
  rtems_bdbuf_read_ahead_reset (dd);                                  
  rtems_bdbuf_gather_for_purge (&purge_list, dd);                     
  rtems_bdbuf_purge_list (&purge_list);                               
  rtems_bdbuf_unlock_cache ();                                        
4000eec0:	7f ff f6 bb 	call  4000c9ac <rtems_bdbuf_unlock_cache>      
4000eec4:	01 00 00 00 	nop                                            
4000eec8:	81 c7 e0 08 	ret                                            
4000eecc:	81 e8 00 00 	restore                                        
                                                                      
  while (cur != NULL)                                                 
  {                                                                   
    if (cur->dd == dd)                                                
    {                                                                 
      switch (cur->state)                                             
4000eed0:	c4 06 40 01 	ld  [ %i1 + %g1 ], %g2                         
4000eed4:	81 c0 80 00 	jmp  %g2                                       
4000eed8:	01 00 00 00 	nop                                            
        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);           
4000eedc:	7f ff f7 55 	call  4000cc30 <rtems_bdbuf_wake>              
4000eee0:	90 10 00 10 	mov  %l0, %o0                                  
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)                    
{                                                                     
  --bd->group->users;                                                 
4000eee4:	c4 07 60 28 	ld  [ %i5 + 0x28 ], %g2                        
4000eee8:	c2 00 a0 0c 	ld  [ %g2 + 0xc ], %g1                         
4000eeec:	82 00 7f ff 	add  %g1, -1, %g1                              
4000eef0:	c2 20 a0 0c 	st  %g1, [ %g2 + 0xc ]                         
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
4000eef4:	c4 07 60 04 	ld  [ %i5 + 4 ], %g2                           
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
4000eef8:	c6 07 40 00 	ld  [ %i5 ], %g3                               
  previous       = the_node->previous;                                
  next->previous = previous;                                          
4000eefc:	c4 20 e0 04 	st  %g2, [ %g3 + 4 ]                           
  previous->next = next;                                              
4000ef00:	c6 20 80 00 	st  %g3, [ %g2 ]                               
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
4000ef04:	c4 07 bf 7c 	ld  [ %fp + -132 ], %g2                        
                                                                      
  the_node->next = tail;                                              
4000ef08:	f6 27 40 00 	st  %i3, [ %i5 ]                               
  tail->previous = the_node;                                          
4000ef0c:	fa 27 bf 7c 	st  %i5, [ %fp + -132 ]                        
  old_last->next = the_node;                                          
4000ef10:	fa 20 80 00 	st  %i5, [ %g2 ]                               
  the_node->previous = old_last;                                      
4000ef14:	10 bf ff ae 	b  4000edcc <rtems_bdbuf_purge_dev+0x78>       
4000ef18:	c4 27 60 04 	st  %g2, [ %i5 + 4 ]                           
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000ef1c:	10 bf ff ac 	b  4000edcc <rtems_bdbuf_purge_dev+0x78>       
4000ef20:	e2 27 60 20 	st  %l1, [ %i5 + 0x20 ]                        
4000ef24:	10 bf ff aa 	b  4000edcc <rtems_bdbuf_purge_dev+0x78>       
4000ef28:	e4 27 60 20 	st  %l2, [ %i5 + 0x20 ]                        
4000ef2c:	fa 22 20 20 	st  %i5, [ %o0 + 0x20 ]                        
4000ef30:	10 bf ff d0 	b  4000ee70 <rtems_bdbuf_purge_dev+0x11c>      
4000ef34:	90 10 00 01 	mov  %g1, %o0                                  
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(                   
  const Chain_Node *node                                              
)                                                                     
{                                                                     
  return (node->next == NULL) && (node->previous == NULL);            
4000ef38:	80 a0 a0 00 	cmp  %g2, 0                                    
4000ef3c:	32 bf ff 92 	bne,a   4000ed84 <rtems_bdbuf_purge_dev+0x30>  <== NEVER TAKEN
4000ef40:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           <== NOT EXECUTED
rtems_bdbuf_gather_for_purge (rtems_chain_control *purge_list,        
                              const rtems_disk_device *dd)            
{                                                                     
  rtems_bdbuf_buffer *stack [RTEMS_BDBUF_AVL_MAX_HEIGHT];             
  rtems_bdbuf_buffer **prev = stack;                                  
  rtems_bdbuf_buffer *cur = bdbuf_cache.tree;                         
4000ef44:	10 bf ff 94 	b  4000ed94 <rtems_bdbuf_purge_dev+0x40>       
4000ef48:	03 10 00 6b 	sethi  %hi(0x4001ac00), %g1                    
                                                                      

4000e83c <rtems_bdbuf_read>: rtems_status_code rtems_bdbuf_read (rtems_disk_device *dd, rtems_blkdev_bnum block, rtems_bdbuf_buffer **bd_ptr) {
4000e83c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code     sc = RTEMS_SUCCESSFUL;                        
  rtems_bdbuf_buffer   *bd = NULL;                                    
  rtems_blkdev_bnum     media_block;                                  
                                                                      
  rtems_bdbuf_lock_cache ();                                          
4000e840:	7f ff f8 45 	call  4000c954 <rtems_bdbuf_lock_cache>        
4000e844:	ba 10 00 18 	mov  %i0, %i5                                  
                             rtems_blkdev_bnum        block,          
                             rtems_blkdev_bnum       *media_block_ptr)
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  if (block < dd->block_count)                                        
4000e848:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
rtems_bdbuf_read (rtems_disk_device   *dd,                            
                  rtems_blkdev_bnum    block,                         
                  rtems_bdbuf_buffer **bd_ptr)                        
{                                                                     
  rtems_status_code     sc = RTEMS_SUCCESSFUL;                        
  rtems_bdbuf_buffer   *bd = NULL;                                    
4000e84c:	b8 10 20 00 	clr  %i4                                       
                             rtems_blkdev_bnum        block,          
                             rtems_blkdev_bnum       *media_block_ptr)
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  if (block < dd->block_count)                                        
4000e850:	80 a6 40 01 	cmp  %i1, %g1                                  
4000e854:	0a 80 00 07 	bcs  4000e870 <rtems_bdbuf_read+0x34>          <== ALWAYS TAKEN
4000e858:	b0 10 20 04 	mov  4, %i0                                    
    }                                                                 
                                                                      
    rtems_bdbuf_check_read_ahead_trigger (dd, block);                 
  }                                                                   
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
4000e85c:	7f ff f8 54 	call  4000c9ac <rtems_bdbuf_unlock_cache>      
4000e860:	01 00 00 00 	nop                                            
                                                                      
  *bd_ptr = bd;                                                       
4000e864:	f8 26 80 00 	st  %i4, [ %i2 ]                               
4000e868:	81 c7 e0 08 	ret                                            
4000e86c:	81 e8 00 00 	restore                                        
}                                                                     
                                                                      
static rtems_blkdev_bnum                                              
rtems_bdbuf_media_block (const rtems_disk_device *dd, rtems_blkdev_bnum block)
{                                                                     
  if (dd->block_to_media_block_shift >= 0)                            
4000e870:	d2 07 60 30 	ld  [ %i5 + 0x30 ], %o1                        
4000e874:	80 a2 60 00 	cmp  %o1, 0                                    
4000e878:	26 80 00 60 	bl,a   4000e9f8 <rtems_bdbuf_read+0x1bc>       <== NEVER TAKEN
4000e87c:	d6 07 60 24 	ld  [ %i5 + 0x24 ], %o3                        <== NOT EXECUTED
    return block << dd->block_to_media_block_shift;                   
4000e880:	93 2e 40 09 	sll  %i1, %o1, %o1                             
    /*                                                                
     * Compute the media block number. Drivers work with media block number not
     * the block number a BD may have as this depends on the block size set by
     * the user.                                                      
     */                                                               
    *media_block_ptr = rtems_bdbuf_media_block (dd, block) + dd->start;
4000e884:	c2 07 60 18 	ld  [ %i5 + 0x18 ], %g1                        
  {                                                                   
    if (rtems_bdbuf_tracer)                                           
      printf ("bdbuf:read: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n", 
              media_block + dd->start, block, (unsigned) dd->dev);    
                                                                      
    bd = rtems_bdbuf_get_buffer_for_access (dd, media_block);         
4000e888:	90 10 00 1d 	mov  %i5, %o0                                  
4000e88c:	7f ff fb 9e 	call  4000d704 <rtems_bdbuf_get_buffer_for_access>
4000e890:	92 02 40 01 	add  %o1, %g1, %o1                             
4000e894:	b8 10 00 08 	mov  %o0, %i4                                  
    switch (bd->state)                                                
4000e898:	d0 02 20 20 	ld  [ %o0 + 0x20 ], %o0                        
4000e89c:	80 a2 20 02 	cmp  %o0, 2                                    
4000e8a0:	02 80 00 4f 	be  4000e9dc <rtems_bdbuf_read+0x1a0>          
4000e8a4:	80 a2 20 07 	cmp  %o0, 7                                    
4000e8a8:	02 80 00 06 	be  4000e8c0 <rtems_bdbuf_read+0x84>           
4000e8ac:	80 a2 20 01 	cmp  %o0, 1                                    
4000e8b0:	22 80 00 28 	be,a   4000e950 <rtems_bdbuf_read+0x114>       <== ALWAYS TAKEN
4000e8b4:	c4 07 60 48 	ld  [ %i5 + 0x48 ], %g2                        
        {                                                             
          bd = NULL;                                                  
        }                                                             
        break;                                                        
      default:                                                        
        rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_4);
4000e8b8:	7f ff f8 2d 	call  4000c96c <rtems_bdbuf_fatal_with_state>  <== NOT EXECUTED
4000e8bc:	92 10 20 10 	mov  0x10, %o1                                 <== NOT EXECUTED
      case RTEMS_BDBUF_STATE_CACHED:                                  
        ++dd->stats.read_hits;                                        
        rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_CACHED);  
        break;                                                        
      case RTEMS_BDBUF_STATE_MODIFIED:                                
        ++dd->stats.read_hits;                                        
4000e8c0:	c2 07 60 44 	ld  [ %i5 + 0x44 ], %g1                        
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000e8c4:	b0 10 20 00 	clr  %i0                                       
      case RTEMS_BDBUF_STATE_CACHED:                                  
        ++dd->stats.read_hits;                                        
        rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_CACHED);  
        break;                                                        
      case RTEMS_BDBUF_STATE_MODIFIED:                                
        ++dd->stats.read_hits;                                        
4000e8c8:	82 00 60 01 	inc  %g1                                       
4000e8cc:	c2 27 60 44 	st  %g1, [ %i5 + 0x44 ]                        
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000e8d0:	82 10 20 04 	mov  4, %g1                                    
4000e8d4:	c2 27 20 20 	st  %g1, [ %i4 + 0x20 ]                        
                                                                      
static void                                                           
rtems_bdbuf_check_read_ahead_trigger (rtems_disk_device *dd,          
                                      rtems_blkdev_bnum  block)       
{                                                                     
  if (bdbuf_cache.read_ahead_task != 0                                
4000e8d8:	37 10 00 6b 	sethi  %hi(0x4001ac00), %i3                    
4000e8dc:	b6 16 e3 34 	or  %i3, 0x334, %i3	! 4001af34 <bdbuf_cache>   
4000e8e0:	d0 06 e0 84 	ld  [ %i3 + 0x84 ], %o0                        
4000e8e4:	80 a2 20 00 	cmp  %o0, 0                                    
4000e8e8:	02 bf ff dd 	be  4000e85c <rtems_bdbuf_read+0x20>           
4000e8ec:	01 00 00 00 	nop                                            
      && dd->read_ahead.trigger == block                              
4000e8f0:	c2 07 60 6c 	ld  [ %i5 + 0x6c ], %g1                        
4000e8f4:	80 a6 40 01 	cmp  %i1, %g1                                  
4000e8f8:	12 bf ff d9 	bne  4000e85c <rtems_bdbuf_read+0x20>          
4000e8fc:	01 00 00 00 	nop                                            
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(                   
  const Chain_Node *node                                              
)                                                                     
{                                                                     
  return (node->next == NULL) && (node->previous == NULL);            
4000e900:	c2 07 60 64 	ld  [ %i5 + 0x64 ], %g1                        
4000e904:	80 a0 60 00 	cmp  %g1, 0                                    
4000e908:	12 bf ff d5 	bne  4000e85c <rtems_bdbuf_read+0x20>          <== NEVER TAKEN
4000e90c:	01 00 00 00 	nop                                            
4000e910:	c2 07 60 68 	ld  [ %i5 + 0x68 ], %g1                        
4000e914:	80 a0 60 00 	cmp  %g1, 0                                    
4000e918:	12 bf ff d1 	bne  4000e85c <rtems_bdbuf_read+0x20>          <== NEVER TAKEN
4000e91c:	01 00 00 00 	nop                                            
      && !rtems_bdbuf_is_read_ahead_active (dd))                      
  {                                                                   
    rtems_status_code sc;                                             
    rtems_chain_control *chain = &bdbuf_cache.read_ahead_chain;       
                                                                      
    if (rtems_chain_is_empty (chain))                                 
4000e920:	c2 06 e0 88 	ld  [ %i3 + 0x88 ], %g1                        
4000e924:	b2 06 e0 8c 	add  %i3, 0x8c, %i1                            
4000e928:	80 a0 40 19 	cmp  %g1, %i1                                  
4000e92c:	02 80 00 41 	be  4000ea30 <rtems_bdbuf_read+0x1f4>          <== ALWAYS TAKEN
4000e930:	01 00 00 00 	nop                                            
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
4000e934:	c2 06 e0 90 	ld  [ %i3 + 0x90 ], %g1                        <== NOT EXECUTED
                             RTEMS_BDBUF_READ_AHEAD_WAKE_UP);         
      if (sc != RTEMS_SUCCESSFUL)                                     
        rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_RA_WAKE_UP);             
    }                                                                 
                                                                      
    rtems_chain_append_unprotected (chain, &dd->read_ahead.node);     
4000e938:	84 07 60 64 	add  %i5, 0x64, %g2                            
                                                                      
  the_node->next = tail;                                              
4000e93c:	f2 27 60 64 	st  %i1, [ %i5 + 0x64 ]                        
  tail->previous = the_node;                                          
4000e940:	c4 26 e0 90 	st  %g2, [ %i3 + 0x90 ]                        
  old_last->next = the_node;                                          
4000e944:	c4 20 40 00 	st  %g2, [ %g1 ]                               
  the_node->previous = old_last;                                      
4000e948:	10 bf ff c5 	b  4000e85c <rtems_bdbuf_read+0x20>            
4000e94c:	c2 27 60 68 	st  %g1, [ %i5 + 0x68 ]                        
                                                                      
static void                                                           
rtems_bdbuf_set_read_ahead_trigger (rtems_disk_device *dd,            
                                    rtems_blkdev_bnum  block)         
{                                                                     
  if (dd->read_ahead.trigger != block)                                
4000e950:	c2 07 60 6c 	ld  [ %i5 + 0x6c ], %g1                        
      case RTEMS_BDBUF_STATE_MODIFIED:                                
        ++dd->stats.read_hits;                                        
        rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_MODIFIED);
        break;                                                        
      case RTEMS_BDBUF_STATE_EMPTY:                                   
        ++dd->stats.read_misses;                                      
4000e954:	84 00 a0 01 	inc  %g2                                       
                                                                      
static void                                                           
rtems_bdbuf_set_read_ahead_trigger (rtems_disk_device *dd,            
                                    rtems_blkdev_bnum  block)         
{                                                                     
  if (dd->read_ahead.trigger != block)                                
4000e958:	80 a6 40 01 	cmp  %i1, %g1                                  
4000e95c:	02 80 00 0e 	be  4000e994 <rtems_bdbuf_read+0x158>          
4000e960:	c4 27 60 48 	st  %g2, [ %i5 + 0x48 ]                        
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(                   
  const Chain_Node *node                                              
)                                                                     
{                                                                     
  return (node->next == NULL) && (node->previous == NULL);            
4000e964:	c2 07 60 64 	ld  [ %i5 + 0x64 ], %g1                        
4000e968:	80 a0 60 00 	cmp  %g1, 0                                    
4000e96c:	02 80 00 2c 	be  4000ea1c <rtems_bdbuf_read+0x1e0>          <== ALWAYS TAKEN
4000e970:	c4 07 60 68 	ld  [ %i5 + 0x68 ], %g2                        
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
  next->previous = previous;                                          
4000e974:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           <== NOT EXECUTED
  previous->next = next;                                              
4000e978:	c2 20 80 00 	st  %g1, [ %g2 ]                               <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(                       
  Chain_Node *node                                                    
)                                                                     
{                                                                     
  node->next = node->previous = NULL;                                 
4000e97c:	c0 27 60 68 	clr  [ %i5 + 0x68 ]                            <== NOT EXECUTED
4000e980:	c0 27 60 64 	clr  [ %i5 + 0x64 ]                            <== NOT EXECUTED
  {                                                                   
    rtems_bdbuf_read_ahead_cancel (dd);                               
    dd->read_ahead.trigger = block + 1;                               
4000e984:	84 06 60 01 	add  %i1, 1, %g2                               <== NOT EXECUTED
    dd->read_ahead.next = block + 2;                                  
4000e988:	82 06 60 02 	add  %i1, 2, %g1                               
                                    rtems_blkdev_bnum  block)         
{                                                                     
  if (dd->read_ahead.trigger != block)                                
  {                                                                   
    rtems_bdbuf_read_ahead_cancel (dd);                               
    dd->read_ahead.trigger = block + 1;                               
4000e98c:	c4 27 60 6c 	st  %g2, [ %i5 + 0x6c ]                        
    dd->read_ahead.next = block + 2;                                  
4000e990:	c2 27 60 70 	st  %g1, [ %i5 + 0x70 ]                        
        rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_MODIFIED);
        break;                                                        
      case RTEMS_BDBUF_STATE_EMPTY:                                   
        ++dd->stats.read_misses;                                      
        rtems_bdbuf_set_read_ahead_trigger (dd, block);               
        sc = rtems_bdbuf_execute_read_request (dd, bd, 1);            
4000e994:	90 10 00 1d 	mov  %i5, %o0                                  
4000e998:	92 10 00 1c 	mov  %i4, %o1                                  
4000e99c:	7f ff fd cc 	call  4000e0cc <rtems_bdbuf_execute_read_request>
4000e9a0:	94 10 20 01 	mov  1, %o2                                    
        if (sc == RTEMS_SUCCESSFUL)                                   
4000e9a4:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4000e9a8:	32 bf ff cc 	bne,a   4000e8d8 <rtems_bdbuf_read+0x9c>       
4000e9ac:	b8 10 20 00 	clr  %i4                                       
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)                     
{                                                                     
  ++bd->group->users;                                                 
4000e9b0:	c2 07 20 28 	ld  [ %i4 + 0x28 ], %g1                        
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
4000e9b4:	c4 07 20 04 	ld  [ %i4 + 4 ], %g2                           
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
4000e9b8:	c6 07 00 00 	ld  [ %i4 ], %g3                               
4000e9bc:	c8 00 60 0c 	ld  [ %g1 + 0xc ], %g4                         
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000e9c0:	b6 10 20 03 	mov  3, %i3                                    
4000e9c4:	f6 27 20 20 	st  %i3, [ %i4 + 0x20 ]                        
  previous       = the_node->previous;                                
  next->previous = previous;                                          
4000e9c8:	c4 20 e0 04 	st  %g2, [ %g3 + 4 ]                           
  previous->next = next;                                              
4000e9cc:	c6 20 80 00 	st  %g3, [ %g2 ]                               
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)                     
{                                                                     
  ++bd->group->users;                                                 
4000e9d0:	84 01 20 01 	add  %g4, 1, %g2                               
4000e9d4:	10 bf ff c1 	b  4000e8d8 <rtems_bdbuf_read+0x9c>            
4000e9d8:	c4 20 60 0c 	st  %g2, [ %g1 + 0xc ]                         
                                                                      
    bd = rtems_bdbuf_get_buffer_for_access (dd, media_block);         
    switch (bd->state)                                                
    {                                                                 
      case RTEMS_BDBUF_STATE_CACHED:                                  
        ++dd->stats.read_hits;                                        
4000e9dc:	c2 07 60 44 	ld  [ %i5 + 0x44 ], %g1                        
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000e9e0:	b0 10 20 00 	clr  %i0                                       
                                                                      
    bd = rtems_bdbuf_get_buffer_for_access (dd, media_block);         
    switch (bd->state)                                                
    {                                                                 
      case RTEMS_BDBUF_STATE_CACHED:                                  
        ++dd->stats.read_hits;                                        
4000e9e4:	82 00 60 01 	inc  %g1                                       
4000e9e8:	c2 27 60 44 	st  %g1, [ %i5 + 0x44 ]                        
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000e9ec:	82 10 20 03 	mov  3, %g1                                    
4000e9f0:	10 bf ff ba 	b  4000e8d8 <rtems_bdbuf_read+0x9c>            
4000e9f4:	c2 27 20 20 	st  %g1, [ %i4 + 0x20 ]                        
    /*                                                                
     * Change the block number for the block size to the block number for the media
     * block size. We have to use 64bit maths. There is no short cut here.
     */                                                               
    return (rtems_blkdev_bnum)                                        
      ((((uint64_t) block) * dd->block_size) / dd->media_block_size); 
4000e9f8:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
4000e9fc:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
4000ea00:	40 00 23 e6 	call  40017998 <__muldi3>                      <== NOT EXECUTED
4000ea04:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4000ea08:	d6 07 60 20 	ld  [ %i5 + 0x20 ], %o3                        <== NOT EXECUTED
4000ea0c:	40 00 25 f4 	call  400181dc <__udivdi3>                     <== NOT EXECUTED
4000ea10:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
    /*                                                                
     * Compute the media block number. Drivers work with media block number not
     * the block number a BD may have as this depends on the block size set by
     * the user.                                                      
     */                                                               
    *media_block_ptr = rtems_bdbuf_media_block (dd, block) + dd->start;
4000ea14:	10 bf ff 9d 	b  4000e888 <rtems_bdbuf_read+0x4c>            <== NOT EXECUTED
4000ea18:	c2 07 60 18 	ld  [ %i5 + 0x18 ], %g1                        <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(                   
  const Chain_Node *node                                              
)                                                                     
{                                                                     
  return (node->next == NULL) && (node->previous == NULL);            
4000ea1c:	80 a0 a0 00 	cmp  %g2, 0                                    
4000ea20:	32 bf ff d5 	bne,a   4000e974 <rtems_bdbuf_read+0x138>      <== NEVER TAKEN
4000ea24:	c4 07 60 68 	ld  [ %i5 + 0x68 ], %g2                        <== NOT EXECUTED
                                    rtems_blkdev_bnum  block)         
{                                                                     
  if (dd->read_ahead.trigger != block)                                
  {                                                                   
    rtems_bdbuf_read_ahead_cancel (dd);                               
    dd->read_ahead.trigger = block + 1;                               
4000ea28:	10 bf ff d8 	b  4000e988 <rtems_bdbuf_read+0x14c>           
4000ea2c:	84 06 60 01 	add  %i1, 1, %g2                               
    rtems_status_code sc;                                             
    rtems_chain_control *chain = &bdbuf_cache.read_ahead_chain;       
                                                                      
    if (rtems_chain_is_empty (chain))                                 
    {                                                                 
      sc = rtems_event_send (bdbuf_cache.read_ahead_task,             
4000ea30:	7f ff e5 cd 	call  40008164 <rtems_event_send>              
4000ea34:	92 10 20 02 	mov  2, %o1                                    
                             RTEMS_BDBUF_READ_AHEAD_WAKE_UP);         
      if (sc != RTEMS_SUCCESSFUL)                                     
4000ea38:	80 a2 20 00 	cmp  %o0, 0                                    
4000ea3c:	22 bf ff bf 	be,a   4000e938 <rtems_bdbuf_read+0xfc>        <== ALWAYS TAKEN
4000ea40:	c2 06 e0 90 	ld  [ %i3 + 0x90 ], %g1                        
        rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_RA_WAKE_UP);             
4000ea44:	7f ff f7 b2 	call  4000c90c <rtems_bdbuf_fatal>             <== NOT EXECUTED
4000ea48:	90 10 20 07 	mov  7, %o0                                    <== NOT EXECUTED
                                                                      

4000e1bc <rtems_bdbuf_read_ahead_task>: return sc; } static rtems_task rtems_bdbuf_read_ahead_task (rtems_task_argument arg) {
4000e1bc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_chain_control *chain = &bdbuf_cache.read_ahead_chain;         
                                                                      
  while (bdbuf_cache.read_ahead_enabled)                              
4000e1c0:	37 10 00 6b 	sethi  %hi(0x4001ac00), %i3                    
4000e1c4:	b6 16 e3 34 	or  %i3, 0x334, %i3	! 4001af34 <bdbuf_cache>   
4000e1c8:	c2 0e e0 94 	ldub  [ %i3 + 0x94 ], %g1                      
4000e1cc:	80 a0 60 00 	cmp  %g1, 0                                    
4000e1d0:	02 80 00 22 	be  4000e258 <rtems_bdbuf_read_ahead_task+0x9c><== NEVER TAKEN
4000e1d4:	b0 06 e0 88 	add  %i3, 0x88, %i0                            
4000e1d8:	b2 06 e0 8c 	add  %i3, 0x8c, %i1                            
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(        
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_head( the_chain )->next;                    
4000e1dc:	b4 10 00 1b 	mov  %i3, %i2                                  
          rtems_bdbuf_get_buffer_for_read_ahead (dd, media_block);    
                                                                      
        if (bd != NULL)                                               
        {                                                             
          uint32_t transfer_count = dd->block_count - block;          
          uint32_t max_transfer_count = bdbuf_config.max_read_ahead_blocks;
4000e1e0:	23 10 00 65 	sethi  %hi(0x40019400), %l1                    
                                                                      
  while (bdbuf_cache.read_ahead_enabled)                              
  {                                                                   
    rtems_chain_node *node;                                           
                                                                      
    rtems_bdbuf_wait_for_event (RTEMS_BDBUF_READ_AHEAD_WAKE_UP);      
4000e1e4:	7f ff fa 53 	call  4000cb30 <rtems_bdbuf_wait_for_event>    
4000e1e8:	90 10 20 02 	mov  2, %o0                                    
    rtems_bdbuf_lock_cache ();                                        
4000e1ec:	7f ff f9 da 	call  4000c954 <rtems_bdbuf_lock_cache>        
4000e1f0:	01 00 00 00 	nop                                            
4000e1f4:	fa 06 e0 88 	ld  [ %i3 + 0x88 ], %i5                        
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(              
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  if ( !_Chain_Is_empty(the_chain))                                   
4000e1f8:	80 a7 40 19 	cmp  %i5, %i1                                  
4000e1fc:	02 80 00 11 	be  4000e240 <rtems_bdbuf_read_ahead_task+0x84>
4000e200:	01 00 00 00 	nop                                            
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *old_first = head->next;                                 
  Chain_Node *new_first = old_first->next;                            
4000e204:	c2 07 40 00 	ld  [ %i5 ], %g1                               
                                                                      
    while ((node = rtems_chain_get_unprotected (chain)) != NULL)      
    {                                                                 
      rtems_disk_device *dd = (rtems_disk_device *)                   
        ((char *) node - offsetof (rtems_disk_device, read_ahead.node));
      rtems_blkdev_bnum block = dd->read_ahead.next;                  
4000e208:	f8 07 60 0c 	ld  [ %i5 + 0xc ], %i4                         
                             rtems_blkdev_bnum        block,          
                             rtems_blkdev_bnum       *media_block_ptr)
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  if (block < dd->block_count)                                        
4000e20c:	c4 07 7f c4 	ld  [ %i5 + -60 ], %g2                         
                                                                      
  head->next = new_first;                                             
4000e210:	c2 26 a0 88 	st  %g1, [ %i2 + 0x88 ]                        
4000e214:	80 a7 00 02 	cmp  %i4, %g2                                  
4000e218:	0a 80 00 12 	bcs  4000e260 <rtems_bdbuf_read_ahead_task+0xa4>
4000e21c:	f0 20 60 04 	st  %i0, [ %g1 + 4 ]                           
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(                       
  Chain_Node *node                                                    
)                                                                     
{                                                                     
  node->next = node->previous = NULL;                                 
4000e220:	c0 27 60 04 	clr  [ %i5 + 4 ]                               
4000e224:	c0 27 40 00 	clr  [ %i5 ]                                   
          rtems_bdbuf_execute_read_request (dd, bd, transfer_count);  
        }                                                             
      }                                                               
      else                                                            
      {                                                               
        dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;    
4000e228:	82 10 3f ff 	mov  -1, %g1                                   
4000e22c:	c2 27 60 08 	st  %g1, [ %i5 + 8 ]                           
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(        
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_head( the_chain )->next;                    
4000e230:	fa 06 e0 88 	ld  [ %i3 + 0x88 ], %i5                        
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(              
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  if ( !_Chain_Is_empty(the_chain))                                   
4000e234:	80 a7 40 19 	cmp  %i5, %i1                                  
4000e238:	32 bf ff f4 	bne,a   4000e208 <rtems_bdbuf_read_ahead_task+0x4c><== NEVER TAKEN
4000e23c:	c2 07 40 00 	ld  [ %i5 ], %g1                               <== NOT EXECUTED
      }                                                               
    }                                                                 
                                                                      
    rtems_bdbuf_unlock_cache ();                                      
4000e240:	7f ff f9 db 	call  4000c9ac <rtems_bdbuf_unlock_cache>      
4000e244:	01 00 00 00 	nop                                            
static rtems_task                                                     
rtems_bdbuf_read_ahead_task (rtems_task_argument arg)                 
{                                                                     
  rtems_chain_control *chain = &bdbuf_cache.read_ahead_chain;         
                                                                      
  while (bdbuf_cache.read_ahead_enabled)                              
4000e248:	c2 0e a0 94 	ldub  [ %i2 + 0x94 ], %g1                      
4000e24c:	80 a0 60 00 	cmp  %g1, 0                                    
4000e250:	12 bf ff e5 	bne  4000e1e4 <rtems_bdbuf_read_ahead_task+0x28><== ALWAYS TAKEN
4000e254:	01 00 00 00 	nop                                            
    }                                                                 
                                                                      
    rtems_bdbuf_unlock_cache ();                                      
  }                                                                   
                                                                      
  rtems_task_delete (RTEMS_SELF);                                     
4000e258:	7f ff e9 d4 	call  400089a8 <rtems_task_delete>             <== NOT EXECUTED
4000e25c:	91 e8 20 00 	restore  %g0, 0, %o0                           <== NOT EXECUTED
}                                                                     
                                                                      
static rtems_blkdev_bnum                                              
rtems_bdbuf_media_block (const rtems_disk_device *dd, rtems_blkdev_bnum block)
{                                                                     
  if (dd->block_to_media_block_shift >= 0)                            
4000e260:	d2 07 7f cc 	ld  [ %i5 + -52 ], %o1                         
4000e264:	80 a2 60 00 	cmp  %o1, 0                                    
4000e268:	26 80 00 21 	bl,a   4000e2ec <rtems_bdbuf_read_ahead_task+0x130><== NEVER TAKEN
4000e26c:	d2 07 7f c0 	ld  [ %i5 + -64 ], %o1                         <== NOT EXECUTED
    return block << dd->block_to_media_block_shift;                   
4000e270:	93 2f 00 09 	sll  %i4, %o1, %o1                             
    /*                                                                
     * Compute the media block number. Drivers work with media block number not
     * the block number a BD may have as this depends on the block size set by
     * the user.                                                      
     */                                                               
    *media_block_ptr = rtems_bdbuf_media_block (dd, block) + dd->start;
4000e274:	c2 07 7f b4 	ld  [ %i5 + -76 ], %g1                         
    rtems_bdbuf_wait_for_event (RTEMS_BDBUF_READ_AHEAD_WAKE_UP);      
    rtems_bdbuf_lock_cache ();                                        
                                                                      
    while ((node = rtems_chain_get_unprotected (chain)) != NULL)      
    {                                                                 
      rtems_disk_device *dd = (rtems_disk_device *)                   
4000e278:	a0 07 7f 9c 	add  %i5, -100, %l0                            
                                                                      
      rtems_chain_set_off_chain (&dd->read_ahead.node);               
                                                                      
      if (sc == RTEMS_SUCCESSFUL)                                     
      {                                                               
        rtems_bdbuf_buffer *bd =                                      
4000e27c:	92 02 40 01 	add  %o1, %g1, %o1                             
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(                       
  Chain_Node *node                                                    
)                                                                     
{                                                                     
  node->next = node->previous = NULL;                                 
4000e280:	c0 27 60 04 	clr  [ %i5 + 4 ]                               
4000e284:	c0 27 40 00 	clr  [ %i5 ]                                   
4000e288:	7f ff fd 08 	call  4000d6a8 <rtems_bdbuf_get_buffer_for_read_ahead>
4000e28c:	90 10 00 10 	mov  %l0, %o0                                  
          rtems_bdbuf_get_buffer_for_read_ahead (dd, media_block);    
                                                                      
        if (bd != NULL)                                               
4000e290:	92 92 20 00 	orcc  %o0, 0, %o1                              
4000e294:	02 bf ff d8 	be  4000e1f4 <rtems_bdbuf_read_ahead_task+0x38><== NEVER TAKEN
4000e298:	c2 04 62 08 	ld  [ %l1 + 0x208 ], %g1                       
        {                                                             
          uint32_t transfer_count = dd->block_count - block;          
4000e29c:	d4 07 7f c4 	ld  [ %i5 + -60 ], %o2                         
4000e2a0:	94 22 80 1c 	sub  %o2, %i4, %o2                             
          uint32_t max_transfer_count = bdbuf_config.max_read_ahead_blocks;
                                                                      
          if (transfer_count >= max_transfer_count)                   
4000e2a4:	80 a2 80 01 	cmp  %o2, %g1                                  
4000e2a8:	2a 80 00 0f 	bcs,a   4000e2e4 <rtems_bdbuf_read_ahead_task+0x128>
4000e2ac:	82 10 3f ff 	mov  -1, %g1                                   
          {                                                           
            transfer_count = max_transfer_count;                      
            dd->read_ahead.trigger = block + transfer_count / 2;      
            dd->read_ahead.next = block + transfer_count;             
4000e2b0:	84 00 40 1c 	add  %g1, %i4, %g2                             
          uint32_t max_transfer_count = bdbuf_config.max_read_ahead_blocks;
                                                                      
          if (transfer_count >= max_transfer_count)                   
          {                                                           
            transfer_count = max_transfer_count;                      
            dd->read_ahead.trigger = block + transfer_count / 2;      
4000e2b4:	87 30 60 01 	srl  %g1, 1, %g3                               
            dd->read_ahead.next = block + transfer_count;             
4000e2b8:	c4 27 60 0c 	st  %g2, [ %i5 + 0xc ]                         
          uint32_t max_transfer_count = bdbuf_config.max_read_ahead_blocks;
                                                                      
          if (transfer_count >= max_transfer_count)                   
          {                                                           
            transfer_count = max_transfer_count;                      
            dd->read_ahead.trigger = block + transfer_count / 2;      
4000e2bc:	b8 00 c0 1c 	add  %g3, %i4, %i4                             
            dd->read_ahead.next = block + transfer_count;             
4000e2c0:	94 10 00 01 	mov  %g1, %o2                                  
          uint32_t max_transfer_count = bdbuf_config.max_read_ahead_blocks;
                                                                      
          if (transfer_count >= max_transfer_count)                   
          {                                                           
            transfer_count = max_transfer_count;                      
            dd->read_ahead.trigger = block + transfer_count / 2;      
4000e2c4:	f8 27 60 08 	st  %i4, [ %i5 + 8 ]                           
          else                                                        
          {                                                           
            dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
          }                                                           
                                                                      
          ++dd->stats.read_ahead_transfers;                           
4000e2c8:	c2 07 7f e8 	ld  [ %i5 + -24 ], %g1                         
          rtems_bdbuf_execute_read_request (dd, bd, transfer_count);  
4000e2cc:	90 10 00 10 	mov  %l0, %o0                                  
          else                                                        
          {                                                           
            dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
          }                                                           
                                                                      
          ++dd->stats.read_ahead_transfers;                           
4000e2d0:	82 00 60 01 	inc  %g1                                       
          rtems_bdbuf_execute_read_request (dd, bd, transfer_count);  
4000e2d4:	7f ff ff 7e 	call  4000e0cc <rtems_bdbuf_execute_read_request>
4000e2d8:	c2 27 7f e8 	st  %g1, [ %i5 + -24 ]                         
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(        
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_head( the_chain )->next;                    
4000e2dc:	10 bf ff c7 	b  4000e1f8 <rtems_bdbuf_read_ahead_task+0x3c> 
4000e2e0:	fa 06 e0 88 	ld  [ %i3 + 0x88 ], %i5                        
            dd->read_ahead.trigger = block + transfer_count / 2;      
            dd->read_ahead.next = block + transfer_count;             
          }                                                           
          else                                                        
          {                                                           
            dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
4000e2e4:	10 bf ff f9 	b  4000e2c8 <rtems_bdbuf_read_ahead_task+0x10c>
4000e2e8:	c2 27 60 08 	st  %g1, [ %i5 + 8 ]                           
    /*                                                                
     * Change the block number for the block size to the block number for the media
     * block size. We have to use 64bit maths. There is no short cut here.
     */                                                               
    return (rtems_blkdev_bnum)                                        
      ((((uint64_t) block) * dd->block_size) / dd->media_block_size); 
4000e2ec:	96 10 00 1c 	mov  %i4, %o3                                  <== NOT EXECUTED
4000e2f0:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
4000e2f4:	40 00 25 a9 	call  40017998 <__muldi3>                      <== NOT EXECUTED
4000e2f8:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4000e2fc:	d6 07 7f bc 	ld  [ %i5 + -68 ], %o3                         <== NOT EXECUTED
4000e300:	40 00 27 b7 	call  400181dc <__udivdi3>                     <== NOT EXECUTED
4000e304:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
    /*                                                                
     * Compute the media block number. Drivers work with media block number not
     * the block number a BD may have as this depends on the block size set by
     * the user.                                                      
     */                                                               
    *media_block_ptr = rtems_bdbuf_media_block (dd, block) + dd->start;
4000e308:	10 bf ff dc 	b  4000e278 <rtems_bdbuf_read_ahead_task+0xbc> <== NOT EXECUTED
4000e30c:	c2 07 7f b4 	ld  [ %i5 + -76 ], %g1                         <== NOT EXECUTED
                                                                      

4000ea50 <rtems_bdbuf_release>: return RTEMS_SUCCESSFUL; } rtems_status_code rtems_bdbuf_release (rtems_bdbuf_buffer *bd) {
4000ea50:	9d e3 bf a0 	save  %sp, -96, %sp                            
}                                                                     
                                                                      
static rtems_status_code                                              
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{                                                                     
  if (bd == NULL)                                                     
4000ea54:	80 a6 20 00 	cmp  %i0, 0                                    
4000ea58:	02 80 00 0f 	be  4000ea94 <rtems_bdbuf_release+0x44>        <== NEVER TAKEN
4000ea5c:	01 00 00 00 	nop                                            
  if (rtems_bdbuf_tracer)                                             
  {                                                                   
    printf ("bdbuf:%s: %" PRIu32 "\n", kind, bd->block);              
    rtems_bdbuf_show_users (kind, bd);                                
  }                                                                   
  rtems_bdbuf_lock_cache();                                           
4000ea60:	7f ff f7 bd 	call  4000c954 <rtems_bdbuf_lock_cache>        
4000ea64:	01 00 00 00 	nop                                            
                                                                      
  sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release");           
  if (sc != RTEMS_SUCCESSFUL)                                         
    return sc;                                                        
                                                                      
  switch (bd->state)                                                  
4000ea68:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        
4000ea6c:	80 a2 20 04 	cmp  %o0, 4                                    
4000ea70:	02 80 00 14 	be  4000eac0 <rtems_bdbuf_release+0x70>        
4000ea74:	01 00 00 00 	nop                                            
4000ea78:	18 80 00 09 	bgu  4000ea9c <rtems_bdbuf_release+0x4c>       
4000ea7c:	80 a2 20 06 	cmp  %o0, 6                                    
4000ea80:	80 a2 20 03 	cmp  %o0, 3                                    
4000ea84:	22 80 00 15 	be,a   4000ead8 <rtems_bdbuf_release+0x88>     <== ALWAYS TAKEN
4000ea88:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
      break;                                                          
    case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:                           
      rtems_bdbuf_add_to_modified_list_after_access (bd);             
      break;                                                          
    default:                                                          
      rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_0);
4000ea8c:	7f ff f7 b8 	call  4000c96c <rtems_bdbuf_fatal_with_state>  <== NOT EXECUTED
4000ea90:	92 10 20 0e 	mov  0xe, %o1                                  <== NOT EXECUTED
    rtems_bdbuf_show_usage ();                                        
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
4000ea94:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000ea98:	91 e8 20 09 	restore  %g0, 9, %o0                           <== NOT EXECUTED
                                                                      
  sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release");           
  if (sc != RTEMS_SUCCESSFUL)                                         
    return sc;                                                        
                                                                      
  switch (bd->state)                                                  
4000ea9c:	18 bf ff fc 	bgu  4000ea8c <rtems_bdbuf_release+0x3c>       <== NEVER TAKEN
4000eaa0:	01 00 00 00 	nop                                            
    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);                   
4000eaa4:	90 10 00 18 	mov  %i0, %o0                                  
4000eaa8:	7f ff f9 d2 	call  4000d1f0 <rtems_bdbuf_discard_buffer_after_access>
4000eaac:	b0 10 20 00 	clr  %i0                                       
  }                                                                   
                                                                      
  if (rtems_bdbuf_tracer)                                             
    rtems_bdbuf_show_usage ();                                        
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
4000eab0:	7f ff f7 bf 	call  4000c9ac <rtems_bdbuf_unlock_cache>      
4000eab4:	01 00 00 00 	nop                                            
                                                                      
  return RTEMS_SUCCESSFUL;                                            
4000eab8:	81 c7 e0 08 	ret                                            
4000eabc:	81 e8 00 00 	restore                                        
    case RTEMS_BDBUF_STATE_ACCESS_EMPTY:                              
    case RTEMS_BDBUF_STATE_ACCESS_PURGED:                             
      rtems_bdbuf_discard_buffer_after_access (bd);                   
      break;                                                          
    case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:                           
      rtems_bdbuf_add_to_modified_list_after_access (bd);             
4000eac0:	7f ff f8 6b 	call  4000cc6c <rtems_bdbuf_add_to_modified_list_after_access>
4000eac4:	90 10 00 18 	mov  %i0, %o0                                  
  }                                                                   
                                                                      
  if (rtems_bdbuf_tracer)                                             
    rtems_bdbuf_show_usage ();                                        
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
4000eac8:	7f ff f7 b9 	call  4000c9ac <rtems_bdbuf_unlock_cache>      
4000eacc:	b0 10 20 00 	clr  %i0                                       
                                                                      
  return RTEMS_SUCCESSFUL;                                            
4000ead0:	81 c7 e0 08 	ret                                            
4000ead4:	81 e8 00 00 	restore                                        
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
4000ead8:	11 10 00 6b 	sethi  %hi(0x4001ac00), %o0                    
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)                    
{                                                                     
  --bd->group->users;                                                 
4000eadc:	c4 00 60 0c 	ld  [ %g1 + 0xc ], %g2                         
4000eae0:	90 12 23 34 	or  %o0, 0x334, %o0                            
4000eae4:	84 00 bf ff 	add  %g2, -1, %g2                              
4000eae8:	c4 20 60 0c 	st  %g2, [ %g1 + 0xc ]                         
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000eaec:	82 10 20 02 	mov  2, %g1                                    
                                                                      
  the_node->next = tail;                                              
4000eaf0:	84 02 20 44 	add  %o0, 0x44, %g2                            
4000eaf4:	c2 26 20 20 	st  %g1, [ %i0 + 0x20 ]                        
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
4000eaf8:	c2 02 20 48 	ld  [ %o0 + 0x48 ], %g1                        
                                                                      
  the_node->next = tail;                                              
4000eafc:	c4 26 00 00 	st  %g2, [ %i0 ]                               
  tail->previous = the_node;                                          
4000eb00:	f0 22 20 48 	st  %i0, [ %o0 + 0x48 ]                        
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)                                                    
4000eb04:	c4 06 20 24 	ld  [ %i0 + 0x24 ], %g2                        
  old_last->next = the_node;                                          
  the_node->previous = old_last;                                      
4000eb08:	c2 26 20 04 	st  %g1, [ %i0 + 4 ]                           
4000eb0c:	80 a0 a0 00 	cmp  %g2, 0                                    
4000eb10:	12 80 00 05 	bne  4000eb24 <rtems_bdbuf_release+0xd4>       
4000eb14:	f0 20 40 00 	st  %i0, [ %g1 ]                               
    rtems_bdbuf_wake (&bdbuf_cache.access_waiters);                   
  else                                                                
    rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);                   
4000eb18:	7f ff f8 46 	call  4000cc30 <rtems_bdbuf_wake>              
4000eb1c:	90 02 20 74 	add  %o0, 0x74, %o0                            
4000eb20:	30 bf ff ea 	b,a   4000eac8 <rtems_bdbuf_release+0x78>      
{                                                                     
  rtems_bdbuf_group_release (bd);                                     
  rtems_bdbuf_make_cached_and_add_to_lru_list (bd);                   
                                                                      
  if (bd->waiters)                                                    
    rtems_bdbuf_wake (&bdbuf_cache.access_waiters);                   
4000eb24:	7f ff f8 43 	call  4000cc30 <rtems_bdbuf_wake>              
4000eb28:	90 02 20 64 	add  %o0, 0x64, %o0                            
4000eb2c:	30 bf ff e7 	b,a   4000eac8 <rtems_bdbuf_release+0x78>      
                                                                      

4000eb30 <rtems_bdbuf_release_modified>: return RTEMS_SUCCESSFUL; } rtems_status_code rtems_bdbuf_release_modified (rtems_bdbuf_buffer *bd) {
4000eb30:	9d e3 bf a0 	save  %sp, -96, %sp                            
}                                                                     
                                                                      
static rtems_status_code                                              
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{                                                                     
  if (bd == NULL)                                                     
4000eb34:	80 a6 20 00 	cmp  %i0, 0                                    
4000eb38:	02 80 00 13 	be  4000eb84 <rtems_bdbuf_release_modified+0x54><== NEVER TAKEN
4000eb3c:	01 00 00 00 	nop                                            
  if (rtems_bdbuf_tracer)                                             
  {                                                                   
    printf ("bdbuf:%s: %" PRIu32 "\n", kind, bd->block);              
    rtems_bdbuf_show_users (kind, bd);                                
  }                                                                   
  rtems_bdbuf_lock_cache();                                           
4000eb40:	7f ff f7 85 	call  4000c954 <rtems_bdbuf_lock_cache>        
4000eb44:	01 00 00 00 	nop                                            
                                                                      
  sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release modified");  
  if (sc != RTEMS_SUCCESSFUL)                                         
    return sc;                                                        
                                                                      
  switch (bd->state)                                                  
4000eb48:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        
4000eb4c:	80 a2 20 03 	cmp  %o0, 3                                    
4000eb50:	1a 80 00 04 	bcc  4000eb60 <rtems_bdbuf_release_modified+0x30><== ALWAYS TAKEN
4000eb54:	80 a2 20 05 	cmp  %o0, 5                                    
      break;                                                          
    case RTEMS_BDBUF_STATE_ACCESS_PURGED:                             
      rtems_bdbuf_discard_buffer_after_access (bd);                   
      break;                                                          
    default:                                                          
      rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_6);
4000eb58:	7f ff f7 85 	call  4000c96c <rtems_bdbuf_fatal_with_state>  <== NOT EXECUTED
4000eb5c:	92 10 20 12 	mov  0x12, %o1                                 <== NOT EXECUTED
                                                                      
  sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release modified");  
  if (sc != RTEMS_SUCCESSFUL)                                         
    return sc;                                                        
                                                                      
  switch (bd->state)                                                  
4000eb60:	18 80 00 0b 	bgu  4000eb8c <rtems_bdbuf_release_modified+0x5c>
4000eb64:	80 a2 20 06 	cmp  %o0, 6                                    
  {                                                                   
    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);             
4000eb68:	90 10 00 18 	mov  %i0, %o0                                  
4000eb6c:	7f ff f8 40 	call  4000cc6c <rtems_bdbuf_add_to_modified_list_after_access>
4000eb70:	b0 10 20 00 	clr  %i0                                       
  }                                                                   
                                                                      
  if (rtems_bdbuf_tracer)                                             
    rtems_bdbuf_show_usage ();                                        
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
4000eb74:	7f ff f7 8e 	call  4000c9ac <rtems_bdbuf_unlock_cache>      
4000eb78:	01 00 00 00 	nop                                            
                                                                      
  return RTEMS_SUCCESSFUL;                                            
4000eb7c:	81 c7 e0 08 	ret                                            
4000eb80:	81 e8 00 00 	restore                                        
}                                                                     
4000eb84:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000eb88:	91 e8 20 09 	restore  %g0, 9, %o0                           <== NOT EXECUTED
                                                                      
  sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release modified");  
  if (sc != RTEMS_SUCCESSFUL)                                         
    return sc;                                                        
                                                                      
  switch (bd->state)                                                  
4000eb8c:	12 bf ff f3 	bne  4000eb58 <rtems_bdbuf_release_modified+0x28><== NEVER TAKEN
4000eb90:	01 00 00 00 	nop                                            
    case RTEMS_BDBUF_STATE_ACCESS_EMPTY:                              
    case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:                           
      rtems_bdbuf_add_to_modified_list_after_access (bd);             
      break;                                                          
    case RTEMS_BDBUF_STATE_ACCESS_PURGED:                             
      rtems_bdbuf_discard_buffer_after_access (bd);                   
4000eb94:	90 10 00 18 	mov  %i0, %o0                                  
4000eb98:	7f ff f9 96 	call  4000d1f0 <rtems_bdbuf_discard_buffer_after_access>
4000eb9c:	b0 10 20 00 	clr  %i0                                       
  }                                                                   
                                                                      
  if (rtems_bdbuf_tracer)                                             
    rtems_bdbuf_show_usage ();                                        
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
4000eba0:	7f ff f7 83 	call  4000c9ac <rtems_bdbuf_unlock_cache>      
4000eba4:	01 00 00 00 	nop                                            
                                                                      
  return RTEMS_SUCCESSFUL;                                            
4000eba8:	81 c7 e0 08 	ret                                            
4000ebac:	81 e8 00 00 	restore                                        
                                                                      

4000cdd0 <rtems_bdbuf_remove_from_tree>: return bdbuf_cache.buffer_waiters.count; } static void rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd) {
4000cdd0:	9d e3 bf 20 	save  %sp, -224, %sp                           
                       const rtems_bdbuf_buffer* node)                
{                                                                     
  const rtems_disk_device *dd = node->dd;                             
  rtems_blkdev_bnum block = node->block;                              
                                                                      
  rtems_bdbuf_buffer*  p = *root;                                     
4000cdd4:	35 10 00 6b 	sethi  %hi(0x4001ac00), %i2                    
4000cdd8:	b4 16 a3 34 	or  %i2, 0x334, %i2	! 4001af34 <bdbuf_cache>   
4000cddc:	fa 06 a0 3c 	ld  [ %i2 + 0x3c ], %i5                        
  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));                           
4000cde0:	b6 07 bf 80 	add  %fp, -128, %i3                            
 */                                                                   
static int                                                            
rtems_bdbuf_avl_remove(rtems_bdbuf_buffer**      root,                
                       const rtems_bdbuf_buffer* node)                
{                                                                     
  const rtems_disk_device *dd = node->dd;                             
4000cde4:	f8 06 20 14 	ld  [ %i0 + 0x14 ], %i4                        
  rtems_blkdev_bnum block = node->block;                              
4000cde8:	e0 06 20 18 	ld  [ %i0 + 0x18 ], %l0                        
  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));                           
4000cdec:	90 10 00 1b 	mov  %i3, %o0                                  
4000cdf0:	92 10 20 00 	clr  %o1                                       
4000cdf4:	40 00 1e 7c 	call  400147e4 <memset>                        
4000cdf8:	94 10 20 80 	mov  0x80, %o2                                 
                                                                      
  while (p != NULL)                                                   
4000cdfc:	80 a7 60 00 	cmp  %i5, 0                                    
4000ce00:	02 80 00 11 	be  4000ce44 <rtems_bdbuf_remove_from_tree+0x74><== NEVER TAKEN
4000ce04:	84 10 00 1b 	mov  %i3, %g2                                  
    *buf_prev++ = p;                                                  
                                                                      
    if (((uintptr_t) p->dd < (uintptr_t) dd)                          
        || ((p->dd == dd) && (p->block < block)))                     
    {                                                                 
      p->avl.cache = 1;                                               
4000ce08:	88 10 20 01 	mov  1, %g4                                    
      p = p->avl.right;                                               
    }                                                                 
    else if ((p->dd != dd) || (p->block != block))                    
    {                                                                 
      p->avl.cache = -1;                                              
4000ce0c:	b2 10 3f ff 	mov  -1, %i1                                   
                                                                      
  while (p != NULL)                                                   
  {                                                                   
    *buf_prev++ = p;                                                  
                                                                      
    if (((uintptr_t) p->dd < (uintptr_t) dd)                          
4000ce10:	c6 07 60 14 	ld  [ %i5 + 0x14 ], %g3                        
                                                                      
  memset (buf_stack, 0, sizeof(buf_stack));                           
                                                                      
  while (p != NULL)                                                   
  {                                                                   
    *buf_prev++ = p;                                                  
4000ce14:	fa 20 80 00 	st  %i5, [ %g2 ]                               
                                                                      
    if (((uintptr_t) p->dd < (uintptr_t) dd)                          
4000ce18:	80 a0 c0 1c 	cmp  %g3, %i4                                  
4000ce1c:	0a 80 00 65 	bcs  4000cfb0 <rtems_bdbuf_remove_from_tree+0x1e0><== NEVER TAKEN
4000ce20:	82 00 a0 04 	add  %g2, 4, %g1                               
        || ((p->dd == dd) && (p->block < block)))                     
4000ce24:	80 a7 00 03 	cmp  %i4, %g3                                  
4000ce28:	22 80 00 0a 	be,a   4000ce50 <rtems_bdbuf_remove_from_tree+0x80><== ALWAYS TAKEN
4000ce2c:	c6 07 60 18 	ld  [ %i5 + 0x18 ], %g3                        
      p->avl.cache = 1;                                               
      p = p->avl.right;                                               
    }                                                                 
    else if ((p->dd != dd) || (p->block != block))                    
    {                                                                 
      p->avl.cache = -1;                                              
4000ce30:	f2 2f 60 10 	stb  %i1, [ %i5 + 0x10 ]                       <== NOT EXECUTED
      p = p->avl.left;                                                
4000ce34:	fa 07 60 08 	ld  [ %i5 + 8 ], %i5                           
                                                                      
  bool modified = false;                                              
                                                                      
  memset (buf_stack, 0, sizeof(buf_stack));                           
                                                                      
  while (p != NULL)                                                   
4000ce38:	80 a7 60 00 	cmp  %i5, 0                                    
4000ce3c:	12 bf ff f5 	bne  4000ce10 <rtems_bdbuf_remove_from_tree+0x40><== ALWAYS TAKEN
4000ce40:	84 10 00 01 	mov  %g1, %g2                                  
                                                                      
static void                                                           
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)                 
{                                                                     
  if (rtems_bdbuf_avl_remove (&bdbuf_cache.tree, bd) != 0)            
    rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_TREE_RM);
4000ce44:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        <== NOT EXECUTED
4000ce48:	7f ff fe c9 	call  4000c96c <rtems_bdbuf_fatal_with_state>  <== NOT EXECUTED
4000ce4c:	92 10 20 1b 	mov  0x1b, %o1                                 <== NOT EXECUTED
  while (p != NULL)                                                   
  {                                                                   
    *buf_prev++ = p;                                                  
                                                                      
    if (((uintptr_t) p->dd < (uintptr_t) dd)                          
        || ((p->dd == dd) && (p->block < block)))                     
4000ce50:	80 a4 00 03 	cmp  %l0, %g3                                  
4000ce54:	38 80 00 58 	bgu,a   4000cfb4 <rtems_bdbuf_remove_from_tree+0x1e4>
4000ce58:	c8 2f 60 10 	stb  %g4, [ %i5 + 0x10 ]                       
    {                                                                 
      p->avl.cache = 1;                                               
      p = p->avl.right;                                               
    }                                                                 
    else if ((p->dd != dd) || (p->block != block))                    
4000ce5c:	80 a4 00 03 	cmp  %l0, %g3                                  
4000ce60:	32 bf ff f5 	bne,a   4000ce34 <rtems_bdbuf_remove_from_tree+0x64>
4000ce64:	f2 2f 60 10 	stb  %i1, [ %i5 + 0x10 ]                       
                                                                      
  memset (buf_stack, 0, sizeof(buf_stack));                           
                                                                      
  while (p != NULL)                                                   
  {                                                                   
    *buf_prev++ = p;                                                  
4000ce68:	9a 10 00 01 	mov  %g1, %o5                                  
  }                                                                   
                                                                      
  q = p;                                                              
                                                                      
  buf_prev--;                                                         
  if (buf_prev > buf_stack)                                           
4000ce6c:	80 a0 80 1b 	cmp  %g2, %i3                                  
4000ce70:	18 80 00 6a 	bgu  4000d018 <rtems_bdbuf_remove_from_tree+0x248>
4000ce74:	b0 10 20 00 	clr  %i0                                       
  {                                                                   
    p = NULL;                                                         
  }                                                                   
                                                                      
  /* at this moment q - is a node to delete, p is q's parent */       
  if (q->avl.right == NULL)                                           
4000ce78:	f2 07 60 0c 	ld  [ %i5 + 0xc ], %i1                         
4000ce7c:	80 a6 60 00 	cmp  %i1, 0                                    
4000ce80:	22 80 00 6b 	be,a   4000d02c <rtems_bdbuf_remove_from_tree+0x25c>
4000ce84:	c6 07 60 08 	ld  [ %i5 + 8 ], %g3                           
  {                                                                   
    rtems_bdbuf_buffer **t;                                           
                                                                      
    r = q->avl.right;                                                 
                                                                      
    if (r->avl.left == NULL)                                          
4000ce88:	c6 06 60 08 	ld  [ %i1 + 8 ], %g3                           
4000ce8c:	84 10 00 19 	mov  %i1, %g2                                  
4000ce90:	80 a0 e0 00 	cmp  %g3, 0                                    
4000ce94:	12 80 00 06 	bne  4000ceac <rtems_bdbuf_remove_from_tree+0xdc>
4000ce98:	b8 10 3f ff 	mov  -1, %i4                                   
    {                                                                 
      r->avl.left = q->avl.left;                                      
4000ce9c:	10 80 00 ba 	b  4000d184 <rtems_bdbuf_remove_from_tree+0x3b4>
4000cea0:	c6 07 60 08 	ld  [ %i5 + 8 ], %g3                           
    else                                                              
    {                                                                 
      t = buf_prev++;                                                 
      s = r;                                                          
                                                                      
      while (s->avl.left != NULL)                                     
4000cea4:	84 10 00 03 	mov  %g3, %g2                                  
4000cea8:	86 10 00 04 	mov  %g4, %g3                                  
4000ceac:	c8 00 e0 08 	ld  [ %g3 + 8 ], %g4                           
      {                                                               
        *buf_prev++ = r = s;                                          
4000ceb0:	c4 20 40 00 	st  %g2, [ %g1 ]                               
        s = r->avl.left;                                              
        r->avl.cache = -1;                                            
4000ceb4:	f8 28 a0 10 	stb  %i4, [ %g2 + 0x10 ]                       
    else                                                              
    {                                                                 
      t = buf_prev++;                                                 
      s = r;                                                          
                                                                      
      while (s->avl.left != NULL)                                     
4000ceb8:	80 a1 20 00 	cmp  %g4, 0                                    
4000cebc:	12 bf ff fa 	bne  4000cea4 <rtems_bdbuf_remove_from_tree+0xd4>
4000cec0:	82 00 60 04 	add  %g1, 4, %g1                               
        *buf_prev++ = r = s;                                          
        s = r->avl.left;                                              
        r->avl.cache = -1;                                            
      }                                                               
                                                                      
      s->avl.left = q->avl.left;                                      
4000cec4:	de 07 60 08 	ld  [ %i5 + 8 ], %o7                           
      r->avl.left = s->avl.right;                                     
4000cec8:	f8 00 e0 0c 	ld  [ %g3 + 0xc ], %i4                         
      s->avl.right = q->avl.right;                                    
      s->avl.bal = q->avl.bal;                                        
4000cecc:	c8 0f 60 11 	ldub  [ %i5 + 0x11 ], %g4                      
        *buf_prev++ = r = s;                                          
        s = r->avl.left;                                              
        r->avl.cache = -1;                                            
      }                                                               
                                                                      
      s->avl.left = q->avl.left;                                      
4000ced0:	de 20 e0 08 	st  %o7, [ %g3 + 8 ]                           
      r->avl.left = s->avl.right;                                     
4000ced4:	f8 20 a0 08 	st  %i4, [ %g2 + 8 ]                           
      s->avl.right = q->avl.right;                                    
4000ced8:	f2 20 e0 0c 	st  %i1, [ %g3 + 0xc ]                         
      s->avl.bal = q->avl.bal;                                        
      s->avl.cache = 1;                                               
4000cedc:	84 10 20 01 	mov  1, %g2                                    
      }                                                               
                                                                      
      s->avl.left = q->avl.left;                                      
      r->avl.left = s->avl.right;                                     
      s->avl.right = q->avl.right;                                    
      s->avl.bal = q->avl.bal;                                        
4000cee0:	c8 28 e0 11 	stb  %g4, [ %g3 + 0x11 ]                       
      s->avl.cache = 1;                                               
4000cee4:	c4 28 e0 10 	stb  %g2, [ %g3 + 0x10 ]                       
                                                                      
      *t = q = s;                                                     
4000cee8:	c6 23 7f fc 	st  %g3, [ %o5 + -4 ]                          
    }                                                                 
  }                                                                   
                                                                      
  if (p != NULL)                                                      
4000ceec:	80 a6 20 00 	cmp  %i0, 0                                    
4000cef0:	22 80 00 07 	be,a   4000cf0c <rtems_bdbuf_remove_from_tree+0x13c>
4000cef4:	c6 26 a0 3c 	st  %g3, [ %i2 + 0x3c ]                        
  {                                                                   
    if (p->avl.cache == -1)                                           
4000cef8:	c4 4e 20 10 	ldsb  [ %i0 + 0x10 ], %g2                      
4000cefc:	80 a0 bf ff 	cmp  %g2, -1                                   
4000cf00:	22 80 00 03 	be,a   4000cf0c <rtems_bdbuf_remove_from_tree+0x13c>
4000cf04:	c6 26 20 08 	st  %g3, [ %i0 + 8 ]                           
    {                                                                 
      p->avl.left = q;                                                
    }                                                                 
    else                                                              
    {                                                                 
      p->avl.right = q;                                               
4000cf08:	c6 26 20 0c 	st  %g3, [ %i0 + 0xc ]                         
                                                                      
  modified = true;                                                    
                                                                      
  while (modified)                                                    
  {                                                                   
    if (buf_prev > buf_stack)                                         
4000cf0c:	80 a0 40 1b 	cmp  %g1, %i3                                  
4000cf10:	08 80 00 26 	bleu  4000cfa8 <rtems_bdbuf_remove_from_tree+0x1d8>
4000cf14:	b2 10 3f ff 	mov  -1, %i1                                   
4000cf18:	c4 00 7f fc 	ld  [ %g1 + -4 ], %g2                          
4000cf1c:	c8 08 a0 10 	ldub  [ %g2 + 0x10 ], %g4                      
4000cf20:	10 80 00 10 	b  4000cf60 <rtems_bdbuf_remove_from_tree+0x190>
4000cf24:	89 29 20 18 	sll  %g4, 0x18, %g4                            
        case +1:                                                      
          p->avl.bal = 0;                                             
          break;                                                      
                                                                      
        case  0:                                                      
          p->avl.bal = -1;                                            
4000cf28:	86 10 00 02 	mov  %g2, %g3                                  
          modified = false;                                           
4000cf2c:	ba 10 20 00 	clr  %i5                                       
        default:                                                      
          break;                                                      
      }                                                               
    }                                                                 
                                                                      
    if (buf_prev > buf_stack)                                         
4000cf30:	80 a0 40 1b 	cmp  %g1, %i3                                  
4000cf34:	28 80 00 1d 	bleu,a   4000cfa8 <rtems_bdbuf_remove_from_tree+0x1d8>
4000cf38:	c6 26 a0 3c 	st  %g3, [ %i2 + 0x3c ]                        
    {                                                                 
      q = *(buf_prev - 1);                                            
4000cf3c:	c4 00 7f fc 	ld  [ %g1 + -4 ], %g2                          
                                                                      
      if (q->avl.cache == -1)                                         
4000cf40:	c8 08 a0 10 	ldub  [ %g2 + 0x10 ], %g4                      
4000cf44:	89 29 20 18 	sll  %g4, 0x18, %g4                            
4000cf48:	b9 39 20 18 	sra  %g4, 0x18, %i4                            
4000cf4c:	80 a7 3f ff 	cmp  %i4, -1                                   
4000cf50:	02 80 00 47 	be  4000d06c <rtems_bdbuf_remove_from_tree+0x29c>
4000cf54:	80 8f 60 ff 	btst  0xff, %i5                                
    *root = q;                                                        
  }                                                                   
                                                                      
  modified = true;                                                    
                                                                      
  while (modified)                                                    
4000cf58:	02 80 00 14 	be  4000cfa8 <rtems_bdbuf_remove_from_tree+0x1d8>
4000cf5c:	c6 20 a0 0c 	st  %g3, [ %g2 + 0xc ]                         
    else                                                              
    {                                                                 
      break;                                                          
    }                                                                 
                                                                      
    if (p->avl.cache == -1)                                           
4000cf60:	89 39 20 18 	sra  %g4, 0x18, %g4                            
                                                                      
  while (modified)                                                    
  {                                                                   
    if (buf_prev > buf_stack)                                         
    {                                                                 
      p = *--buf_prev;                                                
4000cf64:	82 00 7f fc 	add  %g1, -4, %g1                              
    else                                                              
    {                                                                 
      break;                                                          
    }                                                                 
                                                                      
    if (p->avl.cache == -1)                                           
4000cf68:	80 a1 3f ff 	cmp  %g4, -1                                   
4000cf6c:	02 80 00 38 	be  4000d04c <rtems_bdbuf_remove_from_tree+0x27c>
4000cf70:	c6 48 a0 11 	ldsb  [ %g2 + 0x11 ], %g3                      
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      /* rebalance right branch */                                    
      switch (p->avl.bal)                                             
4000cf74:	80 a0 e0 00 	cmp  %g3, 0                                    
4000cf78:	22 bf ff ec 	be,a   4000cf28 <rtems_bdbuf_remove_from_tree+0x158>
4000cf7c:	f2 28 a0 11 	stb  %i1, [ %g2 + 0x11 ]                       
4000cf80:	80 a0 e0 01 	cmp  %g3, 1                                    
4000cf84:	02 80 00 42 	be  4000d08c <rtems_bdbuf_remove_from_tree+0x2bc>
4000cf88:	80 a0 ff ff 	cmp  %g3, -1                                   
4000cf8c:	22 80 00 0c 	be,a   4000cfbc <rtems_bdbuf_remove_from_tree+0x1ec><== ALWAYS TAKEN
4000cf90:	c8 00 a0 08 	ld  [ %g2 + 8 ], %g4                           
4000cf94:	86 10 00 02 	mov  %g2, %g3                                  <== NOT EXECUTED
        default:                                                      
          break;                                                      
      }                                                               
    }                                                                 
                                                                      
    if (buf_prev > buf_stack)                                         
4000cf98:	80 a0 40 1b 	cmp  %g1, %i3                                  <== NOT EXECUTED
4000cf9c:	18 bf ff e8 	bgu  4000cf3c <rtems_bdbuf_remove_from_tree+0x16c><== NOT EXECUTED
4000cfa0:	ba 10 20 01 	mov  1, %i5                                    <== NOT EXECUTED
        q->avl.right = p;                                             
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      *root = p;                                                      
4000cfa4:	c6 26 a0 3c 	st  %g3, [ %i2 + 0x3c ]                        <== NOT EXECUTED
4000cfa8:	81 c7 e0 08 	ret                                            
4000cfac:	81 e8 00 00 	restore                                        
    *buf_prev++ = p;                                                  
                                                                      
    if (((uintptr_t) p->dd < (uintptr_t) dd)                          
        || ((p->dd == dd) && (p->block < block)))                     
    {                                                                 
      p->avl.cache = 1;                                               
4000cfb0:	c8 2f 60 10 	stb  %g4, [ %i5 + 0x10 ]                       <== NOT EXECUTED
      p = p->avl.right;                                               
4000cfb4:	10 bf ff a1 	b  4000ce38 <rtems_bdbuf_remove_from_tree+0x68>
4000cfb8:	fa 07 60 0c 	ld  [ %i5 + 0xc ], %i5                         
          break;                                                      
                                                                      
        case -1:                                                      
          p1 = p->avl.left;                                           
                                                                      
          if (p1->avl.bal <= 0) /* simple LL-turn */                  
4000cfbc:	c6 49 20 11 	ldsb  [ %g4 + 0x11 ], %g3                      
4000cfc0:	80 a0 e0 00 	cmp  %g3, 0                                    
4000cfc4:	24 80 00 41 	ble,a   4000d0c8 <rtems_bdbuf_remove_from_tree+0x2f8>
4000cfc8:	fa 01 20 0c 	ld  [ %g4 + 0xc ], %i5                         
            }                                                         
            p = p1;                                                   
          }                                                           
          else /* double LR-turn */                                   
          {                                                           
            p2 = p1->avl.right;                                       
4000cfcc:	c6 01 20 0c 	ld  [ %g4 + 0xc ], %g3                         
                                                                      
            p1->avl.right = p2->avl.left;                             
4000cfd0:	f8 00 e0 08 	ld  [ %g3 + 8 ], %i4                           
            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;
4000cfd4:	fa 48 e0 11 	ldsb  [ %g3 + 0x11 ], %i5                      
          }                                                           
          else /* double LR-turn */                                   
          {                                                           
            p2 = p1->avl.right;                                       
                                                                      
            p1->avl.right = p2->avl.left;                             
4000cfd8:	f8 21 20 0c 	st  %i4, [ %g4 + 0xc ]                         
            p2->avl.left = p1;                                        
            p->avl.left = p2->avl.right;                              
4000cfdc:	f8 00 e0 0c 	ld  [ %g3 + 0xc ], %i4                         
          else /* double LR-turn */                                   
          {                                                           
            p2 = p1->avl.right;                                       
                                                                      
            p1->avl.right = p2->avl.left;                             
            p2->avl.left = p1;                                        
4000cfe0:	c8 20 e0 08 	st  %g4, [ %g3 + 8 ]                           
            p->avl.left = p2->avl.right;                              
4000cfe4:	f8 20 a0 08 	st  %i4, [ %g2 + 8 ]                           
            p2->avl.right = p;                                        
                                                                      
            if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
4000cfe8:	80 a7 7f ff 	cmp  %i5, -1                                   
4000cfec:	02 80 00 40 	be  4000d0ec <rtems_bdbuf_remove_from_tree+0x31c>
4000cff0:	c4 20 e0 0c 	st  %g2, [ %g3 + 0xc ]                         
4000cff4:	c0 28 a0 11 	clrb  [ %g2 + 0x11 ]                           
            if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
4000cff8:	c4 48 e0 11 	ldsb  [ %g3 + 0x11 ], %g2                      
4000cffc:	80 a0 a0 01 	cmp  %g2, 1                                    
4000d000:	22 80 00 42 	be,a   4000d108 <rtems_bdbuf_remove_from_tree+0x338>
4000d004:	f2 29 20 11 	stb  %i1, [ %g4 + 0x11 ]                       
4000d008:	c0 29 20 11 	clrb  [ %g4 + 0x11 ]                           
                                                                      
            p = p2;                                                   
            p2->avl.bal = 0;                                          
4000d00c:	c0 28 e0 11 	clrb  [ %g3 + 0x11 ]                           
4000d010:	10 bf ff c8 	b  4000cf30 <rtems_bdbuf_remove_from_tree+0x160>
4000d014:	ba 10 20 01 	mov  1, %i5                                    
  {                                                                   
    p = NULL;                                                         
  }                                                                   
                                                                      
  /* at this moment q - is a node to delete, p is q's parent */       
  if (q->avl.right == NULL)                                           
4000d018:	f2 07 60 0c 	ld  [ %i5 + 0xc ], %i1                         
4000d01c:	80 a6 60 00 	cmp  %i1, 0                                    
4000d020:	12 bf ff 9a 	bne  4000ce88 <rtems_bdbuf_remove_from_tree+0xb8>
4000d024:	f0 00 7f f8 	ld  [ %g1 + -8 ], %i0                          
  {                                                                   
    r = q->avl.left;                                                  
4000d028:	c6 07 60 08 	ld  [ %i5 + 8 ], %g3                           
    if (r != NULL)                                                    
4000d02c:	80 a0 e0 00 	cmp  %g3, 0                                    
4000d030:	02 80 00 61 	be  4000d1b4 <rtems_bdbuf_remove_from_tree+0x3e4>
4000d034:	80 a6 20 00 	cmp  %i0, 0                                    
    {                                                                 
      r->avl.bal = 0;                                                 
4000d038:	c0 28 e0 11 	clrb  [ %g3 + 0x11 ]                           
                                                                      
      *t = q = s;                                                     
    }                                                                 
  }                                                                   
                                                                      
  if (p != NULL)                                                      
4000d03c:	12 bf ff af 	bne  4000cef8 <rtems_bdbuf_remove_from_tree+0x128>
4000d040:	82 10 00 02 	mov  %g2, %g1                                  
      p->avl.right = q;                                               
    }                                                                 
  }                                                                   
  else                                                                
  {                                                                   
    *root = q;                                                        
4000d044:	10 bf ff b2 	b  4000cf0c <rtems_bdbuf_remove_from_tree+0x13c>
4000d048:	c6 26 a0 3c 	st  %g3, [ %i2 + 0x3c ]                        
    }                                                                 
                                                                      
    if (p->avl.cache == -1)                                           
    {                                                                 
      /* rebalance left branch */                                     
      switch (p->avl.bal)                                             
4000d04c:	80 a0 e0 00 	cmp  %g3, 0                                    
4000d050:	12 80 00 0b 	bne  4000d07c <rtems_bdbuf_remove_from_tree+0x2ac>
4000d054:	80 a0 e0 01 	cmp  %g3, 1                                    
      {                                                               
        case -1:                                                      
          p->avl.bal = 0;                                             
          break;                                                      
        case  0:                                                      
          p->avl.bal = 1;                                             
4000d058:	88 10 20 01 	mov  1, %g4                                    
4000d05c:	86 10 00 02 	mov  %g2, %g3                                  
4000d060:	c8 28 a0 11 	stb  %g4, [ %g2 + 0x11 ]                       
          modified = false;                                           
4000d064:	10 bf ff b3 	b  4000cf30 <rtems_bdbuf_remove_from_tree+0x160>
4000d068:	ba 10 20 00 	clr  %i5                                       
    *root = q;                                                        
  }                                                                   
                                                                      
  modified = true;                                                    
                                                                      
  while (modified)                                                    
4000d06c:	12 bf ff bd 	bne  4000cf60 <rtems_bdbuf_remove_from_tree+0x190>
4000d070:	c6 20 a0 08 	st  %g3, [ %g2 + 8 ]                           
4000d074:	81 c7 e0 08 	ret                                            
4000d078:	81 e8 00 00 	restore                                        
    }                                                                 
                                                                      
    if (p->avl.cache == -1)                                           
    {                                                                 
      /* rebalance left branch */                                     
      switch (p->avl.bal)                                             
4000d07c:	02 80 00 08 	be  4000d09c <rtems_bdbuf_remove_from_tree+0x2cc>
4000d080:	80 a0 ff ff 	cmp  %g3, -1                                   
4000d084:	32 bf ff c5 	bne,a   4000cf98 <rtems_bdbuf_remove_from_tree+0x1c8><== NEVER TAKEN
4000d088:	86 10 00 02 	mov  %g2, %g3                                  <== NOT EXECUTED
    {                                                                 
      /* rebalance right branch */                                    
      switch (p->avl.bal)                                             
      {                                                               
        case +1:                                                      
          p->avl.bal = 0;                                             
4000d08c:	c0 28 a0 11 	clrb  [ %g2 + 0x11 ]                           
4000d090:	86 10 00 02 	mov  %g2, %g3                                  
4000d094:	10 bf ff a7 	b  4000cf30 <rtems_bdbuf_remove_from_tree+0x160>
4000d098:	ba 10 20 01 	mov  1, %i5                                    
          p->avl.bal = 1;                                             
          modified = false;                                           
          break;                                                      
                                                                      
        case +1:                                                      
          p1 = p->avl.right;                                          
4000d09c:	c6 00 a0 0c 	ld  [ %g2 + 0xc ], %g3                         
                                                                      
          if (p1->avl.bal >= 0) /* simple RR-turn */                  
4000d0a0:	fa 48 e0 11 	ldsb  [ %g3 + 0x11 ], %i5                      
4000d0a4:	80 a7 60 00 	cmp  %i5, 0                                    
4000d0a8:	26 80 00 24 	bl,a   4000d138 <rtems_bdbuf_remove_from_tree+0x368>
4000d0ac:	fa 00 e0 08 	ld  [ %g3 + 8 ], %i5                           
          {                                                           
            p->avl.right = p1->avl.left;                              
4000d0b0:	f8 00 e0 08 	ld  [ %g3 + 8 ], %i4                           
            p1->avl.left = p;                                         
4000d0b4:	c4 20 e0 08 	st  %g2, [ %g3 + 8 ]                           
                                                                      
            if (p1->avl.bal == 0)                                     
4000d0b8:	12 80 00 17 	bne  4000d114 <rtems_bdbuf_remove_from_tree+0x344>
4000d0bc:	f8 20 a0 0c 	st  %i4, [ %g2 + 0xc ]                         
            {                                                         
              p1->avl.bal = -1;                                       
4000d0c0:	10 bf ff 9c 	b  4000cf30 <rtems_bdbuf_remove_from_tree+0x160>
4000d0c4:	c8 28 e0 11 	stb  %g4, [ %g3 + 0x11 ]                       
          p1 = p->avl.left;                                           
                                                                      
          if (p1->avl.bal <= 0) /* simple LL-turn */                  
          {                                                           
            p->avl.left = p1->avl.right;                              
            p1->avl.right = p;                                        
4000d0c8:	c4 21 20 0c 	st  %g2, [ %g4 + 0xc ]                         
            if (p1->avl.bal == 0)                                     
4000d0cc:	80 a0 e0 00 	cmp  %g3, 0                                    
4000d0d0:	12 80 00 15 	bne  4000d124 <rtems_bdbuf_remove_from_tree+0x354>
4000d0d4:	fa 20 a0 08 	st  %i5, [ %g2 + 8 ]                           
            {                                                         
              p1->avl.bal = 1;                                        
4000d0d8:	84 10 20 01 	mov  1, %g2                                    
4000d0dc:	86 10 00 04 	mov  %g4, %g3                                  
4000d0e0:	c4 29 20 11 	stb  %g2, [ %g4 + 0x11 ]                       
              modified = false;                                       
4000d0e4:	10 bf ff 93 	b  4000cf30 <rtems_bdbuf_remove_from_tree+0x160>
4000d0e8:	ba 10 20 00 	clr  %i5                                       
            p1->avl.right = p2->avl.left;                             
            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;
4000d0ec:	ba 10 20 01 	mov  1, %i5                                    
4000d0f0:	fa 28 a0 11 	stb  %i5, [ %g2 + 0x11 ]                       
            if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
4000d0f4:	c4 48 e0 11 	ldsb  [ %g3 + 0x11 ], %g2                      
4000d0f8:	80 a0 a0 01 	cmp  %g2, 1                                    
4000d0fc:	32 bf ff c4 	bne,a   4000d00c <rtems_bdbuf_remove_from_tree+0x23c><== ALWAYS TAKEN
4000d100:	c0 29 20 11 	clrb  [ %g4 + 0x11 ]                           
4000d104:	f2 29 20 11 	stb  %i1, [ %g4 + 0x11 ]                       <== NOT EXECUTED
                                                                      
            p = p2;                                                   
            p2->avl.bal = 0;                                          
4000d108:	c0 28 e0 11 	clrb  [ %g3 + 0x11 ]                           
4000d10c:	10 bf ff 89 	b  4000cf30 <rtems_bdbuf_remove_from_tree+0x160>
4000d110:	ba 10 20 01 	mov  1, %i5                                    
              p1->avl.bal = -1;                                       
              modified = false;                                       
            }                                                         
            else                                                      
            {                                                         
              p->avl.bal = 0;                                         
4000d114:	c0 28 a0 11 	clrb  [ %g2 + 0x11 ]                           
              p1->avl.bal = 0;                                        
4000d118:	c0 28 e0 11 	clrb  [ %g3 + 0x11 ]                           
4000d11c:	10 bf ff 85 	b  4000cf30 <rtems_bdbuf_remove_from_tree+0x160>
4000d120:	ba 10 20 01 	mov  1, %i5                                    
              p1->avl.bal = 1;                                        
              modified = false;                                       
            }                                                         
            else                                                      
            {                                                         
              p->avl.bal = 0;                                         
4000d124:	c0 28 a0 11 	clrb  [ %g2 + 0x11 ]                           
              p1->avl.bal = 0;                                        
4000d128:	c0 29 20 11 	clrb  [ %g4 + 0x11 ]                           
4000d12c:	86 10 00 04 	mov  %g4, %g3                                  
4000d130:	10 bf ff 80 	b  4000cf30 <rtems_bdbuf_remove_from_tree+0x160>
4000d134:	ba 10 20 01 	mov  1, %i5                                    
          }                                                           
          else /* double RL-turn */                                   
          {                                                           
            p2 = p1->avl.left;                                        
                                                                      
            p1->avl.left = p2->avl.right;                             
4000d138:	f0 07 60 0c 	ld  [ %i5 + 0xc ], %i0                         
            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;
4000d13c:	f8 4f 60 11 	ldsb  [ %i5 + 0x11 ], %i4                      
          }                                                           
          else /* double RL-turn */                                   
          {                                                           
            p2 = p1->avl.left;                                        
                                                                      
            p1->avl.left = p2->avl.right;                             
4000d140:	f0 20 e0 08 	st  %i0, [ %g3 + 8 ]                           
            p2->avl.right = p1;                                       
            p->avl.right = p2->avl.left;                              
4000d144:	f0 07 60 08 	ld  [ %i5 + 8 ], %i0                           
          else /* double RL-turn */                                   
          {                                                           
            p2 = p1->avl.left;                                        
                                                                      
            p1->avl.left = p2->avl.right;                             
            p2->avl.right = p1;                                       
4000d148:	c6 27 60 0c 	st  %g3, [ %i5 + 0xc ]                         
            p->avl.right = p2->avl.left;                              
4000d14c:	f0 20 a0 0c 	st  %i0, [ %g2 + 0xc ]                         
            p2->avl.left = p;                                         
                                                                      
            if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
4000d150:	80 a7 20 01 	cmp  %i4, 1                                    
4000d154:	02 80 00 16 	be  4000d1ac <rtems_bdbuf_remove_from_tree+0x3dc>
4000d158:	c4 27 60 08 	st  %g2, [ %i5 + 8 ]                           
4000d15c:	c0 28 a0 11 	clrb  [ %g2 + 0x11 ]                           
            if (p2->avl.bal == -1) p1->avl.bal = 1; else p1->avl.bal = 0;
4000d160:	c4 4f 60 11 	ldsb  [ %i5 + 0x11 ], %g2                      
4000d164:	80 a0 bf ff 	cmp  %g2, -1                                   
4000d168:	02 80 00 0f 	be  4000d1a4 <rtems_bdbuf_remove_from_tree+0x3d4><== NEVER TAKEN
4000d16c:	84 10 20 01 	mov  1, %g2                                    
4000d170:	c0 28 e0 11 	clrb  [ %g3 + 0x11 ]                           
                                                                      
            p = p2;                                                   
            p2->avl.bal = 0;                                          
4000d174:	c0 2f 60 11 	clrb  [ %i5 + 0x11 ]                           
4000d178:	86 10 00 1d 	mov  %i5, %g3                                  
4000d17c:	10 bf ff 6d 	b  4000cf30 <rtems_bdbuf_remove_from_tree+0x160>
4000d180:	ba 10 20 01 	mov  1, %i5                                    
    r = q->avl.right;                                                 
                                                                      
    if (r->avl.left == NULL)                                          
    {                                                                 
      r->avl.left = q->avl.left;                                      
      r->avl.bal = q->avl.bal;                                        
4000d184:	c4 0f 60 11 	ldub  [ %i5 + 0x11 ], %g2                      
                                                                      
    r = q->avl.right;                                                 
                                                                      
    if (r->avl.left == NULL)                                          
    {                                                                 
      r->avl.left = q->avl.left;                                      
4000d188:	c6 26 60 08 	st  %g3, [ %i1 + 8 ]                           
      r->avl.bal = q->avl.bal;                                        
4000d18c:	c4 2e 60 11 	stb  %g2, [ %i1 + 0x11 ]                       
      r->avl.cache = 1;                                               
      *buf_prev++ = q = r;                                            
4000d190:	f2 20 7f fc 	st  %i1, [ %g1 + -4 ]                          
                                                                      
    if (r->avl.left == NULL)                                          
    {                                                                 
      r->avl.left = q->avl.left;                                      
      r->avl.bal = q->avl.bal;                                        
      r->avl.cache = 1;                                               
4000d194:	84 10 20 01 	mov  1, %g2                                    
      *buf_prev++ = q = r;                                            
4000d198:	86 10 00 19 	mov  %i1, %g3                                  
                                                                      
    if (r->avl.left == NULL)                                          
    {                                                                 
      r->avl.left = q->avl.left;                                      
      r->avl.bal = q->avl.bal;                                        
      r->avl.cache = 1;                                               
4000d19c:	10 bf ff 54 	b  4000ceec <rtems_bdbuf_remove_from_tree+0x11c>
4000d1a0:	c4 2e 60 10 	stb  %g2, [ %i1 + 0x10 ]                       
            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;
            if (p2->avl.bal == -1) p1->avl.bal = 1; else p1->avl.bal = 0;
4000d1a4:	10 bf ff f4 	b  4000d174 <rtems_bdbuf_remove_from_tree+0x3a4><== NOT EXECUTED
4000d1a8:	c4 28 e0 11 	stb  %g2, [ %g3 + 0x11 ]                       <== NOT EXECUTED
            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;
4000d1ac:	10 bf ff ed 	b  4000d160 <rtems_bdbuf_remove_from_tree+0x390>
4000d1b0:	c8 28 a0 11 	stb  %g4, [ %g2 + 0x11 ]                       
                                                                      
  /* at this moment q - is a node to delete, p is q's parent */       
  if (q->avl.right == NULL)                                           
  {                                                                   
    r = q->avl.left;                                                  
    if (r != NULL)                                                    
4000d1b4:	10 bf ff 4e 	b  4000ceec <rtems_bdbuf_remove_from_tree+0x11c>
4000d1b8:	82 10 00 02 	mov  %g2, %g1                                  
                                                                      

4000d248 <rtems_bdbuf_remove_from_tree_and_lru_list>: rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_TREE_RM); } static void rtems_bdbuf_remove_from_tree_and_lru_list (rtems_bdbuf_buffer *bd) {
4000d248:	9d e3 bf a0 	save  %sp, -96, %sp                            
  switch (bd->state)                                                  
4000d24c:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        
4000d250:	80 a2 20 00 	cmp  %o0, 0                                    
4000d254:	22 80 00 0a 	be,a   4000d27c <rtems_bdbuf_remove_from_tree_and_lru_list+0x34>
4000d258:	c4 06 00 00 	ld  [ %i0 ], %g2                               
4000d25c:	80 a2 20 02 	cmp  %o0, 2                                    
4000d260:	02 80 00 04 	be  4000d270 <rtems_bdbuf_remove_from_tree_and_lru_list+0x28><== ALWAYS TAKEN
4000d264:	01 00 00 00 	nop                                            
      break;                                                          
    case RTEMS_BDBUF_STATE_CACHED:                                    
      rtems_bdbuf_remove_from_tree (bd);                              
      break;                                                          
    default:                                                          
      rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_10);
4000d268:	7f ff fd c1 	call  4000c96c <rtems_bdbuf_fatal_with_state>  <== NOT EXECUTED
4000d26c:	92 10 20 16 	mov  0x16, %o1	! 16 <PROM_START+0x16>          <== NOT EXECUTED
  switch (bd->state)                                                  
  {                                                                   
    case RTEMS_BDBUF_STATE_FREE:                                      
      break;                                                          
    case RTEMS_BDBUF_STATE_CACHED:                                    
      rtems_bdbuf_remove_from_tree (bd);                              
4000d270:	7f ff fe d8 	call  4000cdd0 <rtems_bdbuf_remove_from_tree>  
4000d274:	90 10 00 18 	mov  %i0, %o0                                  
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
4000d278:	c4 06 00 00 	ld  [ %i0 ], %g2                               
  previous       = the_node->previous;                                
4000d27c:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
  next->previous = previous;                                          
4000d280:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]                           
  previous->next = next;                                              
4000d284:	c4 20 40 00 	st  %g2, [ %g1 ]                               
4000d288:	81 c7 e0 08 	ret                                            
4000d28c:	81 e8 00 00 	restore                                        
                                                                      

4000ca30 <rtems_bdbuf_restore_preemption>: return prev_mode; } static void rtems_bdbuf_restore_preemption (rtems_mode prev_mode) {
4000ca30:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  sc = rtems_task_mode (prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode); 
4000ca34:	13 00 00 3f 	sethi  %hi(0xfc00), %o1                        
  return prev_mode;                                                   
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_restore_preemption (rtems_mode prev_mode)                 
{                                                                     
4000ca38:	f0 27 a0 44 	st  %i0, [ %fp + 0x44 ]                        
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  sc = rtems_task_mode (prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode); 
4000ca3c:	90 10 00 18 	mov  %i0, %o0                                  
4000ca40:	94 07 a0 44 	add  %fp, 0x44, %o2                            
4000ca44:	40 00 12 3e 	call  4001133c <rtems_task_mode>               
4000ca48:	92 12 63 ff 	or  %o1, 0x3ff, %o1                            
  if (sc != RTEMS_SUCCESSFUL)                                         
4000ca4c:	80 a2 20 00 	cmp  %o0, 0                                    
4000ca50:	12 80 00 04 	bne  4000ca60 <rtems_bdbuf_restore_preemption+0x30><== NEVER TAKEN
4000ca54:	01 00 00 00 	nop                                            
4000ca58:	81 c7 e0 08 	ret                                            
4000ca5c:	81 e8 00 00 	restore                                        
    rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_PREEMPT_RST);                
4000ca60:	7f ff ff ab 	call  4000c90c <rtems_bdbuf_fatal>             <== NOT EXECUTED
4000ca64:	90 10 20 06 	mov  6, %o0                                    <== NOT EXECUTED
                                                                      

4000ef4c <rtems_bdbuf_set_block_size>: rtems_status_code rtems_bdbuf_set_block_size (rtems_disk_device *dd, uint32_t block_size, bool sync) {
4000ef4c:	9d e3 bf a0 	save  %sp, -96, %sp                            
                                                                      
  /*                                                                  
   * We do not care about the synchronization status since we will purge the
   * device later.                                                    
   */                                                                 
  if (sync)                                                           
4000ef50:	80 a6 a0 00 	cmp  %i2, 0                                    
4000ef54:	12 80 00 43 	bne  4000f060 <rtems_bdbuf_set_block_size+0x114>
4000ef58:	01 00 00 00 	nop                                            
    rtems_bdbuf_syncdev (dd);                                         
                                                                      
  rtems_bdbuf_lock_cache ();                                          
4000ef5c:	7f ff f6 7e 	call  4000c954 <rtems_bdbuf_lock_cache>        
4000ef60:	b8 10 20 0a 	mov  0xa, %i4	! a <PROM_START+0xa>             
                                                                      
  if (block_size > 0)                                                 
4000ef64:	80 a6 60 00 	cmp  %i1, 0                                    
4000ef68:	12 80 00 06 	bne  4000ef80 <rtems_bdbuf_set_block_size+0x34>
4000ef6c:	03 10 00 65 	sethi  %hi(0x40019400), %g1                    
  else                                                                
  {                                                                   
    sc = RTEMS_INVALID_NUMBER;                                        
  }                                                                   
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
4000ef70:	7f ff f6 8f 	call  4000c9ac <rtems_bdbuf_unlock_cache>      
4000ef74:	b0 10 00 1c 	mov  %i4, %i0                                  
                                                                      
  return sc;                                                          
}                                                                     
4000ef78:	81 c7 e0 08 	ret                                            
4000ef7c:	81 e8 00 00 	restore                                        
rtems_bdbuf_bds_per_group (size_t size)                               
{                                                                     
  size_t bufs_per_size;                                               
  size_t bds_per_size;                                                
                                                                      
  if (size > bdbuf_config.buffer_max)                                 
4000ef80:	82 10 62 08 	or  %g1, 0x208, %g1                            
4000ef84:	c4 00 60 28 	ld  [ %g1 + 0x28 ], %g2                        
4000ef88:	80 a6 40 02 	cmp  %i1, %g2                                  
4000ef8c:	18 bf ff f9 	bgu  4000ef70 <rtems_bdbuf_set_block_size+0x24><== NEVER TAKEN
4000ef90:	01 00 00 00 	nop                                            
    return 0;                                                         
                                                                      
  bufs_per_size = ((size - 1) / bdbuf_config.buffer_min) + 1;         
4000ef94:	d2 00 60 24 	ld  [ %g1 + 0x24 ], %o1                        
4000ef98:	40 00 21 28 	call  40017438 <.udiv>                         
4000ef9c:	90 06 7f ff 	add  %i1, -1, %o0                              
4000efa0:	90 02 20 01 	inc  %o0                                       
                                                                      
  for (bds_per_size = 1;                                              
4000efa4:	80 a2 20 01 	cmp  %o0, 1                                    
4000efa8:	08 80 00 06 	bleu  4000efc0 <rtems_bdbuf_set_block_size+0x74>
4000efac:	92 10 20 01 	mov  1, %o1                                    
       bds_per_size < bufs_per_size;                                  
       bds_per_size <<= 1)                                            
4000efb0:	93 2a 60 01 	sll  %o1, 1, %o1                               
  if (size > bdbuf_config.buffer_max)                                 
    return 0;                                                         
                                                                      
  bufs_per_size = ((size - 1) / bdbuf_config.buffer_min) + 1;         
                                                                      
  for (bds_per_size = 1;                                              
4000efb4:	80 a2 00 09 	cmp  %o0, %o1                                  
4000efb8:	38 bf ff ff 	bgu,a   4000efb4 <rtems_bdbuf_set_block_size+0x68>
4000efbc:	93 2a 60 01 	sll  %o1, 1, %o1                               
       bds_per_size < bufs_per_size;                                  
       bds_per_size <<= 1)                                            
    ;                                                                 
                                                                      
  return bdbuf_cache.max_bds_per_group / bds_per_size;                
4000efc0:	03 10 00 6b 	sethi  %hi(0x4001ac00), %g1                    
4000efc4:	d0 00 63 54 	ld  [ %g1 + 0x354 ], %o0	! 4001af54 <bdbuf_cache+0x20>
4000efc8:	40 00 21 1c 	call  40017438 <.udiv>                         
4000efcc:	b8 10 20 0a 	mov  0xa, %i4                                  
                                                                      
  if (block_size > 0)                                                 
  {                                                                   
    size_t bds_per_group = rtems_bdbuf_bds_per_group (block_size);    
                                                                      
    if (bds_per_group != 0)                                           
4000efd0:	80 a2 20 00 	cmp  %o0, 0                                    
4000efd4:	02 bf ff e7 	be  4000ef70 <rtems_bdbuf_set_block_size+0x24> <== NEVER TAKEN
4000efd8:	b4 10 00 08 	mov  %o0, %i2                                  
    {                                                                 
      int block_to_media_block_shift = 0;                             
      uint32_t media_blocks_per_block = block_size / dd->media_block_size;
4000efdc:	f8 06 20 20 	ld  [ %i0 + 0x20 ], %i4                        
4000efe0:	90 10 00 19 	mov  %i1, %o0                                  
4000efe4:	92 10 00 1c 	mov  %i4, %o1                                  
4000efe8:	40 00 21 14 	call  40017438 <.udiv>                         
4000efec:	ba 10 20 00 	clr  %i5                                       
      uint32_t one = 1;                                               
                                                                      
      while ((one << block_to_media_block_shift) < media_blocks_per_block)
4000eff0:	80 a2 20 01 	cmp  %o0, 1                                    
4000eff4:	08 80 00 08 	bleu  4000f014 <rtems_bdbuf_set_block_size+0xc8>
4000eff8:	b6 10 00 08 	mov  %o0, %i3                                  
4000effc:	84 10 20 01 	mov  1, %g2                                    
      {                                                               
        ++block_to_media_block_shift;                                 
4000f000:	ba 07 60 01 	inc  %i5                                       
    {                                                                 
      int block_to_media_block_shift = 0;                             
      uint32_t media_blocks_per_block = block_size / dd->media_block_size;
      uint32_t one = 1;                                               
                                                                      
      while ((one << block_to_media_block_shift) < media_blocks_per_block)
4000f004:	83 28 80 1d 	sll  %g2, %i5, %g1                             
4000f008:	80 a6 c0 01 	cmp  %i3, %g1                                  
4000f00c:	38 bf ff fe 	bgu,a   4000f004 <rtems_bdbuf_set_block_size+0xb8>
4000f010:	ba 07 60 01 	inc  %i5                                       
      {                                                               
        ++block_to_media_block_shift;                                 
      }                                                               
                                                                      
      if ((dd->media_block_size << block_to_media_block_shift) != block_size)
4000f014:	b9 2f 00 1d 	sll  %i4, %i5, %i4                             
4000f018:	80 a7 00 19 	cmp  %i4, %i1                                  
4000f01c:	32 80 00 02 	bne,a   4000f024 <rtems_bdbuf_set_block_size+0xd8><== NEVER TAKEN
4000f020:	ba 10 3f ff 	mov  -1, %i5                                   <== NOT EXECUTED
        block_to_media_block_shift = -1;                              
                                                                      
      dd->block_size = block_size;                                    
      dd->block_count = dd->size / media_blocks_per_block;            
4000f024:	d0 06 20 1c 	ld  [ %i0 + 0x1c ], %o0                        
4000f028:	92 10 00 1b 	mov  %i3, %o1                                  
4000f02c:	40 00 21 03 	call  40017438 <.udiv>                         
4000f030:	f2 26 20 24 	st  %i1, [ %i0 + 0x24 ]                        
4000f034:	d0 26 20 28 	st  %o0, [ %i0 + 0x28 ]                        
      dd->media_blocks_per_block = media_blocks_per_block;            
      dd->block_to_media_block_shift = block_to_media_block_shift;    
      dd->bds_per_group = bds_per_group;                              
                                                                      
      rtems_bdbuf_purge_dev (dd);                                     
4000f038:	90 10 00 18 	mov  %i0, %o0                                  
      if ((dd->media_block_size << block_to_media_block_shift) != block_size)
        block_to_media_block_shift = -1;                              
                                                                      
      dd->block_size = block_size;                                    
      dd->block_count = dd->size / media_blocks_per_block;            
      dd->media_blocks_per_block = media_blocks_per_block;            
4000f03c:	f6 26 20 2c 	st  %i3, [ %i0 + 0x2c ]                        
      dd->block_to_media_block_shift = block_to_media_block_shift;    
4000f040:	fa 26 20 30 	st  %i5, [ %i0 + 0x30 ]                        
      dd->bds_per_group = bds_per_group;                              
4000f044:	f4 26 20 34 	st  %i2, [ %i0 + 0x34 ]                        
                                                                      
      rtems_bdbuf_purge_dev (dd);                                     
4000f048:	7f ff ff 43 	call  4000ed54 <rtems_bdbuf_purge_dev>         
4000f04c:	b8 10 20 00 	clr  %i4                                       
  else                                                                
  {                                                                   
    sc = RTEMS_INVALID_NUMBER;                                        
  }                                                                   
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
4000f050:	7f ff f6 57 	call  4000c9ac <rtems_bdbuf_unlock_cache>      
4000f054:	b0 10 00 1c 	mov  %i4, %i0                                  
                                                                      
  return sc;                                                          
}                                                                     
4000f058:	81 c7 e0 08 	ret                                            
4000f05c:	81 e8 00 00 	restore                                        
  /*                                                                  
   * We do not care about the synchronization status since we will purge the
   * device later.                                                    
   */                                                                 
  if (sync)                                                           
    rtems_bdbuf_syncdev (dd);                                         
4000f060:	7f ff ff 26 	call  4000ecf8 <rtems_bdbuf_syncdev>           
4000f064:	90 10 00 18 	mov  %i0, %o0                                  
4000f068:	30 bf ff bd 	b,a   4000ef5c <rtems_bdbuf_set_block_size+0x10>
                                                                      

4000c788 <rtems_bdbuf_swapout_modified_processing>: rtems_chain_control* chain, rtems_chain_control* transfer, bool sync_active, bool update_timers, uint32_t timer_delta) {
4000c788:	9d e3 bf a0 	save  %sp, -96, %sp                            
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(        
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_head( the_chain )->next;                    
4000c78c:	c2 06 40 00 	ld  [ %i1 ], %g1                               
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
4000c790:	b2 06 60 04 	add  %i1, 4, %i1                               
  if (!rtems_chain_is_empty (chain))                                  
4000c794:	80 a0 40 19 	cmp  %g1, %i1                                  
4000c798:	02 80 00 2e 	be  4000c850 <rtems_bdbuf_swapout_modified_processing+0xc8>
4000c79c:	80 a6 e0 00 	cmp  %i3, 0                                    
    node = node->next;                                                
                                                                      
    /*                                                                
     * A sync active with no valid dev means sync all.                
     */                                                               
    if (sync_active && (*dd_ptr == BDBUF_INVALID_DEV))                
4000c7a0:	12 80 00 57 	bne  4000c8fc <rtems_bdbuf_swapout_modified_processing+0x174>
4000c7a4:	9e 10 20 00 	clr  %o7                                       
}                                                                     
                                                                      
static bool                                                           
rtems_bdbuf_has_buffer_waiters (void)                                 
{                                                                     
  return bdbuf_cache.buffer_waiters.count;                            
4000c7a8:	05 10 00 6b 	sethi  %hi(0x4001ac00), %g2                    
4000c7ac:	d8 00 a3 a8 	ld  [ %g2 + 0x3a8 ], %o4	! 4001afa8 <bdbuf_cache+0x74>
4000c7b0:	9e 0b e0 ff 	and  %o7, 0xff, %o7                            
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000c7b4:	96 10 20 09 	mov  9, %o3                                    
       * or someone waits for a buffer written force all the timers to 0.
       *                                                              
       * @note Lots of sync requests will skew this timer. It should be based
       *       on TOD to be accurate. Does it matter ?                
       */                                                             
      if (sync_all || (sync_active && (*dd_ptr == bd->dd))            
4000c7b8:	80 a3 e0 00 	cmp  %o7, 0                                    
4000c7bc:	32 80 00 3b 	bne,a   4000c8a8 <rtems_bdbuf_swapout_modified_processing+0x120>
4000c7c0:	c4 06 00 00 	ld  [ %i0 ], %g2                               
4000c7c4:	80 a6 e0 00 	cmp  %i3, 0                                    
4000c7c8:	02 80 00 07 	be  4000c7e4 <rtems_bdbuf_swapout_modified_processing+0x5c>
4000c7cc:	80 a3 20 00 	cmp  %o4, 0                                    
4000c7d0:	c4 06 00 00 	ld  [ %i0 ], %g2                               
4000c7d4:	c6 00 60 14 	ld  [ %g1 + 0x14 ], %g3                        
4000c7d8:	80 a0 80 03 	cmp  %g2, %g3                                  
4000c7dc:	02 80 00 34 	be  4000c8ac <rtems_bdbuf_swapout_modified_processing+0x124>
4000c7e0:	80 a3 20 00 	cmp  %o4, 0                                    
          || rtems_bdbuf_has_buffer_waiters ())                       
4000c7e4:	32 80 00 31 	bne,a   4000c8a8 <rtems_bdbuf_swapout_modified_processing+0x120>
4000c7e8:	c4 06 00 00 	ld  [ %i0 ], %g2                               
        bd->hold_timer = 0;                                           
                                                                      
      if (bd->hold_timer)                                             
4000c7ec:	c4 00 60 2c 	ld  [ %g1 + 0x2c ], %g2                        
4000c7f0:	80 a0 a0 00 	cmp  %g2, 0                                    
4000c7f4:	02 80 00 0b 	be  4000c820 <rtems_bdbuf_swapout_modified_processing+0x98><== NEVER TAKEN
4000c7f8:	80 a7 20 00 	cmp  %i4, 0                                    
      {                                                               
        if (update_timers)                                            
4000c7fc:	22 80 00 12 	be,a   4000c844 <rtems_bdbuf_swapout_modified_processing+0xbc>
4000c800:	c2 00 40 00 	ld  [ %g1 ], %g1                               
        {                                                             
          if (bd->hold_timer > timer_delta)                           
4000c804:	80 a0 80 1d 	cmp  %g2, %i5                                  
4000c808:	28 80 00 3a 	bleu,a   4000c8f0 <rtems_bdbuf_swapout_modified_processing+0x168>
4000c80c:	c0 20 60 2c 	clr  [ %g1 + 0x2c ]                            
            bd->hold_timer -= timer_delta;                            
4000c810:	84 20 80 1d 	sub  %g2, %i5, %g2                             
          else                                                        
            bd->hold_timer = 0;                                       
        }                                                             
                                                                      
        if (bd->hold_timer)                                           
4000c814:	80 a0 a0 00 	cmp  %g2, 0                                    
4000c818:	12 80 00 0a 	bne  4000c840 <rtems_bdbuf_swapout_modified_processing+0xb8><== ALWAYS TAKEN
4000c81c:	c4 20 60 2c 	st  %g2, [ %g1 + 0x2c ]                        
4000c820:	c4 06 00 00 	ld  [ %i0 ], %g2                               <== NOT EXECUTED
4000c824:	c6 00 60 14 	ld  [ %g1 + 0x14 ], %g3                        <== NOT EXECUTED
      /*                                                              
       * This assumes we can set it to BDBUF_INVALID_DEV which is just an
       * assumption. Cannot use the transfer list being empty the sync dev
       * calls sets the dev to use.                                   
       */                                                             
      if (*dd_ptr == BDBUF_INVALID_DEV)                               
4000c828:	80 a0 a0 00 	cmp  %g2, 0                                    
4000c82c:	22 80 00 24 	be,a   4000c8bc <rtems_bdbuf_swapout_modified_processing+0x134>
4000c830:	84 10 00 03 	mov  %g3, %g2                                  
        *dd_ptr = bd->dd;                                             
                                                                      
      if (bd->dd == *dd_ptr)                                          
4000c834:	80 a0 c0 02 	cmp  %g3, %g2                                  
4000c838:	22 80 00 08 	be,a   4000c858 <rtems_bdbuf_swapout_modified_processing+0xd0><== ALWAYS TAKEN
4000c83c:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
                                                                      
        node = next_node;                                             
      }                                                               
      else                                                            
      {                                                               
        node = node->next;                                            
4000c840:	c2 00 40 00 	ld  [ %g1 ], %g1                               
    if (sync_active && (*dd_ptr == BDBUF_INVALID_DEV))                
      sync_all = true;                                                
    else                                                              
      sync_all = false;                                               
                                                                      
    while (!rtems_chain_is_tail (chain, node))                        
4000c844:	80 a0 40 19 	cmp  %g1, %i1                                  
4000c848:	12 bf ff dd 	bne  4000c7bc <rtems_bdbuf_swapout_modified_processing+0x34>
4000c84c:	80 a3 e0 00 	cmp  %o7, 0                                    
4000c850:	81 c7 e0 08 	ret                                            
4000c854:	81 e8 00 00 	restore                                        
      if (*dd_ptr == BDBUF_INVALID_DEV)                               
        *dd_ptr = bd->dd;                                             
                                                                      
      if (bd->dd == *dd_ptr)                                          
      {                                                               
        rtems_chain_node* next_node = node->next;                     
4000c858:	da 00 40 00 	ld  [ %g1 ], %o5                               
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000c85c:	d6 20 60 20 	st  %o3, [ %g1 + 0x20 ]                        
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
  next->previous = previous;                                          
4000c860:	c4 23 60 04 	st  %g2, [ %o5 + 4 ]                           
  previous->next = next;                                              
4000c864:	da 20 80 00 	st  %o5, [ %g2 ]                               
                                                                      
        rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);       
                                                                      
        rtems_chain_extract_unprotected (node);                       
                                                                      
        tnode = tnode->previous;                                      
4000c868:	c4 06 a0 08 	ld  [ %i2 + 8 ], %g2                           
                                                                      
        while (node && !rtems_chain_is_head (transfer, tnode))        
4000c86c:	80 a0 80 1a 	cmp  %g2, %i2                                  
4000c870:	22 80 00 1a 	be,a   4000c8d8 <rtems_bdbuf_swapout_modified_processing+0x150>
4000c874:	c4 06 80 00 	ld  [ %i2 ], %g2                               
        {                                                             
          rtems_bdbuf_buffer* tbd = (rtems_bdbuf_buffer*) tnode;      
                                                                      
          if (bd->block > tbd->block)                                 
4000c878:	c6 00 a0 18 	ld  [ %g2 + 0x18 ], %g3                        
4000c87c:	c8 00 60 18 	ld  [ %g1 + 0x18 ], %g4                        
4000c880:	80 a1 00 03 	cmp  %g4, %g3                                  
4000c884:	28 80 00 11 	bleu,a   4000c8c8 <rtems_bdbuf_swapout_modified_processing+0x140>
4000c888:	c4 00 a0 04 	ld  [ %g2 + 4 ], %g2                           
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
4000c88c:	c6 00 80 00 	ld  [ %g2 ], %g3                               
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
4000c890:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
4000c894:	c2 20 80 00 	st  %g1, [ %g2 ]                               
  the_node->next        = before_node;                                
4000c898:	c6 20 40 00 	st  %g3, [ %g1 ]                               
  before_node->previous = the_node;                                   
4000c89c:	c2 20 e0 04 	st  %g1, [ %g3 + 4 ]                           
4000c8a0:	10 bf ff e9 	b  4000c844 <rtems_bdbuf_swapout_modified_processing+0xbc>
4000c8a4:	82 10 00 0d 	mov  %o5, %g1                                  
4000c8a8:	c6 00 60 14 	ld  [ %g1 + 0x14 ], %g3                        
      /*                                                              
       * This assumes we can set it to BDBUF_INVALID_DEV which is just an
       * assumption. Cannot use the transfer list being empty the sync dev
       * calls sets the dev to use.                                   
       */                                                             
      if (*dd_ptr == BDBUF_INVALID_DEV)                               
4000c8ac:	80 a0 a0 00 	cmp  %g2, 0                                    
4000c8b0:	12 bf ff e1 	bne  4000c834 <rtems_bdbuf_swapout_modified_processing+0xac>
4000c8b4:	c0 20 60 2c 	clr  [ %g1 + 0x2c ]                            
        *dd_ptr = bd->dd;                                             
4000c8b8:	84 10 00 03 	mov  %g3, %g2                                  
4000c8bc:	c6 26 00 00 	st  %g3, [ %i0 ]                               
4000c8c0:	10 bf ff dd 	b  4000c834 <rtems_bdbuf_swapout_modified_processing+0xac>
4000c8c4:	c6 00 60 14 	ld  [ %g1 + 0x14 ], %g3                        
                                                                      
        rtems_chain_extract_unprotected (node);                       
                                                                      
        tnode = tnode->previous;                                      
                                                                      
        while (node && !rtems_chain_is_head (transfer, tnode))        
4000c8c8:	80 a0 80 1a 	cmp  %g2, %i2                                  
4000c8cc:	32 bf ff ec 	bne,a   4000c87c <rtems_bdbuf_swapout_modified_processing+0xf4>
4000c8d0:	c6 00 a0 18 	ld  [ %g2 + 0x18 ], %g3                        
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
4000c8d4:	c4 06 80 00 	ld  [ %i2 ], %g2                               
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
4000c8d8:	f4 20 60 04 	st  %i2, [ %g1 + 4 ]                           
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
4000c8dc:	c2 26 80 00 	st  %g1, [ %i2 ]                               
  the_node->next        = before_node;                                
4000c8e0:	c4 20 40 00 	st  %g2, [ %g1 ]                               
  before_node->previous = the_node;                                   
4000c8e4:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]                           
4000c8e8:	10 bf ff d7 	b  4000c844 <rtems_bdbuf_swapout_modified_processing+0xbc>
4000c8ec:	82 10 00 0d 	mov  %o5, %g1                                  
4000c8f0:	c4 06 00 00 	ld  [ %i0 ], %g2                               
4000c8f4:	10 bf ff cd 	b  4000c828 <rtems_bdbuf_swapout_modified_processing+0xa0>
4000c8f8:	c6 00 60 14 	ld  [ %g1 + 0x14 ], %g3                        
    node = node->next;                                                
                                                                      
    /*                                                                
     * A sync active with no valid dev means sync all.                
     */                                                               
    if (sync_active && (*dd_ptr == BDBUF_INVALID_DEV))                
4000c8fc:	c4 06 00 00 	ld  [ %i0 ], %g2                               
4000c900:	80 a0 00 02 	cmp  %g0, %g2                                  
4000c904:	10 bf ff a9 	b  4000c7a8 <rtems_bdbuf_swapout_modified_processing+0x20>
4000c908:	9e 60 3f ff 	subx  %g0, -1, %o7                             
                                                                      

4000dca4 <rtems_bdbuf_swapout_task>: * not this. * @return rtems_task Not used. */ static rtems_task rtems_bdbuf_swapout_task (rtems_task_argument arg) {
4000dca4:	9d e3 bf 78 	save  %sp, -136, %sp                           
  rtems_bdbuf_swapout_transfer transfer;                              
  uint32_t                     period_in_ticks;                       
  const uint32_t               period_in_msecs = bdbuf_config.swapout_period;
4000dca8:	23 10 00 65 	sethi  %hi(0x40019400), %l1                    
4000dcac:	a2 14 62 08 	or  %l1, 0x208, %l1	! 40019608 <rtems_bdbuf_configuration>
  uint32_t                     timer_delta;                           
                                                                      
  transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();         
4000dcb0:	7f ff fb b2 	call  4000cb78 <rtems_bdbuf_swapout_writereq_alloc>
4000dcb4:	f6 04 60 0c 	ld  [ %l1 + 0xc ], %i3                         
  transfer.syncing = false;                                           
                                                                      
  /*                                                                  
   * Localise the period.                                             
   */                                                                 
  period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
4000dcb8:	03 10 00 65 	sethi  %hi(0x40019400), %g1                    
4000dcbc:	d2 00 61 cc 	ld  [ %g1 + 0x1cc ], %o1	! 400195cc <Configuration+0xc>
4000dcc0:	83 2e e0 02 	sll  %i3, 2, %g1                               
  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 ();         
4000dcc4:	d0 27 bf fc 	st  %o0, [ %fp + -4 ]                          
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
4000dcc8:	b4 07 bf e8 	add  %fp, -24, %i2                             
4000dccc:	b0 07 bf ec 	add  %fp, -20, %i0                             
  head->previous = NULL;                                              
4000dcd0:	c0 27 bf ec 	clr  [ %fp + -20 ]                             
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
4000dcd4:	f0 27 bf e8 	st  %i0, [ %fp + -24 ]                         
  head->previous = NULL;                                              
  tail->previous = head;                                              
4000dcd8:	f4 27 bf f0 	st  %i2, [ %fp + -16 ]                         
  rtems_chain_initialize_empty (&transfer.bds);                       
  transfer.dd = BDBUF_INVALID_DEV;                                    
4000dcdc:	c0 27 bf f4 	clr  [ %fp + -12 ]                             
  transfer.syncing = false;                                           
4000dce0:	c0 2f bf f8 	clrb  [ %fp + -8 ]                             
                                                                      
  /*                                                                  
   * Localise the period.                                             
   */                                                                 
  period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
4000dce4:	91 2e e0 07 	sll  %i3, 7, %o0                               
4000dce8:	90 22 00 01 	sub  %o0, %g1, %o0                             
4000dcec:	90 02 00 1b 	add  %o0, %i3, %o0                             
4000dcf0:	40 00 25 d2 	call  40017438 <.udiv>                         
4000dcf4:	91 2a 20 03 	sll  %o0, 3, %o0                               
rtems_bdbuf_swapout_workers_open (void)                               
{                                                                     
  rtems_status_code sc;                                               
  size_t            w;                                                
                                                                      
  rtems_bdbuf_lock_cache ();                                          
4000dcf8:	7f ff fb 17 	call  4000c954 <rtems_bdbuf_lock_cache>        
4000dcfc:	ac 10 00 08 	mov  %o0, %l6                                  
                                                                      
  for (w = 0; w < bdbuf_config.swapout_workers; w++)                  
4000dd00:	c2 04 60 14 	ld  [ %l1 + 0x14 ], %g1                        
 * @param arg A pointer to the global cache data. Use the global variable and
 *            not this.                                               
 * @return rtems_task Not used.                                       
 */                                                                   
static rtems_task                                                     
rtems_bdbuf_swapout_task (rtems_task_argument arg)                    
4000dd04:	b2 10 20 61 	mov  0x61, %i1                                 
  rtems_status_code sc;                                               
  size_t            w;                                                
                                                                      
  rtems_bdbuf_lock_cache ();                                          
                                                                      
  for (w = 0; w < bdbuf_config.swapout_workers; w++)                  
4000dd08:	80 a0 60 00 	cmp  %g1, 0                                    
4000dd0c:	02 80 00 c3 	be  4000e018 <rtems_bdbuf_swapout_task+0x374>  <== ALWAYS TAKEN
4000dd10:	a4 00 60 61 	add  %g1, 0x61, %l2                            
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
4000dd14:	21 10 00 6b 	sethi  %hi(0x4001ac00), %l0                    <== NOT EXECUTED
    worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
                                                                      
    rtems_chain_initialize_empty (&worker->transfer.bds);             
    worker->transfer.dd = BDBUF_INVALID_DEV;                          
                                                                      
    sc = rtems_bdbuf_create_task (rtems_build_name('B', 'D', 'o', 'a' + w),
4000dd18:	29 10 91 1b 	sethi  %hi(0x42446c00), %l4                    <== NOT EXECUTED
4000dd1c:	a0 14 23 34 	or  %l0, 0x334, %l0                            <== NOT EXECUTED
4000dd20:	27 10 00 38 	sethi  %hi(0x4000e000), %l3                    <== NOT EXECUTED
                                                                      
  the_node->next = tail;                                              
4000dd24:	ae 04 20 0c 	add  %l0, 0xc, %l7                             <== NOT EXECUTED
    worker = malloc (sizeof (rtems_bdbuf_swapout_worker));            
    if (!worker)                                                      
      rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_NOMEM);              
                                                                      
    rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
    worker->enabled = true;                                           
4000dd28:	aa 10 20 01 	mov  1, %l5                                    <== NOT EXECUTED
    worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
                                                                      
    rtems_chain_initialize_empty (&worker->transfer.bds);             
    worker->transfer.dd = BDBUF_INVALID_DEV;                          
                                                                      
    sc = rtems_bdbuf_create_task (rtems_build_name('B', 'D', 'o', 'a' + w),
4000dd2c:	a8 15 23 00 	or  %l4, 0x300, %l4                            <== NOT EXECUTED
4000dd30:	a6 14 e0 38 	or  %l3, 0x38, %l3                             <== NOT EXECUTED
                                                                      
  for (w = 0; w < bdbuf_config.swapout_workers; w++)                  
  {                                                                   
    rtems_bdbuf_swapout_worker* worker;                               
                                                                      
    worker = malloc (sizeof (rtems_bdbuf_swapout_worker));            
4000dd34:	7f ff da 0f 	call  40004570 <malloc>                        <== NOT EXECUTED
4000dd38:	90 10 20 28 	mov  0x28, %o0                                 <== NOT EXECUTED
    if (!worker)                                                      
4000dd3c:	ba 92 20 00 	orcc  %o0, 0, %i5                              <== NOT EXECUTED
4000dd40:	02 80 00 bb 	be  4000e02c <rtems_bdbuf_swapout_task+0x388>  <== NOT EXECUTED
4000dd44:	01 00 00 00 	nop                                            <== NOT EXECUTED
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
4000dd48:	c2 04 20 10 	ld  [ %l0 + 0x10 ], %g1                        <== NOT EXECUTED
                                                                      
  the_node->next = tail;                                              
4000dd4c:	ee 27 40 00 	st  %l7, [ %i5 ]                               <== NOT EXECUTED
  tail->previous = the_node;                                          
  old_last->next = the_node;                                          
4000dd50:	fa 20 40 00 	st  %i5, [ %g1 ]                               <== NOT EXECUTED
  the_node->previous = old_last;                                      
4000dd54:	c2 27 60 04 	st  %g1, [ %i5 + 4 ]                           <== NOT EXECUTED
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
                                                                      
  the_node->next = tail;                                              
  tail->previous = the_node;                                          
4000dd58:	fa 24 20 10 	st  %i5, [ %l0 + 0x10 ]                        <== NOT EXECUTED
      rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_NOMEM);              
                                                                      
    rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
    worker->enabled = true;                                           
    worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
4000dd5c:	7f ff fb 87 	call  4000cb78 <rtems_bdbuf_swapout_writereq_alloc><== NOT EXECUTED
4000dd60:	ea 2f 60 0c 	stb  %l5, [ %i5 + 0xc ]                        <== NOT EXECUTED
                                                                      
    rtems_chain_initialize_empty (&worker->transfer.bds);             
    worker->transfer.dd = BDBUF_INVALID_DEV;                          
                                                                      
    sc = rtems_bdbuf_create_task (rtems_build_name('B', 'D', 'o', 'a' + w),
4000dd64:	d2 04 60 18 	ld  [ %l1 + 0x18 ], %o1                        <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
4000dd68:	82 07 60 10 	add  %i5, 0x10, %g1                            <== NOT EXECUTED
4000dd6c:	84 07 60 14 	add  %i5, 0x14, %g2                            <== NOT EXECUTED
    if (!worker)                                                      
      rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_NOMEM);              
                                                                      
    rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
    worker->enabled = true;                                           
    worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
4000dd70:	d0 27 60 24 	st  %o0, [ %i5 + 0x24 ]                        <== NOT EXECUTED
                                                                      
    rtems_chain_initialize_empty (&worker->transfer.bds);             
    worker->transfer.dd = BDBUF_INVALID_DEV;                          
                                                                      
    sc = rtems_bdbuf_create_task (rtems_build_name('B', 'D', 'o', 'a' + w),
4000dd74:	96 10 00 1d 	mov  %i5, %o3                                  <== NOT EXECUTED
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
4000dd78:	c0 27 60 14 	clr  [ %i5 + 0x14 ]                            <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
4000dd7c:	c4 27 60 10 	st  %g2, [ %i5 + 0x10 ]                        <== NOT EXECUTED
  head->previous = NULL;                                              
  tail->previous = head;                                              
4000dd80:	c2 27 60 18 	st  %g1, [ %i5 + 0x18 ]                        <== NOT EXECUTED
    rtems_chain_append_unprotected (&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.dd = BDBUF_INVALID_DEV;                          
4000dd84:	c0 27 60 1c 	clr  [ %i5 + 0x1c ]                            <== NOT EXECUTED
                                                                      
    sc = rtems_bdbuf_create_task (rtems_build_name('B', 'D', 'o', 'a' + w),
4000dd88:	90 16 40 14 	or  %i1, %l4, %o0                              <== NOT EXECUTED
4000dd8c:	94 10 00 13 	mov  %l3, %o2                                  <== NOT EXECUTED
4000dd90:	98 07 60 08 	add  %i5, 8, %o4                               <== NOT EXECUTED
4000dd94:	7f ff fb f7 	call  4000cd70 <rtems_bdbuf_create_task.constprop.9><== NOT EXECUTED
4000dd98:	b8 10 00 10 	mov  %l0, %i4                                  <== NOT EXECUTED
                                  bdbuf_config.swapout_worker_priority,
                                  RTEMS_BDBUF_SWAPOUT_WORKER_TASK_PRIORITY_DEFAULT,
                                  rtems_bdbuf_swapout_worker_task,    
                                  (rtems_task_argument) worker,       
                                  &worker->id);                       
    if (sc != RTEMS_SUCCESSFUL)                                       
4000dd9c:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4000dda0:	12 80 00 a1 	bne  4000e024 <rtems_bdbuf_swapout_task+0x380> <== NOT EXECUTED
4000dda4:	b2 06 60 01 	inc  %i1                                       <== NOT EXECUTED
  rtems_status_code sc;                                               
  size_t            w;                                                
                                                                      
  rtems_bdbuf_lock_cache ();                                          
                                                                      
  for (w = 0; w < bdbuf_config.swapout_workers; w++)                  
4000dda8:	80 a6 40 12 	cmp  %i1, %l2                                  <== NOT EXECUTED
4000ddac:	12 bf ff e2 	bne  4000dd34 <rtems_bdbuf_swapout_task+0x90>  <== NOT EXECUTED
4000ddb0:	01 00 00 00 	nop                                            <== NOT EXECUTED
                                  &worker->id);                       
    if (sc != RTEMS_SUCCESSFUL)                                       
      rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_CREATE);             
  }                                                                   
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
4000ddb4:	7f ff fa fe 	call  4000c9ac <rtems_bdbuf_unlock_cache>      
4000ddb8:	01 00 00 00 	nop                                            
  /*                                                                  
   * Create the worker threads.                                       
   */                                                                 
  rtems_bdbuf_swapout_workers_open ();                                
                                                                      
  while (bdbuf_cache.swapout_enabled)                                 
4000ddbc:	c2 0f 20 04 	ldub  [ %i4 + 4 ], %g1                         
4000ddc0:	80 a0 60 00 	cmp  %g1, 0                                    
4000ddc4:	02 80 00 75 	be  4000df98 <rtems_bdbuf_swapout_task+0x2f4>  <== NEVER TAKEN
4000ddc8:	82 07 20 08 	add  %i4, 8, %g1                               
                                           timer_delta);              
                                                                      
  /*                                                                  
   * Process the cache's modified list.                               
   */                                                                 
  rtems_bdbuf_swapout_modified_processing (&transfer->dd,             
4000ddcc:	a2 07 20 4c 	add  %i4, 0x4c, %l1                            
                                                                      
  /*                                                                  
   * 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->dd,             
4000ddd0:	aa 07 20 58 	add  %i4, 0x58, %l5                            
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(              
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  if ( !_Chain_Is_empty(the_chain))                                   
4000ddd4:	a8 07 20 0c 	add  %i4, 0xc, %l4                             
                                           timer_delta);              
                                                                      
  /*                                                                  
   * Process the cache's modified list.                               
   */                                                                 
  rtems_bdbuf_swapout_modified_processing (&transfer->dd,             
4000ddd8:	e2 27 bf dc 	st  %l1, [ %fp + -36 ]                         
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *old_first = head->next;                                 
  Chain_Node *new_first = old_first->next;                            
                                                                      
  head->next = new_first;                                             
  new_first->previous = head;                                         
4000dddc:	c2 27 bf d8 	st  %g1, [ %fp + -40 ]                         
 * @param arg A pointer to the global cache data. Use the global variable and
 *            not this.                                               
 * @return rtems_task Not used.                                       
 */                                                                   
static rtems_task                                                     
rtems_bdbuf_swapout_task (rtems_task_argument arg)                    
4000dde0:	b2 10 20 01 	mov  1, %i1                                    
      transfer = &worker->transfer;                                   
  }                                                                   
                                                                      
  rtems_chain_initialize_empty (&transfer->bds);                      
  transfer->dd = BDBUF_INVALID_DEV;                                   
  transfer->syncing = bdbuf_cache.sync_active;                        
4000dde4:	a0 10 20 01 	mov  1, %l0                                    
                                rtems_bdbuf_swapout_transfer* transfer)
{                                                                     
  rtems_bdbuf_swapout_worker* worker;                                 
  bool                        transfered_buffers = false;             
                                                                      
  rtems_bdbuf_lock_cache ();                                          
4000dde8:	7f ff fa db 	call  4000c954 <rtems_bdbuf_lock_cache>        
4000ddec:	01 00 00 00 	nop                                            
   * 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)                                        
4000ddf0:	c2 0f 20 30 	ldub  [ %i4 + 0x30 ], %g1                      
4000ddf4:	80 a0 60 00 	cmp  %g1, 0                                    
4000ddf8:	32 80 00 2f 	bne,a   4000deb4 <rtems_bdbuf_swapout_task+0x210>
4000ddfc:	c2 07 20 38 	ld  [ %i4 + 0x38 ], %g1                        
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(        
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_head( the_chain )->next;                    
4000de00:	e6 07 20 08 	ld  [ %i4 + 8 ], %l3                           
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(              
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  if ( !_Chain_Is_empty(the_chain))                                   
4000de04:	80 a4 c0 14 	cmp  %l3, %l4                                  
4000de08:	02 80 00 7b 	be  4000dff4 <rtems_bdbuf_swapout_task+0x350>  <== ALWAYS TAKEN
4000de0c:	c2 07 bf d8 	ld  [ %fp + -40 ], %g1                         
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *old_first = head->next;                                 
  Chain_Node *new_first = old_first->next;                            
4000de10:	c4 04 c0 00 	ld  [ %l3 ], %g2                               <== NOT EXECUTED
  else                                                                
  {                                                                   
    worker = (rtems_bdbuf_swapout_worker*)                            
      rtems_chain_get_unprotected (&bdbuf_cache.swapout_workers);     
    if (worker)                                                       
      transfer = &worker->transfer;                                   
4000de14:	ba 04 e0 10 	add  %l3, 0x10, %i5                            <== NOT EXECUTED
                                                                      
  head->next = new_first;                                             
4000de18:	c4 27 20 08 	st  %g2, [ %i4 + 8 ]                           <== NOT EXECUTED
  new_first->previous = head;                                         
4000de1c:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]                           <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
4000de20:	ae 07 60 04 	add  %i5, 4, %l7                               
                                                                      
  /*                                                                  
   * 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->dd,             
4000de24:	a4 07 60 0c 	add  %i5, 0xc, %l2                             
4000de28:	96 10 20 01 	mov  1, %o3                                    
4000de2c:	98 10 20 00 	clr  %o4                                       
4000de30:	9a 10 00 1b 	mov  %i3, %o5                                  
4000de34:	90 10 00 12 	mov  %l2, %o0                                  
4000de38:	94 10 00 1d 	mov  %i5, %o2                                  
                                                                      
  head->next = tail;                                                  
4000de3c:	ee 27 40 00 	st  %l7, [ %i5 ]                               
  head->previous = NULL;                                              
4000de40:	c0 27 60 04 	clr  [ %i5 + 4 ]                               
  tail->previous = head;                                              
4000de44:	fa 27 60 08 	st  %i5, [ %i5 + 8 ]                           
    if (worker)                                                       
      transfer = &worker->transfer;                                   
  }                                                                   
                                                                      
  rtems_chain_initialize_empty (&transfer->bds);                      
  transfer->dd = BDBUF_INVALID_DEV;                                   
4000de48:	c0 27 60 0c 	clr  [ %i5 + 0xc ]                             
  transfer->syncing = bdbuf_cache.sync_active;                        
4000de4c:	c0 2f 60 10 	clrb  [ %i5 + 0x10 ]                           
                                                                      
  /*                                                                  
   * 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->dd,             
4000de50:	13 10 00 6b 	sethi  %hi(0x4001ac00), %o1                    
4000de54:	7f ff fa 4d 	call  4000c788 <rtems_bdbuf_swapout_modified_processing>
4000de58:	92 12 63 8c 	or  %o1, 0x38c, %o1	! 4001af8c <bdbuf_cache+0x58>
                                           timer_delta);              
                                                                      
  /*                                                                  
   * Process the cache's modified list.                               
   */                                                                 
  rtems_bdbuf_swapout_modified_processing (&transfer->dd,             
4000de5c:	d2 07 bf dc 	ld  [ %fp + -36 ], %o1                         
4000de60:	d6 0f 20 30 	ldub  [ %i4 + 0x30 ], %o3                      
4000de64:	90 10 00 12 	mov  %l2, %o0                                  
4000de68:	94 10 00 1d 	mov  %i5, %o2                                  
4000de6c:	98 0e 60 01 	and  %i1, 1, %o4                               
4000de70:	7f ff fa 46 	call  4000c788 <rtems_bdbuf_swapout_modified_processing>
4000de74:	9a 10 00 1b 	mov  %i3, %o5                                  
  /*                                                                  
   * 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 ();                                        
4000de78:	7f ff fa cd 	call  4000c9ac <rtems_bdbuf_unlock_cache>      
4000de7c:	01 00 00 00 	nop                                            
                                                                      
  /*                                                                  
   * If there are buffers to transfer to the media transfer them.     
   */                                                                 
  if (!rtems_chain_is_empty (&transfer->bds))                         
4000de80:	c6 07 40 00 	ld  [ %i5 ], %g3                               
4000de84:	80 a0 c0 17 	cmp  %g3, %l7                                  
4000de88:	02 80 00 28 	be  4000df28 <rtems_bdbuf_swapout_task+0x284>  
4000de8c:	80 a4 e0 00 	cmp  %l3, 0                                    
  {                                                                   
    if (worker)                                                       
4000de90:	02 80 00 22 	be  4000df18 <rtems_bdbuf_swapout_task+0x274>  <== ALWAYS TAKEN
4000de94:	01 00 00 00 	nop                                            
    {                                                                 
      rtems_status_code sc = rtems_event_send (worker->id,            
4000de98:	d0 04 e0 08 	ld  [ %l3 + 8 ], %o0                           <== NOT EXECUTED
4000de9c:	7f ff e8 b2 	call  40008164 <rtems_event_send>              <== NOT EXECUTED
4000dea0:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
                                               RTEMS_BDBUF_SWAPOUT_SYNC);
      if (sc != RTEMS_SUCCESSFUL)                                     
4000dea4:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4000dea8:	12 80 00 56 	bne  4000e000 <rtems_bdbuf_swapout_task+0x35c> <== NOT EXECUTED
4000deac:	b2 10 20 00 	clr  %i1                                       <== NOT EXECUTED
4000deb0:	30 bf ff ce 	b,a   4000dde8 <rtems_bdbuf_swapout_task+0x144><== NOT EXECUTED
                                                                      
  /*                                                                  
   * 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->dd,             
4000deb4:	96 10 20 01 	mov  1, %o3                                    
   * 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->dd = bdbuf_cache.sync_device;                           
4000deb8:	c2 27 bf f4 	st  %g1, [ %fp + -12 ]                         
                                                                      
  /*                                                                  
   * 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->dd,             
4000debc:	98 10 20 00 	clr  %o4                                       
4000dec0:	9a 10 00 1b 	mov  %i3, %o5                                  
4000dec4:	90 07 bf f4 	add  %fp, -12, %o0                             
4000dec8:	92 10 00 15 	mov  %l5, %o1                                  
4000decc:	94 10 00 1a 	mov  %i2, %o2                                  
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
4000ded0:	f0 27 bf e8 	st  %i0, [ %fp + -24 ]                         
  head->previous = NULL;                                              
4000ded4:	c0 27 bf ec 	clr  [ %fp + -20 ]                             
  tail->previous = head;                                              
4000ded8:	f4 27 bf f0 	st  %i2, [ %fp + -16 ]                         
4000dedc:	7f ff fa 2b 	call  4000c788 <rtems_bdbuf_swapout_modified_processing>
4000dee0:	e0 2f bf f8 	stb  %l0, [ %fp + -8 ]                         
                                           timer_delta);              
                                                                      
  /*                                                                  
   * Process the cache's modified list.                               
   */                                                                 
  rtems_bdbuf_swapout_modified_processing (&transfer->dd,             
4000dee4:	d6 0f 20 30 	ldub  [ %i4 + 0x30 ], %o3                      
4000dee8:	90 07 bf f4 	add  %fp, -12, %o0                             
4000deec:	92 10 00 11 	mov  %l1, %o1                                  
4000def0:	94 10 00 1a 	mov  %i2, %o2                                  
4000def4:	98 0e 60 01 	and  %i1, 1, %o4                               
4000def8:	7f ff fa 24 	call  4000c788 <rtems_bdbuf_swapout_modified_processing>
4000defc:	9a 10 00 1b 	mov  %i3, %o5                                  
  /*                                                                  
   * 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 ();                                        
4000df00:	7f ff fa ab 	call  4000c9ac <rtems_bdbuf_unlock_cache>      
4000df04:	01 00 00 00 	nop                                            
                                                                      
  /*                                                                  
   * If there are buffers to transfer to the media transfer them.     
   */                                                                 
  if (!rtems_chain_is_empty (&transfer->bds))                         
4000df08:	c2 07 bf e8 	ld  [ %fp + -24 ], %g1                         
4000df0c:	80 a0 40 18 	cmp  %g1, %i0                                  
4000df10:	02 80 00 06 	be  4000df28 <rtems_bdbuf_swapout_task+0x284>  
4000df14:	ba 10 00 1a 	mov  %i2, %i5                                  
      if (sc != RTEMS_SUCCESSFUL)                                     
        rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WAKE_2);              
    }                                                                 
    else                                                              
    {                                                                 
      rtems_bdbuf_swapout_write (transfer);                           
4000df18:	7f ff ff 09 	call  4000db3c <rtems_bdbuf_swapout_write>     
4000df1c:	90 10 00 1d 	mov  %i5, %o0                                  
4000df20:	10 bf ff b2 	b  4000dde8 <rtems_bdbuf_swapout_task+0x144>   
4000df24:	b2 10 20 00 	clr  %i1                                       
    }                                                                 
                                                                      
    transfered_buffers = true;                                        
  }                                                                   
                                                                      
  if (bdbuf_cache.sync_active && !transfered_buffers)                 
4000df28:	c2 0f 20 30 	ldub  [ %i4 + 0x30 ], %g1                      
4000df2c:	80 a0 60 00 	cmp  %g1, 0                                    
4000df30:	02 80 00 0f 	be  4000df6c <rtems_bdbuf_swapout_task+0x2c8>  
4000df34:	90 10 20 04 	mov  4, %o0                                    
  {                                                                   
    rtems_id sync_requester;                                          
    rtems_bdbuf_lock_cache ();                                        
4000df38:	7f ff fa 87 	call  4000c954 <rtems_bdbuf_lock_cache>        
4000df3c:	01 00 00 00 	nop                                            
    sync_requester = bdbuf_cache.sync_requester;                      
4000df40:	fa 07 20 34 	ld  [ %i4 + 0x34 ], %i5                        
    bdbuf_cache.sync_active = false;                                  
4000df44:	c0 2f 20 30 	clrb  [ %i4 + 0x30 ]                           
    bdbuf_cache.sync_requester = 0;                                   
    rtems_bdbuf_unlock_cache ();                                      
4000df48:	7f ff fa 99 	call  4000c9ac <rtems_bdbuf_unlock_cache>      
4000df4c:	c0 27 20 34 	clr  [ %i4 + 0x34 ]                            
    if (sync_requester)                                               
4000df50:	80 a7 60 00 	cmp  %i5, 0                                    
4000df54:	02 80 00 06 	be  4000df6c <rtems_bdbuf_swapout_task+0x2c8>  <== NEVER TAKEN
4000df58:	90 10 20 04 	mov  4, %o0                                    
 */                                                                   
RTEMS_INLINE_ROUTINE rtems_status_code rtems_event_transient_send(    
  rtems_id id                                                         
)                                                                     
{                                                                     
  return rtems_event_system_send( id, RTEMS_EVENT_SYSTEM_TRANSIENT ); 
4000df5c:	90 10 00 1d 	mov  %i5, %o0                                  
4000df60:	7f ff ea 34 	call  40008830 <rtems_event_system_send>       
4000df64:	13 20 00 00 	sethi  %hi(0x80000000), %o1                    
       */                                                             
      update_timers = false;                                          
    }                                                                 
    while (transfered_buffers);                                       
                                                                      
    sc = rtems_event_receive (RTEMS_BDBUF_SWAPOUT_SYNC,               
4000df68:	90 10 20 04 	mov  4, %o0                                    
4000df6c:	92 10 20 00 	clr  %o1                                       
4000df70:	94 10 00 16 	mov  %l6, %o2                                  
4000df74:	7f ff e8 18 	call  40007fd4 <rtems_event_receive>           
4000df78:	96 07 bf e4 	add  %fp, -28, %o3                             
                              RTEMS_EVENT_ALL | RTEMS_WAIT,           
                              period_in_ticks,                        
                              &out);                                  
                                                                      
    if ((sc != RTEMS_SUCCESSFUL) && (sc != RTEMS_TIMEOUT))            
4000df7c:	80 a2 20 06 	cmp  %o0, 6                                    
4000df80:	12 80 00 22 	bne  4000e008 <rtems_bdbuf_swapout_task+0x364> 
4000df84:	80 a2 20 00 	cmp  %o0, 0                                    
  /*                                                                  
   * Create the worker threads.                                       
   */                                                                 
  rtems_bdbuf_swapout_workers_open ();                                
                                                                      
  while (bdbuf_cache.swapout_enabled)                                 
4000df88:	c2 0f 20 04 	ldub  [ %i4 + 4 ], %g1                         
4000df8c:	80 a0 60 00 	cmp  %g1, 0                                    
4000df90:	12 bf ff 95 	bne  4000dde4 <rtems_bdbuf_swapout_task+0x140> <== ALWAYS TAKEN
4000df94:	b2 10 20 01 	mov  1, %i1                                    
static void                                                           
rtems_bdbuf_swapout_workers_close (void)                              
{                                                                     
  rtems_chain_node* node;                                             
                                                                      
  rtems_bdbuf_lock_cache ();                                          
4000df98:	7f ff fa 6f 	call  4000c954 <rtems_bdbuf_lock_cache>        <== NOT EXECUTED
4000df9c:	01 00 00 00 	nop                                            <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return _Chain_Head( the_chain )->next;                              
4000dfa0:	fa 07 20 08 	ld  [ %i4 + 8 ], %i5                           <== NOT EXECUTED
                                                                      
  node = rtems_chain_first (&bdbuf_cache.swapout_workers);            
  while (!rtems_chain_is_tail (&bdbuf_cache.swapout_workers, node))   
4000dfa4:	b8 07 20 0c 	add  %i4, 0xc, %i4                             <== NOT EXECUTED
4000dfa8:	80 a7 40 1c 	cmp  %i5, %i4                                  <== NOT EXECUTED
4000dfac:	02 80 00 0a 	be  4000dfd4 <rtems_bdbuf_swapout_task+0x330>  <== NOT EXECUTED
4000dfb0:	01 00 00 00 	nop                                            <== NOT EXECUTED
  {                                                                   
    rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) node;
    worker->enabled = false;                                          
    rtems_event_send (worker->id, RTEMS_BDBUF_SWAPOUT_SYNC);          
4000dfb4:	d0 07 60 08 	ld  [ %i5 + 8 ], %o0                           <== 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;                                          
4000dfb8:	c0 2f 60 0c 	clrb  [ %i5 + 0xc ]                            <== NOT EXECUTED
    rtems_event_send (worker->id, RTEMS_BDBUF_SWAPOUT_SYNC);          
4000dfbc:	7f ff e8 6a 	call  40008164 <rtems_event_send>              <== NOT EXECUTED
4000dfc0:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(                         
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  return the_node->next;                                              
4000dfc4:	fa 07 40 00 	ld  [ %i5 ], %i5                               <== NOT EXECUTED
  rtems_chain_node* node;                                             
                                                                      
  rtems_bdbuf_lock_cache ();                                          
                                                                      
  node = rtems_chain_first (&bdbuf_cache.swapout_workers);            
  while (!rtems_chain_is_tail (&bdbuf_cache.swapout_workers, node))   
4000dfc8:	80 a7 40 1c 	cmp  %i5, %i4                                  <== NOT EXECUTED
4000dfcc:	32 bf ff fb 	bne,a   4000dfb8 <rtems_bdbuf_swapout_task+0x314><== NOT EXECUTED
4000dfd0:	d0 07 60 08 	ld  [ %i5 + 8 ], %o0                           <== NOT EXECUTED
    worker->enabled = false;                                          
    rtems_event_send (worker->id, RTEMS_BDBUF_SWAPOUT_SYNC);          
    node = rtems_chain_next (node);                                   
  }                                                                   
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
4000dfd4:	7f ff fa 76 	call  4000c9ac <rtems_bdbuf_unlock_cache>      <== NOT EXECUTED
4000dfd8:	01 00 00 00 	nop                                            <== NOT EXECUTED
      rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SWAPOUT_RE);               
  }                                                                   
                                                                      
  rtems_bdbuf_swapout_workers_close ();                               
                                                                      
  free (transfer.write_req);                                          
4000dfdc:	7f ff d8 1d 	call  40004050 <free>                          <== NOT EXECUTED
4000dfe0:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          <== NOT EXECUTED
                                                                      
  rtems_task_delete (RTEMS_SELF);                                     
4000dfe4:	7f ff ea 71 	call  400089a8 <rtems_task_delete>             <== NOT EXECUTED
4000dfe8:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4000dfec:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000dff0:	81 e8 00 00 	restore                                        <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(              
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  if ( !_Chain_Is_empty(the_chain))                                   
4000dff4:	a6 10 20 00 	clr  %l3                                       
      /*                                                              
       * 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,                
4000dff8:	10 bf ff 8a 	b  4000de20 <rtems_bdbuf_swapout_task+0x17c>   
4000dffc:	ba 10 00 1a 	mov  %i2, %i5                                  
    if (worker)                                                       
    {                                                                 
      rtems_status_code sc = rtems_event_send (worker->id,            
                                               RTEMS_BDBUF_SWAPOUT_SYNC);
      if (sc != RTEMS_SUCCESSFUL)                                     
        rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WAKE_2);              
4000e000:	7f ff fa 43 	call  4000c90c <rtems_bdbuf_fatal>             <== NOT EXECUTED
4000e004:	90 10 20 0c 	mov  0xc, %o0                                  <== NOT EXECUTED
    sc = rtems_event_receive (RTEMS_BDBUF_SWAPOUT_SYNC,               
                              RTEMS_EVENT_ALL | RTEMS_WAIT,           
                              period_in_ticks,                        
                              &out);                                  
                                                                      
    if ((sc != RTEMS_SUCCESSFUL) && (sc != RTEMS_TIMEOUT))            
4000e008:	22 bf ff e1 	be,a   4000df8c <rtems_bdbuf_swapout_task+0x2e8><== ALWAYS TAKEN
4000e00c:	c2 0f 20 04 	ldub  [ %i4 + 4 ], %g1                         
      rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SWAPOUT_RE);               
4000e010:	7f ff fa 3f 	call  4000c90c <rtems_bdbuf_fatal>             <== NOT EXECUTED
4000e014:	90 10 20 18 	mov  0x18, %o0                                 <== NOT EXECUTED
4000e018:	39 10 00 6b 	sethi  %hi(0x4001ac00), %i4                    
4000e01c:	10 bf ff 66 	b  4000ddb4 <rtems_bdbuf_swapout_task+0x110>   
4000e020:	b8 17 23 34 	or  %i4, 0x334, %i4	! 4001af34 <bdbuf_cache>   
                                  RTEMS_BDBUF_SWAPOUT_WORKER_TASK_PRIORITY_DEFAULT,
                                  rtems_bdbuf_swapout_worker_task,    
                                  (rtems_task_argument) worker,       
                                  &worker->id);                       
    if (sc != RTEMS_SUCCESSFUL)                                       
      rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_CREATE);             
4000e024:	7f ff fa 3a 	call  4000c90c <rtems_bdbuf_fatal>             <== NOT EXECUTED
4000e028:	90 10 20 0d 	mov  0xd, %o0                                  <== NOT EXECUTED
  {                                                                   
    rtems_bdbuf_swapout_worker* worker;                               
                                                                      
    worker = malloc (sizeof (rtems_bdbuf_swapout_worker));            
    if (!worker)                                                      
      rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_NOMEM);              
4000e02c:	7f ff fa 38 	call  4000c90c <rtems_bdbuf_fatal>             <== NOT EXECUTED
4000e030:	90 10 20 0a 	mov  0xa, %o0                                  <== NOT EXECUTED
                                                                      

4000e038 <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) {
4000e038:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
  rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) arg;
                                                                      
  while (worker->enabled)                                             
4000e03c:	c2 0e 20 0c 	ldub  [ %i0 + 0xc ], %g1                       <== NOT EXECUTED
4000e040:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4000e044:	02 80 00 1b 	be  4000e0b0 <rtems_bdbuf_swapout_worker_task+0x78><== NOT EXECUTED
4000e048:	ba 10 00 18 	mov  %i0, %i5                                  <== NOT EXECUTED
4000e04c:	39 10 00 6b 	sethi  %hi(0x4001ac00), %i4                    <== NOT EXECUTED
4000e050:	b6 06 20 10 	add  %i0, 0x10, %i3                            <== NOT EXECUTED
4000e054:	b8 17 23 34 	or  %i4, 0x334, %i4                            <== NOT EXECUTED
4000e058:	b2 06 20 14 	add  %i0, 0x14, %i1                            <== NOT EXECUTED
4000e05c:	b4 07 20 0c 	add  %i4, 0xc, %i2                             <== NOT EXECUTED
  {                                                                   
    rtems_bdbuf_wait_for_event (RTEMS_BDBUF_SWAPOUT_SYNC);            
4000e060:	7f ff fa b4 	call  4000cb30 <rtems_bdbuf_wait_for_event>    <== NOT EXECUTED
4000e064:	90 10 20 04 	mov  4, %o0                                    <== NOT EXECUTED
                                                                      
    rtems_bdbuf_swapout_write (&worker->transfer);                    
4000e068:	7f ff fe b5 	call  4000db3c <rtems_bdbuf_swapout_write>     <== NOT EXECUTED
4000e06c:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
                                                                      
    rtems_bdbuf_lock_cache ();                                        
4000e070:	7f ff fa 39 	call  4000c954 <rtems_bdbuf_lock_cache>        <== NOT EXECUTED
4000e074:	01 00 00 00 	nop                                            <== NOT EXECUTED
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
4000e078:	c2 07 20 10 	ld  [ %i4 + 0x10 ], %g1                        <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
4000e07c:	f2 27 60 10 	st  %i1, [ %i5 + 0x10 ]                        <== NOT EXECUTED
                                                                      
    rtems_chain_initialize_empty (&worker->transfer.bds);             
    worker->transfer.dd = BDBUF_INVALID_DEV;                          
4000e080:	c0 27 60 1c 	clr  [ %i5 + 0x1c ]                            <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
                                                                      
  the_node->next = tail;                                              
4000e084:	f4 27 40 00 	st  %i2, [ %i5 ]                               <== NOT EXECUTED
  tail->previous = the_node;                                          
4000e088:	fa 27 20 10 	st  %i5, [ %i4 + 0x10 ]                        <== NOT EXECUTED
  old_last->next = the_node;                                          
4000e08c:	fa 20 40 00 	st  %i5, [ %g1 ]                               <== NOT EXECUTED
  the_node->previous = old_last;                                      
4000e090:	c2 27 60 04 	st  %g1, [ %i5 + 4 ]                           <== NOT EXECUTED
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
4000e094:	c0 27 60 14 	clr  [ %i5 + 0x14 ]                            <== NOT EXECUTED
                                                                      
    rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
                                                                      
    rtems_bdbuf_unlock_cache ();                                      
4000e098:	7f ff fa 45 	call  4000c9ac <rtems_bdbuf_unlock_cache>      <== NOT EXECUTED
4000e09c:	f6 27 60 18 	st  %i3, [ %i5 + 0x18 ]                        <== 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)                                             
4000e0a0:	c2 0f 60 0c 	ldub  [ %i5 + 0xc ], %g1                       <== NOT EXECUTED
4000e0a4:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4000e0a8:	12 bf ff ee 	bne  4000e060 <rtems_bdbuf_swapout_worker_task+0x28><== NOT EXECUTED
4000e0ac:	01 00 00 00 	nop                                            <== NOT EXECUTED
    rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
                                                                      
    rtems_bdbuf_unlock_cache ();                                      
  }                                                                   
                                                                      
  free (worker->transfer.write_req);                                  
4000e0b0:	d0 07 60 24 	ld  [ %i5 + 0x24 ], %o0                        <== NOT EXECUTED
4000e0b4:	7f ff d7 e7 	call  40004050 <free>                          <== NOT EXECUTED
4000e0b8:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
  free (worker);                                                      
4000e0bc:	7f ff d7 e5 	call  40004050 <free>                          <== NOT EXECUTED
4000e0c0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
                                                                      
  rtems_task_delete (RTEMS_SELF);                                     
4000e0c4:	7f ff ea 39 	call  400089a8 <rtems_task_delete>             <== NOT EXECUTED
4000e0c8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4000db3c <rtems_bdbuf_swapout_write>: * * @param transfer The transfer transaction. */ static void rtems_bdbuf_swapout_write (rtems_bdbuf_swapout_transfer* transfer) {
4000db3c:	9d e3 bf a0 	save  %sp, -96, %sp                            
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(        
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_head( the_chain )->next;                    
4000db40:	c2 06 00 00 	ld  [ %i0 ], %g1                               
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
4000db44:	ba 06 20 04 	add  %i0, 4, %i5                               
    printf ("bdbuf:swapout transfer: %08x\n", (unsigned) transfer->dd->dev);
                                                                      
  /*                                                                  
   * If there are buffers to transfer to the media transfer them.     
   */                                                                 
  if (!rtems_chain_is_empty (&transfer->bds))                         
4000db48:	80 a0 40 1d 	cmp  %g1, %i5                                  
4000db4c:	02 80 00 4f 	be  4000dc88 <rtems_bdbuf_swapout_write+0x14c> <== NEVER TAKEN
4000db50:	b8 10 20 00 	clr  %i4                                       
     * The last block number used when the driver only supports       
     * continuous blocks in a single request.                         
     */                                                               
    uint32_t last_block = 0;                                          
                                                                      
    rtems_disk_device *dd = transfer->dd;                             
4000db54:	e0 06 20 0c 	ld  [ %i0 + 0xc ], %l0                         
     * 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;              
4000db58:	d2 06 20 14 	ld  [ %i0 + 0x14 ], %o1                        
    uint32_t last_block = 0;                                          
                                                                      
    rtems_disk_device *dd = transfer->dd;                             
    uint32_t media_blocks_per_block = dd->media_blocks_per_block;     
    bool need_continuous_blocks =                                     
      (dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) != 0;
4000db5c:	c4 04 20 08 	ld  [ %l0 + 8 ], %g2                           
     * continuous blocks in a single request.                         
     */                                                               
    uint32_t last_block = 0;                                          
                                                                      
    rtems_disk_device *dd = transfer->dd;                             
    uint32_t media_blocks_per_block = dd->media_blocks_per_block;     
4000db60:	f4 04 20 2c 	ld  [ %l0 + 0x2c ], %i2                        
    bool need_continuous_blocks =                                     
      (dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) != 0;
4000db64:	e2 00 a0 0c 	ld  [ %g2 + 0xc ], %l1                         
     * 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;              
4000db68:	84 10 20 0c 	mov  0xc, %g2                                  
    uint32_t last_block = 0;                                          
                                                                      
    rtems_disk_device *dd = transfer->dd;                             
    uint32_t media_blocks_per_block = dd->media_blocks_per_block;     
    bool need_continuous_blocks =                                     
      (dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) != 0;
4000db6c:	a2 0c 60 01 	and  %l1, 1, %l1                               
     * 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;              
4000db70:	c4 22 60 0c 	st  %g2, [ %o1 + 0xc ]                         
    transfer->write_req->bufnum = 0;                                  
4000db74:	c0 22 60 10 	clr  [ %o1 + 0x10 ]                            
                                                                      
      if (write)                                                      
      {                                                               
        rtems_bdbuf_execute_transfer_request (dd, transfer->write_req, false);
                                                                      
        transfer->write_req->status = RTEMS_RESOURCE_IN_USE;          
4000db78:	b6 10 20 0c 	mov  0xc, %i3                                  
       * 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))
4000db7c:	10 80 00 23 	b  4000dc08 <rtems_bdbuf_swapout_write+0xcc>   
4000db80:	25 10 00 65 	sethi  %hi(0x40019400), %l2                    
4000db84:	c6 00 60 18 	ld  [ %g1 + 0x18 ], %g3                        
        write = true;                                                 
      }                                                               
      else                                                            
      {                                                               
        rtems_blkdev_sg_buffer* buf;                                  
        buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
4000db88:	c8 02 60 10 	ld  [ %o1 + 0x10 ], %g4                        
        transfer->write_req->bufnum++;                                
        buf->user   = bd;                                             
        buf->block  = bd->block;                                      
        buf->length = dd->block_size;                                 
        buf->buffer = bd->buffer;                                     
4000db8c:	f2 00 60 1c 	ld  [ %g1 + 0x1c ], %i1                        
        rtems_blkdev_sg_buffer* buf;                                  
        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;                                 
4000db90:	de 04 20 24 	ld  [ %l0 + 0x24 ], %o7                        
      }                                                               
      else                                                            
      {                                                               
        rtems_blkdev_sg_buffer* buf;                                  
        buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
        transfer->write_req->bufnum++;                                
4000db94:	b8 01 20 01 	add  %g4, 1, %i4                               
4000db98:	f8 22 60 10 	st  %i4, [ %o1 + 0x10 ]                        
        write = true;                                                 
      }                                                               
      else                                                            
      {                                                               
        rtems_blkdev_sg_buffer* buf;                                  
        buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
4000db9c:	89 29 20 04 	sll  %g4, 4, %g4                               
        transfer->write_req->bufnum++;                                
        buf->user   = bd;                                             
        buf->block  = bd->block;                                      
4000dba0:	b8 10 00 03 	mov  %g3, %i4                                  
        write = true;                                                 
      }                                                               
      else                                                            
      {                                                               
        rtems_blkdev_sg_buffer* buf;                                  
        buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
4000dba4:	88 01 20 18 	add  %g4, 0x18, %g4                            
    transfer->write_req->bufnum = 0;                                  
                                                                      
    while ((node = rtems_chain_get_unprotected(&transfer->bds)) != NULL)
    {                                                                 
      rtems_bdbuf_buffer* bd = (rtems_bdbuf_buffer*) node;            
      bool                write = false;                              
4000dba8:	9a 10 20 00 	clr  %o5                                       
        write = true;                                                 
      }                                                               
      else                                                            
      {                                                               
        rtems_blkdev_sg_buffer* buf;                                  
        buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
4000dbac:	86 02 40 04 	add  %o1, %g4, %g3                             
        transfer->write_req->bufnum++;                                
        buf->user   = bd;                                             
        buf->block  = bd->block;                                      
4000dbb0:	f8 22 40 04 	st  %i4, [ %o1 + %g4 ]                         
      else                                                            
      {                                                               
        rtems_blkdev_sg_buffer* buf;                                  
        buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
        transfer->write_req->bufnum++;                                
        buf->user   = bd;                                             
4000dbb4:	c2 20 e0 0c 	st  %g1, [ %g3 + 0xc ]                         
        buf->block  = bd->block;                                      
        buf->length = dd->block_size;                                 
4000dbb8:	de 20 e0 04 	st  %o7, [ %g3 + 4 ]                           
        buf->buffer = bd->buffer;                                     
4000dbbc:	f2 20 e0 08 	st  %i1, [ %g3 + 8 ]                           
4000dbc0:	82 10 00 02 	mov  %g2, %g1                                  
      /*                                                              
       * 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) ||                    
4000dbc4:	80 a7 40 01 	cmp  %i5, %g1                                  
4000dbc8:	02 80 00 07 	be  4000dbe4 <rtems_bdbuf_swapout_write+0xa8>  
4000dbcc:	84 14 a2 08 	or  %l2, 0x208, %g2                            
4000dbd0:	c6 02 60 10 	ld  [ %o1 + 0x10 ], %g3                        
4000dbd4:	c4 00 a0 04 	ld  [ %g2 + 4 ], %g2                           
4000dbd8:	80 a0 c0 02 	cmp  %g3, %g2                                  
4000dbdc:	0a 80 00 1e 	bcs  4000dc54 <rtems_bdbuf_swapout_write+0x118>
4000dbe0:	80 8b 60 ff 	btst  0xff, %o5                                
          (transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
        write = true;                                                 
                                                                      
      if (write)                                                      
      {                                                               
        rtems_bdbuf_execute_transfer_request (dd, transfer->write_req, false);
4000dbe4:	90 10 00 10 	mov  %l0, %o0                                  
4000dbe8:	7f ff ff 5d 	call  4000d95c <rtems_bdbuf_execute_transfer_request>
4000dbec:	94 10 20 00 	clr  %o2                                       
                                                                      
        transfer->write_req->status = RTEMS_RESOURCE_IN_USE;          
4000dbf0:	d2 06 20 14 	ld  [ %i0 + 0x14 ], %o1                        
4000dbf4:	c2 06 00 00 	ld  [ %i0 ], %g1                               
4000dbf8:	f6 22 60 0c 	st  %i3, [ %o1 + 0xc ]                         
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(              
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  if ( !_Chain_Is_empty(the_chain))                                   
4000dbfc:	80 a7 40 01 	cmp  %i5, %g1                                  
4000dc00:	02 80 00 19 	be  4000dc64 <rtems_bdbuf_swapout_write+0x128> 
4000dc04:	c0 22 60 10 	clr  [ %o1 + 0x10 ]                            
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *old_first = head->next;                                 
  Chain_Node *new_first = old_first->next;                            
4000dc08:	c4 00 40 00 	ld  [ %g1 ], %g2                               
      if (rtems_bdbuf_tracer)                                         
        printf ("bdbuf:swapout write: bd:%" PRIu32 ", bufnum:%" PRIu32 " mode:%s\n",
                bd->block, transfer->write_req->bufnum,               
                need_continuous_blocks ? "MULTI" : "SCAT");           
                                                                      
      if (need_continuous_blocks && transfer->write_req->bufnum &&    
4000dc0c:	80 a4 60 00 	cmp  %l1, 0                                    
                                                                      
  head->next = new_first;                                             
4000dc10:	c4 26 00 00 	st  %g2, [ %i0 ]                               
4000dc14:	02 bf ff dc 	be  4000db84 <rtems_bdbuf_swapout_write+0x48>  
4000dc18:	f0 20 a0 04 	st  %i0, [ %g2 + 4 ]                           
4000dc1c:	c6 02 60 10 	ld  [ %o1 + 0x10 ], %g3                        
4000dc20:	80 a0 e0 00 	cmp  %g3, 0                                    
4000dc24:	02 bf ff d9 	be  4000db88 <rtems_bdbuf_swapout_write+0x4c>  
4000dc28:	c6 00 60 18 	ld  [ %g1 + 0x18 ], %g3                        
          bd->block != last_block + media_blocks_per_block)           
4000dc2c:	88 07 00 1a 	add  %i4, %i2, %g4                             
      if (rtems_bdbuf_tracer)                                         
        printf ("bdbuf:swapout write: bd:%" PRIu32 ", bufnum:%" PRIu32 " mode:%s\n",
                bd->block, transfer->write_req->bufnum,               
                need_continuous_blocks ? "MULTI" : "SCAT");           
                                                                      
      if (need_continuous_blocks && transfer->write_req->bufnum &&    
4000dc30:	80 a0 c0 04 	cmp  %g3, %g4                                  
4000dc34:	02 bf ff d5 	be  4000db88 <rtems_bdbuf_swapout_write+0x4c>  
4000dc38:	9a 10 20 01 	mov  1, %o5                                    
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
4000dc3c:	f0 20 60 04 	st  %i0, [ %g1 + 4 ]                           
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
4000dc40:	c2 26 00 00 	st  %g1, [ %i0 ]                               
  the_node->next        = before_node;                                
4000dc44:	c4 20 40 00 	st  %g2, [ %g1 ]                               
  before_node->previous = the_node;                                   
4000dc48:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]                           
          bd->block != last_block + media_blocks_per_block)           
      {                                                               
        rtems_chain_prepend_unprotected (&transfer->bds, &bd->link);  
        write = true;                                                 
4000dc4c:	10 bf ff de 	b  4000dbc4 <rtems_bdbuf_swapout_write+0x88>   
4000dc50:	c2 06 00 00 	ld  [ %i0 ], %g1                               
                                                                      
      if (rtems_chain_is_empty (&transfer->bds) ||                    
          (transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
        write = true;                                                 
                                                                      
      if (write)                                                      
4000dc54:	12 bf ff e4 	bne  4000dbe4 <rtems_bdbuf_swapout_write+0xa8> 
4000dc58:	80 a7 40 01 	cmp  %i5, %g1                                  
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(              
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  if ( !_Chain_Is_empty(the_chain))                                   
4000dc5c:	32 bf ff ec 	bne,a   4000dc0c <rtems_bdbuf_swapout_write+0xd0><== ALWAYS TAKEN
4000dc60:	c4 00 40 00 	ld  [ %g1 ], %g2                               
                                                                      
    /*                                                                
     * If sync'ing and the deivce is capability of handling a sync IO control
     * call perform the call.                                         
     */                                                               
    if (transfer->syncing &&                                          
4000dc64:	c2 0e 20 10 	ldub  [ %i0 + 0x10 ], %g1                      
4000dc68:	80 a0 60 00 	cmp  %g1, 0                                    
4000dc6c:	02 80 00 0c 	be  4000dc9c <rtems_bdbuf_swapout_write+0x160> 
4000dc70:	01 00 00 00 	nop                                            
        (dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_SYNC))         
4000dc74:	d0 04 20 08 	ld  [ %l0 + 8 ], %o0                           
4000dc78:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
                                                                      
    /*                                                                
     * If sync'ing and the deivce is capability of handling a sync IO control
     * call perform the call.                                         
     */                                                               
    if (transfer->syncing &&                                          
4000dc7c:	80 88 60 02 	btst  2, %g1                                   
4000dc80:	32 80 00 04 	bne,a   4000dc90 <rtems_bdbuf_swapout_write+0x154><== NEVER TAKEN
4000dc84:	c2 04 20 38 	ld  [ %l0 + 0x38 ], %g1                        <== NOT EXECUTED
4000dc88:	81 c7 e0 08 	ret                                            
4000dc8c:	81 e8 00 00 	restore                                        
        (dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_SYNC))         
    {                                                                 
      /* int result = */ dd->ioctl (dd->phys_dev, RTEMS_BLKDEV_REQ_SYNC, NULL);
4000dc90:	92 10 20 02 	mov  2, %o1                                    <== NOT EXECUTED
4000dc94:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
4000dc98:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
4000dc9c:	81 c7 e0 08 	ret                                            
4000dca0:	81 e8 00 00 	restore                                        
                                                                      

4000cb78 <rtems_bdbuf_swapout_writereq_alloc>: * * @return rtems_blkdev_request* The write reference memory. */ static rtems_blkdev_request* rtems_bdbuf_swapout_writereq_alloc (void) {
4000cb78:	9d e3 bf a0 	save  %sp, -96, %sp                            
   * have been a rtems_chain_control. Simple, fast and less storage as the node
   * is already part of the buffer structure.                         
   */                                                                 
  rtems_blkdev_request* write_req =                                   
    malloc (sizeof (rtems_blkdev_request) +                           
            (bdbuf_config.max_write_blocks * sizeof (rtems_blkdev_sg_buffer)));
4000cb7c:	03 10 00 65 	sethi  %hi(0x40019400), %g1                    
4000cb80:	d0 00 62 0c 	ld  [ %g1 + 0x20c ], %o0	! 4001960c <rtems_bdbuf_configuration+0x4>
4000cb84:	91 2a 20 04 	sll  %o0, 4, %o0                               
   * @note chrisj The rtems_blkdev_request and the array at the end is a hack.
   * I am disappointment at finding code like this in RTEMS. The request should
   * have been a rtems_chain_control. Simple, fast and less storage as the node
   * is already part of the buffer structure.                         
   */                                                                 
  rtems_blkdev_request* write_req =                                   
4000cb88:	7f ff de 7a 	call  40004570 <malloc>                        
4000cb8c:	90 02 20 18 	add  %o0, 0x18, %o0                            
    malloc (sizeof (rtems_blkdev_request) +                           
            (bdbuf_config.max_write_blocks * sizeof (rtems_blkdev_sg_buffer)));
                                                                      
  if (!write_req)                                                     
4000cb90:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4000cb94:	02 80 00 0b 	be  4000cbc0 <rtems_bdbuf_swapout_writereq_alloc+0x48><== NEVER TAKEN
4000cb98:	82 10 20 01 	mov  1, %g1                                    
    rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_REQ_NOMEM);               
                                                                      
  write_req->req = RTEMS_BLKDEV_REQ_WRITE;                            
4000cb9c:	c2 27 40 00 	st  %g1, [ %i5 ]                               
  write_req->done = rtems_bdbuf_transfer_done;                        
4000cba0:	03 10 00 38 	sethi  %hi(0x4000e000), %g1                    
4000cba4:	82 10 61 a0 	or  %g1, 0x1a0, %g1	! 4000e1a0 <rtems_bdbuf_transfer_done>
  write_req->io_task = rtems_task_self ();                            
                                                                      
  return write_req;                                                   
}                                                                     
4000cba8:	b0 10 00 1d 	mov  %i5, %i0                                  
  if (!write_req)                                                     
    rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_REQ_NOMEM);               
                                                                      
  write_req->req = RTEMS_BLKDEV_REQ_WRITE;                            
  write_req->done = rtems_bdbuf_transfer_done;                        
  write_req->io_task = rtems_task_self ();                            
4000cbac:	40 00 12 50 	call  400114ec <rtems_task_self>               
4000cbb0:	c2 27 60 04 	st  %g1, [ %i5 + 4 ]                           
4000cbb4:	d0 27 60 14 	st  %o0, [ %i5 + 0x14 ]                        
                                                                      
  return write_req;                                                   
}                                                                     
4000cbb8:	81 c7 e0 08 	ret                                            
4000cbbc:	81 e8 00 00 	restore                                        
  rtems_blkdev_request* write_req =                                   
    malloc (sizeof (rtems_blkdev_request) +                           
            (bdbuf_config.max_write_blocks * sizeof (rtems_blkdev_sg_buffer)));
                                                                      
  if (!write_req)                                                     
    rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_REQ_NOMEM);               
4000cbc0:	7f ff ff 53 	call  4000c90c <rtems_bdbuf_fatal>             <== NOT EXECUTED
4000cbc4:	90 10 20 09 	mov  9, %o0                                    <== NOT EXECUTED
                                                                      

4000ebb0 <rtems_bdbuf_sync>: } rtems_status_code rtems_bdbuf_sync (rtems_bdbuf_buffer *bd) {
4000ebb0:	9d e3 bf a0 	save  %sp, -96, %sp                            
}                                                                     
                                                                      
static rtems_status_code                                              
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{                                                                     
  if (bd == NULL)                                                     
4000ebb4:	80 a6 20 00 	cmp  %i0, 0                                    
4000ebb8:	02 80 00 30 	be  4000ec78 <rtems_bdbuf_sync+0xc8>           <== NEVER TAKEN
4000ebbc:	01 00 00 00 	nop                                            
  if (rtems_bdbuf_tracer)                                             
  {                                                                   
    printf ("bdbuf:%s: %" PRIu32 "\n", kind, bd->block);              
    rtems_bdbuf_show_users (kind, bd);                                
  }                                                                   
  rtems_bdbuf_lock_cache();                                           
4000ebc0:	7f ff f7 65 	call  4000c954 <rtems_bdbuf_lock_cache>        
4000ebc4:	01 00 00 00 	nop                                            
                                                                      
  sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "sync");              
  if (sc != RTEMS_SUCCESSFUL)                                         
    return sc;                                                        
                                                                      
  switch (bd->state)                                                  
4000ebc8:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        
4000ebcc:	80 a2 20 03 	cmp  %o0, 3                                    
4000ebd0:	1a 80 00 04 	bcc  4000ebe0 <rtems_bdbuf_sync+0x30>          <== ALWAYS TAKEN
4000ebd4:	80 a2 20 05 	cmp  %o0, 5                                    
      break;                                                          
    case RTEMS_BDBUF_STATE_ACCESS_PURGED:                             
      rtems_bdbuf_discard_buffer_after_access (bd);                   
      break;                                                          
    default:                                                          
      rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_5);
4000ebd8:	7f ff f7 65 	call  4000c96c <rtems_bdbuf_fatal_with_state>  <== NOT EXECUTED
4000ebdc:	92 10 20 11 	mov  0x11, %o1                                 <== NOT EXECUTED
                                                                      
  sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "sync");              
  if (sc != RTEMS_SUCCESSFUL)                                         
    return sc;                                                        
                                                                      
  switch (bd->state)                                                  
4000ebe0:	08 80 00 0b 	bleu  4000ec0c <rtems_bdbuf_sync+0x5c>         
4000ebe4:	82 10 20 08 	mov  8, %g1                                    
4000ebe8:	80 a2 20 06 	cmp  %o0, 6                                    
4000ebec:	12 bf ff fb 	bne  4000ebd8 <rtems_bdbuf_sync+0x28>          <== NEVER TAKEN
4000ebf0:	01 00 00 00 	nop                                            
    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);                   
4000ebf4:	7f ff f9 7f 	call  4000d1f0 <rtems_bdbuf_discard_buffer_after_access>
4000ebf8:	90 10 00 18 	mov  %i0, %o0                                  
  }                                                                   
                                                                      
  if (rtems_bdbuf_tracer)                                             
    rtems_bdbuf_show_usage ();                                        
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
4000ebfc:	7f ff f7 6c 	call  4000c9ac <rtems_bdbuf_unlock_cache>      
4000ec00:	b0 10 20 00 	clr  %i0                                       
                                                                      
  return RTEMS_SUCCESSFUL;                                            
4000ec04:	81 c7 e0 08 	ret                                            
4000ec08:	81 e8 00 00 	restore                                        
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
4000ec0c:	3b 10 00 6b 	sethi  %hi(0x4001ac00), %i5                    
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000ec10:	c2 26 20 20 	st  %g1, [ %i0 + 0x20 ]                        
4000ec14:	ba 17 63 34 	or  %i5, 0x334, %i5                            
4000ec18:	c2 07 60 60 	ld  [ %i5 + 0x60 ], %g1                        
                                                                      
  the_node->next = tail;                                              
4000ec1c:	84 07 60 5c 	add  %i5, 0x5c, %g2                            
  tail->previous = the_node;                                          
4000ec20:	f0 27 60 60 	st  %i0, [ %i5 + 0x60 ]                        
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
                                                                      
  the_node->next = tail;                                              
4000ec24:	c4 26 00 00 	st  %g2, [ %i0 ]                               
{                                                                     
  rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_SYNC);                 
                                                                      
  rtems_chain_append_unprotected (&bdbuf_cache.sync, &bd->link);      
                                                                      
  if (bd->waiters)                                                    
4000ec28:	c4 06 20 24 	ld  [ %i0 + 0x24 ], %g2                        
  tail->previous = the_node;                                          
  old_last->next = the_node;                                          
  the_node->previous = old_last;                                      
4000ec2c:	c2 26 20 04 	st  %g1, [ %i0 + 4 ]                           
4000ec30:	80 a0 a0 00 	cmp  %g2, 0                                    
4000ec34:	12 80 00 13 	bne  4000ec80 <rtems_bdbuf_sync+0xd0>          
4000ec38:	f0 20 40 00 	st  %i0, [ %g1 ]                               
    rtems_bdbuf_wake (&bdbuf_cache.access_waiters);                   
                                                                      
  rtems_bdbuf_wake_swapper ();                                        
4000ec3c:	7f ff f7 62 	call  4000c9c4 <rtems_bdbuf_wake_swapper>      
4000ec40:	01 00 00 00 	nop                                            
      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);         
4000ec44:	13 10 00 6b 	sethi  %hi(0x4001ac00), %o1                    
4000ec48:	b8 12 63 a0 	or  %o1, 0x3a0, %i4	! 4001afa0 <bdbuf_cache+0x6c>
static void                                                           
rtems_bdbuf_wait_for_sync_done (rtems_bdbuf_buffer *bd)               
{                                                                     
  while (true)                                                        
  {                                                                   
    switch (bd->state)                                                
4000ec4c:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        
4000ec50:	80 a2 20 01 	cmp  %o0, 1                                    
4000ec54:	0a 80 00 07 	bcs  4000ec70 <rtems_bdbuf_sync+0xc0>          <== NEVER TAKEN
4000ec58:	80 a2 20 07 	cmp  %o0, 7                                    
4000ec5c:	28 80 00 10 	bleu,a   4000ec9c <rtems_bdbuf_sync+0xec>      
4000ec60:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
4000ec64:	80 a2 20 0a 	cmp  %o0, 0xa                                  
4000ec68:	28 80 00 09 	bleu,a   4000ec8c <rtems_bdbuf_sync+0xdc>      <== ALWAYS TAKEN
4000ec6c:	90 10 00 18 	mov  %i0, %o0                                  
      case RTEMS_BDBUF_STATE_TRANSFER:                                
      case RTEMS_BDBUF_STATE_TRANSFER_PURGED:                         
        rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);         
        break;                                                        
      default:                                                        
        rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_9);
4000ec70:	7f ff f7 3f 	call  4000c96c <rtems_bdbuf_fatal_with_state>  <== NOT EXECUTED
4000ec74:	92 10 20 15 	mov  0x15, %o1                                 <== NOT EXECUTED
    rtems_bdbuf_show_usage ();                                        
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
4000ec78:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000ec7c:	91 e8 20 09 	restore  %g0, 9, %o0                           <== NOT EXECUTED
  rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_SYNC);                 
                                                                      
  rtems_chain_append_unprotected (&bdbuf_cache.sync, &bd->link);      
                                                                      
  if (bd->waiters)                                                    
    rtems_bdbuf_wake (&bdbuf_cache.access_waiters);                   
4000ec80:	7f ff f7 ec 	call  4000cc30 <rtems_bdbuf_wake>              
4000ec84:	90 07 60 64 	add  %i5, 0x64, %o0                            
4000ec88:	30 bf ff ed 	b,a   4000ec3c <rtems_bdbuf_sync+0x8c>         
      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);         
4000ec8c:	7f ff f7 96 	call  4000cae4 <rtems_bdbuf_wait>              
4000ec90:	92 10 00 1c 	mov  %i4, %o1                                  
static void                                                           
rtems_bdbuf_wait_for_sync_done (rtems_bdbuf_buffer *bd)               
{                                                                     
  while (true)                                                        
  {                                                                   
    switch (bd->state)                                                
4000ec94:	10 bf ff ef 	b  4000ec50 <rtems_bdbuf_sync+0xa0>            
4000ec98:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        
  rtems_bdbuf_wait_for_sync_done (bd);                                
                                                                      
  /*                                                                  
   * We may have created a cached or empty buffer which may be recycled.
   */                                                                 
  if (bd->waiters == 0                                                
4000ec9c:	80 a0 60 00 	cmp  %g1, 0                                    
4000eca0:	12 bf ff d7 	bne  4000ebfc <rtems_bdbuf_sync+0x4c>          
4000eca4:	82 02 3f ff 	add  %o0, -1, %g1                              
        && (bd->state == RTEMS_BDBUF_STATE_CACHED                     
4000eca8:	80 a0 60 01 	cmp  %g1, 1                                    
4000ecac:	18 bf ff d4 	bgu  4000ebfc <rtems_bdbuf_sync+0x4c>          <== NEVER TAKEN
4000ecb0:	80 a2 20 01 	cmp  %o0, 1                                    
          || bd->state == RTEMS_BDBUF_STATE_EMPTY))                   
  {                                                                   
    if (bd->state == RTEMS_BDBUF_STATE_EMPTY)                         
4000ecb4:	02 80 00 06 	be  4000eccc <rtems_bdbuf_sync+0x11c>          
4000ecb8:	01 00 00 00 	nop                                            
    {                                                                 
      rtems_bdbuf_remove_from_tree (bd);                              
      rtems_bdbuf_make_free_and_add_to_lru_list (bd);                 
    }                                                                 
    rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);                   
4000ecbc:	11 10 00 6b 	sethi  %hi(0x4001ac00), %o0                    
4000ecc0:	7f ff f7 dc 	call  4000cc30 <rtems_bdbuf_wake>              
4000ecc4:	90 12 23 a8 	or  %o0, 0x3a8, %o0	! 4001afa8 <bdbuf_cache+0x74>
4000ecc8:	30 bf ff cd 	b,a   4000ebfc <rtems_bdbuf_sync+0x4c>         
        && (bd->state == RTEMS_BDBUF_STATE_CACHED                     
          || bd->state == RTEMS_BDBUF_STATE_EMPTY))                   
  {                                                                   
    if (bd->state == RTEMS_BDBUF_STATE_EMPTY)                         
    {                                                                 
      rtems_bdbuf_remove_from_tree (bd);                              
4000eccc:	7f ff f8 41 	call  4000cdd0 <rtems_bdbuf_remove_from_tree>  
4000ecd0:	90 10 00 18 	mov  %i0, %o0                                  
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
4000ecd4:	c2 07 60 40 	ld  [ %i5 + 0x40 ], %g1                        
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000ecd8:	c0 26 20 20 	clr  [ %i0 + 0x20 ]                            
  after_node->next      = the_node;                                   
4000ecdc:	f0 27 60 40 	st  %i0, [ %i5 + 0x40 ]                        
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
4000ece0:	05 10 00 6b 	sethi  %hi(0x4001ac00), %g2                    
4000ece4:	84 10 a3 74 	or  %g2, 0x374, %g2	! 4001af74 <bdbuf_cache+0x40>
4000ece8:	c4 26 20 04 	st  %g2, [ %i0 + 4 ]                           
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
  the_node->next        = before_node;                                
4000ecec:	c2 26 00 00 	st  %g1, [ %i0 ]                               
  before_node->previous = the_node;                                   
4000ecf0:	10 bf ff f3 	b  4000ecbc <rtems_bdbuf_sync+0x10c>           
4000ecf4:	f0 20 60 04 	st  %i0, [ %g1 + 4 ]                           
                                                                      

4000c980 <rtems_bdbuf_unlock>: * @param lock The mutex to unlock. * @param fatal_error_code The error code if the call fails. */ static void rtems_bdbuf_unlock (rtems_id lock, uint32_t fatal_error_code) {
4000c980:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc = rtems_semaphore_release (lock);              
4000c984:	7f ff ef 80 	call  40008784 <rtems_semaphore_release>       
4000c988:	90 10 00 18 	mov  %i0, %o0                                  
  if (sc != RTEMS_SUCCESSFUL)                                         
4000c98c:	80 a2 20 00 	cmp  %o0, 0                                    
4000c990:	12 80 00 04 	bne  4000c9a0 <rtems_bdbuf_unlock+0x20>        <== NEVER TAKEN
4000c994:	01 00 00 00 	nop                                            
4000c998:	81 c7 e0 08 	ret                                            
4000c99c:	81 e8 00 00 	restore                                        
    rtems_bdbuf_fatal (fatal_error_code);                             
4000c9a0:	7f ff ff db 	call  4000c90c <rtems_bdbuf_fatal>             <== NOT EXECUTED
4000c9a4:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
                                                                      

4000cb30 <rtems_bdbuf_wait_for_event>: return RTEMS_UNSATISFIED; } static void rtems_bdbuf_wait_for_event (rtems_event_set event) {
4000cb30:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_event_set   out = 0;                                          
                                                                      
  sc = rtems_event_receive (event,                                    
4000cb34:	92 10 20 00 	clr  %o1                                       
                                                                      
static void                                                           
rtems_bdbuf_wait_for_event (rtems_event_set event)                    
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_event_set   out = 0;                                          
4000cb38:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
                                                                      
  sc = rtems_event_receive (event,                                    
4000cb3c:	90 10 00 18 	mov  %i0, %o0                                  
4000cb40:	94 10 20 00 	clr  %o2                                       
4000cb44:	7f ff ed 24 	call  40007fd4 <rtems_event_receive>           
4000cb48:	96 07 bf fc 	add  %fp, -4, %o3                              
                            RTEMS_EVENT_ALL | RTEMS_WAIT,             
                            RTEMS_NO_TIMEOUT,                         
                            &out);                                    
                                                                      
  if (sc != RTEMS_SUCCESSFUL || out != event)                         
4000cb4c:	80 a2 20 00 	cmp  %o0, 0                                    
4000cb50:	12 80 00 07 	bne  4000cb6c <rtems_bdbuf_wait_for_event+0x3c><== NEVER TAKEN
4000cb54:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4000cb58:	80 a0 40 18 	cmp  %g1, %i0                                  
4000cb5c:	12 80 00 04 	bne  4000cb6c <rtems_bdbuf_wait_for_event+0x3c><== NEVER TAKEN
4000cb60:	01 00 00 00 	nop                                            
4000cb64:	81 c7 e0 08 	ret                                            
4000cb68:	81 e8 00 00 	restore                                        
    rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_WAIT_EVNT);                  
4000cb6c:	7f ff ff 68 	call  4000c90c <rtems_bdbuf_fatal>             <== NOT EXECUTED
4000cb70:	90 10 20 1c 	mov  0x1c, %o0                                 <== NOT EXECUTED
                                                                      

4000d924 <rtems_bdbuf_wait_for_transient_event>: rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_WAIT_EVNT); } static void rtems_bdbuf_wait_for_transient_event (void) {
4000d924:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_interval ticks                                                
)                                                                     
{                                                                     
  rtems_event_set event_out;                                          
                                                                      
  return rtems_event_system_receive(                                  
4000d928:	11 20 00 00 	sethi  %hi(0x80000000), %o0                    
4000d92c:	92 10 20 00 	clr  %o1                                       
4000d930:	94 10 20 00 	clr  %o2                                       
4000d934:	40 00 0e 5f 	call  400112b0 <rtems_event_system_receive>    
4000d938:	96 07 bf fc 	add  %fp, -4, %o3                              
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  sc = rtems_event_transient_receive (RTEMS_WAIT, RTEMS_NO_TIMEOUT);  
  if (sc != RTEMS_SUCCESSFUL)                                         
4000d93c:	80 a2 20 00 	cmp  %o0, 0                                    
4000d940:	12 80 00 04 	bne  4000d950 <rtems_bdbuf_wait_for_transient_event+0x2c><== NEVER TAKEN
4000d944:	01 00 00 00 	nop                                            
4000d948:	81 c7 e0 08 	ret                                            
4000d94c:	81 e8 00 00 	restore                                        
    rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_WAIT_TRANS_EVNT);            
4000d950:	7f ff fb ef 	call  4000c90c <rtems_bdbuf_fatal>             <== NOT EXECUTED
4000d954:	90 10 20 1d 	mov  0x1d, %o0                                 <== NOT EXECUTED
                                                                      

4000cc30 <rtems_bdbuf_wake>: * 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) {
4000cc30:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  if (waiters->count > 0)                                             
4000cc34:	c2 06 00 00 	ld  [ %i0 ], %g1                               
4000cc38:	80 a0 60 00 	cmp  %g1, 0                                    
4000cc3c:	12 80 00 04 	bne  4000cc4c <rtems_bdbuf_wake+0x1c>          
4000cc40:	01 00 00 00 	nop                                            
4000cc44:	81 c7 e0 08 	ret                                            
4000cc48:	81 e8 00 00 	restore                                        
  {                                                                   
    sc = rtems_semaphore_flush (waiters->sema);                       
4000cc4c:	40 00 11 6c 	call  400111fc <rtems_semaphore_flush>         
4000cc50:	d0 06 20 04 	ld  [ %i0 + 4 ], %o0                           
    if (sc != RTEMS_SUCCESSFUL)                                       
4000cc54:	80 a2 20 00 	cmp  %o0, 0                                    
4000cc58:	02 bf ff fb 	be  4000cc44 <rtems_bdbuf_wake+0x14>           <== ALWAYS TAKEN
4000cc5c:	01 00 00 00 	nop                                            
      rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAKE);               
4000cc60:	7f ff ff 2b 	call  4000c90c <rtems_bdbuf_fatal>             <== NOT EXECUTED
4000cc64:	90 10 20 04 	mov  4, %o0	! 4 <PROM_START+0x4>               <== NOT EXECUTED
                                                                      

4000c9c4 <rtems_bdbuf_wake_swapper>: } } static void rtems_bdbuf_wake_swapper (void) {
4000c9c4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,       
4000c9c8:	03 10 00 6b 	sethi  %hi(0x4001ac00), %g1                    
4000c9cc:	d0 00 63 34 	ld  [ %g1 + 0x334 ], %o0	! 4001af34 <bdbuf_cache>
4000c9d0:	7f ff ed e5 	call  40008164 <rtems_event_send>              
4000c9d4:	92 10 20 04 	mov  4, %o1                                    
                                           RTEMS_BDBUF_SWAPOUT_SYNC); 
  if (sc != RTEMS_SUCCESSFUL)                                         
4000c9d8:	80 a2 20 00 	cmp  %o0, 0                                    
4000c9dc:	12 80 00 04 	bne  4000c9ec <rtems_bdbuf_wake_swapper+0x28>  <== NEVER TAKEN
4000c9e0:	01 00 00 00 	nop                                            
4000c9e4:	81 c7 e0 08 	ret                                            
4000c9e8:	81 e8 00 00 	restore                                        
    rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WAKE_1);                  
4000c9ec:	7f ff ff c8 	call  4000c90c <rtems_bdbuf_fatal>             <== NOT EXECUTED
4000c9f0:	90 10 20 0b 	mov  0xb, %o0                                  <== NOT EXECUTED
                                                                      

4000281c <rtems_bdpart_create>: const rtems_bdpart_format *format, rtems_bdpart_partition *pt, const unsigned *dist, size_t count ) {
4000281c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  bool dos_compatibility = format != NULL                             
    && format->type == RTEMS_BDPART_FORMAT_MBR                        
    && format->mbr.dos_compatibility;                                 
40002820:	80 a6 60 00 	cmp  %i1, 0                                    
40002824:	02 80 00 06 	be  4000283c <rtems_bdpart_create+0x20>        <== NEVER TAKEN
40002828:	90 10 00 18 	mov  %i0, %o0                                  
  size_t count                                                        
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  bool dos_compatibility = format != NULL                             
    && format->type == RTEMS_BDPART_FORMAT_MBR                        
4000282c:	c2 06 40 00 	ld  [ %i1 ], %g1                               
40002830:	80 a0 60 00 	cmp  %g1, 0                                    
40002834:	22 80 00 12 	be,a   4000287c <rtems_bdpart_create+0x60>     <== ALWAYS TAKEN
40002838:	c2 0e 60 08 	ldub  [ %i1 + 8 ], %g1                         
    && format->mbr.dos_compatibility;                                 
  rtems_blkdev_bnum disk_end = 0;                                     
4000283c:	c0 27 bf fc 	clr  [ %fp + -4 ]                              <== NOT EXECUTED
  const unsigned *dist,                                               
  size_t count                                                        
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  bool dos_compatibility = format != NULL                             
40002840:	a2 10 20 00 	clr  %l1                                       <== NOT EXECUTED
    && format->type == RTEMS_BDPART_FORMAT_MBR                        
    && 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 =                                    
40002844:	a0 10 20 01 	mov  1, %l0                                    <== NOT EXECUTED
  rtems_blkdev_bnum overhead = 0;                                     
  rtems_blkdev_bnum free_space = 0;                                   
  size_t i = 0;                                                       
                                                                      
  /* Check if we have something to do */                              
  if (count == 0) {                                                   
40002848:	80 a7 20 00 	cmp  %i4, 0                                    
4000284c:	02 80 00 0a 	be  40002874 <rtems_bdpart_create+0x58>        <== NEVER TAKEN
40002850:	b0 10 20 00 	clr  %i0                                       
    /* Nothing to do */                                               
    return RTEMS_SUCCESSFUL;                                          
  }                                                                   
                                                                      
  /* Check parameter */                                               
  if (format == NULL || pt == NULL || dist == NULL) {                 
40002854:	80 a6 a0 00 	cmp  %i2, 0                                    
40002858:	02 80 00 07 	be  40002874 <rtems_bdpart_create+0x58>        <== NEVER TAKEN
4000285c:	b0 10 20 09 	mov  9, %i0                                    
40002860:	80 a6 60 00 	cmp  %i1, 0                                    
40002864:	02 80 00 04 	be  40002874 <rtems_bdpart_create+0x58>        <== NEVER TAKEN
40002868:	80 a6 e0 00 	cmp  %i3, 0                                    
4000286c:	12 80 00 0a 	bne  40002894 <rtems_bdpart_create+0x78>       <== ALWAYS TAKEN
40002870:	92 10 20 00 	clr  %o1                                       
                                                                      
  /* Expand the last partition to the disk end */                     
  pt [count - 1].end = disk_end;                                      
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
40002874:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40002878:	81 e8 00 00 	restore                                        <== NOT EXECUTED
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  bool dos_compatibility = format != NULL                             
    && format->type == RTEMS_BDPART_FORMAT_MBR                        
    && format->mbr.dos_compatibility;                                 
4000287c:	80 a0 60 00 	cmp  %g1, 0                                    
40002880:	02 bf ff f0 	be  40002840 <rtems_bdpart_create+0x24>        <== NEVER TAKEN
40002884:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
  const unsigned *dist,                                               
  size_t count                                                        
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  bool dos_compatibility = format != NULL                             
40002888:	a2 10 20 01 	mov  1, %l1                                    
    && format->type == RTEMS_BDPART_FORMAT_MBR                        
    && 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 =                                    
4000288c:	10 bf ff ef 	b  40002848 <rtems_bdpart_create+0x2c>         
40002890:	a0 10 20 3f 	mov  0x3f, %l0                                 
  if (format == NULL || pt == NULL || dist == NULL) {                 
    return RTEMS_INVALID_ADDRESS;                                     
  }                                                                   
                                                                      
  /* Get disk data */                                                 
  sc = rtems_bdpart_get_disk_data( disk_name, NULL, NULL, &disk_end); 
40002894:	94 10 20 00 	clr  %o2                                       
40002898:	40 00 01 3d 	call  40002d8c <rtems_bdpart_get_disk_data>    
4000289c:	96 07 bf fc 	add  %fp, -4, %o3                              
  if (sc != RTEMS_SUCCESSFUL) {                                       
400028a0:	b0 92 20 00 	orcc  %o0, 0, %i0                              
400028a4:	12 80 00 72 	bne  40002a6c <rtems_bdpart_create+0x250>      <== NEVER TAKEN
400028a8:	01 00 00 00 	nop                                            
                                                                      
  /* Get distribution sum and check for overflow */                   
  for (i = 0; i < count; ++i) {                                       
    unsigned prev_sum = dist_sum;                                     
                                                                      
    dist_sum += dist [i];                                             
400028ac:	e4 06 c0 00 	ld  [ %i3 ], %l2                               
                                                                      
    if (dist_sum < prev_sum) {                                        
      return RTEMS_INVALID_NUMBER;                                    
    }                                                                 
                                                                      
    if (dist [i] == 0) {                                              
400028b0:	ba 94 a0 00 	orcc  %l2, 0, %i5                              
400028b4:	12 80 00 0b 	bne  400028e0 <rtems_bdpart_create+0xc4>       <== ALWAYS TAKEN
400028b8:	82 10 20 00 	clr  %g1                                       
      return RTEMS_INVALID_NUMBER;                                    
400028bc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400028c0:	91 e8 20 0a 	restore  %g0, 0xa, %o0                         <== NOT EXECUTED
                                                                      
  /* Get distribution sum and check for overflow */                   
  for (i = 0; i < count; ++i) {                                       
    unsigned prev_sum = dist_sum;                                     
                                                                      
    dist_sum += dist [i];                                             
400028c4:	c4 06 c0 02 	ld  [ %i3 + %g2 ], %g2                         
400028c8:	86 07 40 02 	add  %i5, %g2, %g3                             
                                                                      
    if (dist_sum < prev_sum) {                                        
400028cc:	80 a0 c0 1d 	cmp  %g3, %i5                                  
400028d0:	0a 80 00 0e 	bcs  40002908 <rtems_bdpart_create+0xec>       <== NEVER TAKEN
400028d4:	80 a0 a0 00 	cmp  %g2, 0                                    
      return RTEMS_INVALID_NUMBER;                                    
    }                                                                 
                                                                      
    if (dist [i] == 0) {                                              
400028d8:	02 80 00 0c 	be  40002908 <rtems_bdpart_create+0xec>        <== NEVER TAKEN
400028dc:	ba 10 00 03 	mov  %g3, %i5                                  
  if (sc != RTEMS_SUCCESSFUL) {                                       
    return sc;                                                        
  }                                                                   
                                                                      
  /* Get distribution sum and check for overflow */                   
  for (i = 0; i < count; ++i) {                                       
400028e0:	82 00 60 01 	inc  %g1                                       
400028e4:	80 a0 40 1c 	cmp  %g1, %i4                                  
400028e8:	12 bf ff f7 	bne  400028c4 <rtems_bdpart_create+0xa8>       
400028ec:	85 28 60 02 	sll  %g1, 2, %g2                               
      return RTEMS_INVALID_NUMBER;                                    
    }                                                                 
  }                                                                   
                                                                      
  /* Check format */                                                  
  if (format->type != RTEMS_BDPART_FORMAT_MBR) {                      
400028f0:	c2 06 40 00 	ld  [ %i1 ], %g1                               
400028f4:	80 a0 60 00 	cmp  %g1, 0                                    
400028f8:	02 80 00 06 	be  40002910 <rtems_bdpart_create+0xf4>        <== ALWAYS TAKEN
400028fc:	a2 8c 60 ff 	andcc  %l1, 0xff, %l1                          
    return RTEMS_NOT_IMPLEMENTED;                                     
40002900:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40002904:	91 e8 20 18 	restore  %g0, 0x18, %o0                        <== NOT EXECUTED
    if (dist_sum < prev_sum) {                                        
      return RTEMS_INVALID_NUMBER;                                    
    }                                                                 
                                                                      
    if (dist [i] == 0) {                                              
      return RTEMS_INVALID_NUMBER;                                    
40002908:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000290c:	91 e8 20 0a 	restore  %g0, 0xa, %o0                         <== NOT EXECUTED
  if (format->type != RTEMS_BDPART_FORMAT_MBR) {                      
    return RTEMS_NOT_IMPLEMENTED;                                     
  }                                                                   
                                                                      
  /* Align end of disk on cylinder boundary if necessary */           
  if (dos_compatibility) {                                            
40002910:	02 80 00 06 	be  40002928 <rtems_bdpart_create+0x10c>       <== NEVER TAKEN
40002914:	ec 07 bf fc 	ld  [ %fp + -4 ], %l6                          
    disk_end -= (disk_end % record_space);                            
40002918:	90 10 00 16 	mov  %l6, %o0                                  
4000291c:	40 00 7d 79 	call  40021f00 <.urem>                         
40002920:	92 10 00 10 	mov  %l0, %o1                                  
40002924:	ac 25 80 08 	sub  %l6, %o0, %l6                             
                                                                      
  /*                                                                  
   * In case we need an extended partition and logical partitions we have to
   * account for the space of each EBR.                               
   */                                                                 
  if (count > 4) {                                                    
40002928:	80 a7 20 04 	cmp  %i4, 4                                    
4000292c:	08 80 00 06 	bleu  40002944 <rtems_bdpart_create+0x128>     <== NEVER TAKEN
40002930:	aa 10 00 10 	mov  %l0, %l5                                  
    overhead += (count - 3) * record_space;                           
40002934:	90 10 00 10 	mov  %l0, %o0                                  
40002938:	40 00 7c 8c 	call  40021b68 <.umul>                         
4000293c:	92 07 3f fd 	add  %i4, -3, %o1                              
40002940:	aa 02 00 10 	add  %o0, %l0, %l5                             
                                                                      
  /*                                                                  
   * Account space to align every partition on cylinder boundaries if 
   * necessary.                                                       
   */                                                                 
  if (dos_compatibility) {                                            
40002944:	80 a4 60 00 	cmp  %l1, 0                                    
40002948:	02 80 00 07 	be  40002964 <rtems_bdpart_create+0x148>       <== NEVER TAKEN
4000294c:	82 05 40 1c 	add  %l5, %i4, %g1                             
    overhead += (count - 1) * record_space;                           
40002950:	90 10 00 10 	mov  %l0, %o0                                  
40002954:	40 00 7c 85 	call  40021b68 <.umul>                         
40002958:	92 07 3f ff 	add  %i4, -1, %o1                              
4000295c:	aa 05 40 08 	add  %l5, %o0, %l5                             
  }                                                                   
                                                                      
  /* Check disk space */                                              
  if ((overhead + count) > disk_end) {                                
40002960:	82 05 40 1c 	add  %l5, %i4, %g1                             
40002964:	80 a0 40 16 	cmp  %g1, %l6                                  
40002968:	08 80 00 04 	bleu  40002978 <rtems_bdpart_create+0x15c>     <== ALWAYS TAKEN
4000296c:	aa 25 80 15 	sub  %l6, %l5, %l5                             
    return RTEMS_IO_ERROR;                                            
40002970:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40002974:	91 e8 20 1b 	restore  %g0, 0x1b, %o0                        <== NOT EXECUTED
                                                                      
  for (i = 0; i < count; ++i) {                                       
    rtems_bdpart_partition *p = pt + i;                               
                                                                      
    /* Partition size */                                              
    rtems_blkdev_bnum s = free_space * dist [i];                      
40002978:	92 10 00 12 	mov  %l2, %o1                                  
4000297c:	40 00 7c 7b 	call  40021b68 <.umul>                         
40002980:	90 10 00 15 	mov  %l5, %o0                                  
    if (s < free_space || s < dist [i]) {                             
40002984:	80 a5 40 08 	cmp  %l5, %o0                                  
40002988:	18 bf ff e0 	bgu  40002908 <rtems_bdpart_create+0xec>       <== NEVER TAKEN
4000298c:	80 a4 80 08 	cmp  %l2, %o0                                  
40002990:	18 bf ff de 	bgu  40002908 <rtems_bdpart_create+0xec>       <== NEVER TAKEN
40002994:	80 a7 20 04 	cmp  %i4, 4                                    
40002998:	18 80 00 03 	bgu  400029a4 <rtems_bdpart_create+0x188>      <== ALWAYS TAKEN
4000299c:	ae 10 20 01 	mov  1, %l7                                    
400029a0:	ae 10 20 00 	clr  %l7                                       <== NOT EXECUTED
#endif                                                                
                                                                      
#include <rtems.h>                                                    
#include <rtems/bdpart.h>                                             
                                                                      
rtems_status_code rtems_bdpart_create(                                
400029a4:	a8 06 a0 30 	add  %i2, 0x30, %l4                            
400029a8:	a6 10 00 1a 	mov  %i2, %l3                                  
  if ((overhead + count) > disk_end) {                                
    return RTEMS_IO_ERROR;                                            
  }                                                                   
                                                                      
  /* Begin of first primary partition */                              
  pos = record_space;                                                 
400029ac:	a2 10 00 10 	mov  %l0, %l1                                  
                                                                      
  /* Space for partitions */                                          
  free_space = disk_end - overhead;                                   
                                                                      
  for (i = 0; i < count; ++i) {                                       
400029b0:	b2 10 20 00 	clr  %i1                                       
                                                                      
    /* Align partition upwards */                                     
    s += record_space - (s % record_space);                           
                                                                      
    /* Reserve space for the EBR if necessary */                      
    if (count > 4 && i > 2) {                                         
400029b4:	10 80 00 0b 	b  400029e0 <rtems_bdpart_create+0x1c4>        
400029b8:	ae 0d e0 ff 	and  %l7, 0xff, %l7                            
                                                                      
  for (i = 0; i < count; ++i) {                                       
    rtems_bdpart_partition *p = pt + i;                               
                                                                      
    /* Partition size */                                              
    rtems_blkdev_bnum s = free_space * dist [i];                      
400029bc:	e4 06 c0 01 	ld  [ %i3 + %g1 ], %l2                         
                                                                      
  /* Space for partitions */                                          
  free_space = disk_end - overhead;                                   
                                                                      
  for (i = 0; i < count; ++i) {                                       
    rtems_bdpart_partition *p = pt + i;                               
400029c0:	a6 10 00 14 	mov  %l4, %l3                                  
                                                                      
    /* Partition size */                                              
    rtems_blkdev_bnum s = free_space * dist [i];                      
400029c4:	40 00 7c 69 	call  40021b68 <.umul>                         
400029c8:	90 10 00 12 	mov  %l2, %o0                                  
    if (s < free_space || s < dist [i]) {                             
400029cc:	80 a5 40 08 	cmp  %l5, %o0                                  
400029d0:	18 bf ff ce 	bgu  40002908 <rtems_bdpart_create+0xec>       <== NEVER TAKEN
400029d4:	80 a4 80 08 	cmp  %l2, %o0                                  
400029d8:	18 bf ff cc 	bgu  40002908 <rtems_bdpart_create+0xec>       <== NEVER TAKEN
400029dc:	a8 05 20 30 	add  %l4, 0x30, %l4                            
      /* TODO: Calculate without overflow */                          
      return RTEMS_INVALID_NUMBER;                                    
    }                                                                 
    s /= dist_sum;                                                    
400029e0:	40 00 7c 9c 	call  40021c50 <.udiv>                         
400029e4:	92 10 00 1d 	mov  %i5, %o1                                  
    if (s == 0) {                                                     
      s = 1;                                                          
    }                                                                 
                                                                      
    /* Align partition upwards */                                     
    s += record_space - (s % record_space);                           
400029e8:	92 10 00 10 	mov  %l0, %o1                                  
      return RTEMS_INVALID_NUMBER;                                    
    }                                                                 
    s /= dist_sum;                                                    
                                                                      
    /* Ensure that the partition is not empty */                      
    if (s == 0) {                                                     
400029ec:	80 a2 20 00 	cmp  %o0, 0                                    
400029f0:	12 80 00 03 	bne  400029fc <rtems_bdpart_create+0x1e0>      <== ALWAYS TAKEN
400029f4:	a4 10 00 08 	mov  %o0, %l2                                  
      s = 1;                                                          
400029f8:	a4 10 20 01 	mov  1, %l2                                    <== NOT EXECUTED
    }                                                                 
                                                                      
    /* Align partition upwards */                                     
    s += record_space - (s % record_space);                           
400029fc:	40 00 7d 41 	call  40021f00 <.urem>                         
40002a00:	90 10 00 12 	mov  %l2, %o0                                  
40002a04:	a4 04 80 10 	add  %l2, %l0, %l2                             
                                                                      
  for (i = 0; i < count; ++i) {                                       
    rtems_bdpart_partition *p = pt + i;                               
                                                                      
    /* Partition size */                                              
    rtems_blkdev_bnum s = free_space * dist [i];                      
40002a08:	92 10 00 15 	mov  %l5, %o1                                  
                                                                      
    /* Align partition upwards */                                     
    s += record_space - (s % record_space);                           
                                                                      
    /* Reserve space for the EBR if necessary */                      
    if (count > 4 && i > 2) {                                         
40002a0c:	82 10 20 01 	mov  1, %g1                                    
40002a10:	80 a6 60 02 	cmp  %i1, 2                                    
40002a14:	18 80 00 03 	bgu  40002a20 <rtems_bdpart_create+0x204>      
40002a18:	90 24 80 08 	sub  %l2, %o0, %o0                             
40002a1c:	82 10 20 00 	clr  %g1                                       
40002a20:	80 88 60 ff 	btst  0xff, %g1                                
40002a24:	22 80 00 06 	be,a   40002a3c <rtems_bdpart_create+0x220>    
40002a28:	e2 24 c0 00 	st  %l1, [ %l3 ]                               
40002a2c:	80 a5 e0 00 	cmp  %l7, 0                                    
40002a30:	32 80 00 02 	bne,a   40002a38 <rtems_bdpart_create+0x21c>   <== ALWAYS TAKEN
40002a34:	a2 04 40 10 	add  %l1, %l0, %l1                             
      pos += record_space;                                            
    }                                                                 
                                                                      
    /* Partition begin and end */                                     
    p->begin = pos;                                                   
40002a38:	e2 24 c0 00 	st  %l1, [ %l3 ]                               
    pos += s;                                                         
40002a3c:	a2 04 40 08 	add  %l1, %o0, %l1                             
    p->end = pos;                                                     
40002a40:	e2 24 e0 04 	st  %l1, [ %l3 + 4 ]                           
  pos = record_space;                                                 
                                                                      
  /* Space for partitions */                                          
  free_space = disk_end - overhead;                                   
                                                                      
  for (i = 0; i < count; ++i) {                                       
40002a44:	b2 06 60 01 	inc  %i1                                       
40002a48:	80 a7 00 19 	cmp  %i4, %i1                                  
40002a4c:	18 bf ff dc 	bgu  400029bc <rtems_bdpart_create+0x1a0>      
40002a50:	83 2e 60 02 	sll  %i1, 2, %g1                               
    pos += s;                                                         
    p->end = pos;                                                     
  }                                                                   
                                                                      
  /* Expand the last partition to the disk end */                     
  pt [count - 1].end = disk_end;                                      
40002a54:	b8 07 3f ff 	add  %i4, -1, %i4                              
40002a58:	83 2f 20 04 	sll  %i4, 4, %g1                               
40002a5c:	b9 2f 20 06 	sll  %i4, 6, %i4                               
40002a60:	82 27 00 01 	sub  %i4, %g1, %g1                             
40002a64:	b4 06 80 01 	add  %i2, %g1, %i2                             
40002a68:	ec 26 a0 04 	st  %l6, [ %i2 + 4 ]                           
40002a6c:	81 c7 e0 08 	ret                                            
40002a70:	81 e8 00 00 	restore                                        
                                                                      

40002a74 <rtems_bdpart_dump>: { uuid_unparse_lower( type, str); } void rtems_bdpart_dump( const rtems_bdpart_partition *pt, size_t count) {
40002a74:	9d e3 bf 60 	save  %sp, -160, %sp                           
  size_t i = 0;                                                       
                                                                      
  printf(                                                             
40002a78:	11 10 00 95 	sethi  %hi(0x40025400), %o0                    
40002a7c:	40 00 4d 7b 	call  40016068 <puts>                          
40002a80:	90 12 20 d0 	or  %o0, 0xd0, %o0	! 400254d0 <__FUNCTION__.6193+0x298>
    "------------+------------+-----------------------------------------------------\n"
    " BEGIN      | END        | TYPE\n"                               
    "------------+------------+-----------------------------------------------------\n"
  );                                                                  
                                                                      
  for (i = 0; i < count; ++i) {                                       
40002a84:	80 a6 60 00 	cmp  %i1, 0                                    
40002a88:	02 80 00 3a 	be  40002b70 <rtems_bdpart_dump+0xfc>          <== NEVER TAKEN
40002a8c:	11 10 00 95 	sethi  %hi(0x40025400), %o0                    
          break;                                                      
        case RTEMS_BDPART_MBR_DATA:                                   
          type = "DATA";                                              
          break;                                                      
        default:                                                      
          snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
40002a90:	29 10 00 95 	sethi  %hi(0x40025400), %l4                    
    } else {                                                          
      rtems_bdpart_type_to_string( p->type, type_buffer);             
      type = type_buffer;                                             
    }                                                                 
                                                                      
    printf(                                                           
40002a94:	37 10 00 95 	sethi  %hi(0x40025400), %i3                    
    "------------+------------+-----------------------------------------------------\n"
    " BEGIN      | END        | TYPE\n"                               
    "------------+------------+-----------------------------------------------------\n"
  );                                                                  
                                                                      
  for (i = 0; i < count; ++i) {                                       
40002a98:	ba 10 20 00 	clr  %i5                                       
          break;                                                      
        case RTEMS_BDPART_MBR_FAT_16_LBA:                             
          type = "FAT 16 LBA";                                        
          break;                                                      
        case RTEMS_BDPART_MBR_FAT_32:                                 
          type = "FAT 32";                                            
40002a9c:	2b 10 00 95 	sethi  %hi(0x40025400), %l5                    
          break;                                                      
        case RTEMS_BDPART_MBR_DATA:                                   
          type = "DATA";                                              
          break;                                                      
        default:                                                      
          snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
40002aa0:	a8 15 22 10 	or  %l4, 0x210, %l4                            
          break;                                                      
        case RTEMS_BDPART_MBR_FAT_16:                                 
          type = "FAT 16";                                            
          break;                                                      
        case RTEMS_BDPART_MBR_FAT_16_LBA:                             
          type = "FAT 16 LBA";                                        
40002aa4:	27 10 00 95 	sethi  %hi(0x40025400), %l3                    
          break;                                                      
        case RTEMS_BDPART_MBR_FAT_32_LBA:                             
          type = "FAT 32 LBA";                                        
          break;                                                      
        case RTEMS_BDPART_MBR_DATA:                                   
          type = "DATA";                                              
40002aa8:	25 10 00 95 	sethi  %hi(0x40025400), %l2                    
          break;                                                      
        case RTEMS_BDPART_MBR_FAT_32:                                 
          type = "FAT 32";                                            
          break;                                                      
        case RTEMS_BDPART_MBR_FAT_32_LBA:                             
          type = "FAT 32 LBA";                                        
40002aac:	23 10 00 95 	sethi  %hi(0x40025400), %l1                    
    uint8_t type_mbr = 0;                                             
                                                                      
    if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {    
      switch (type_mbr) {                                             
        case RTEMS_BDPART_MBR_FAT_12:                                 
          type = "FAT 12";                                            
40002ab0:	21 10 00 95 	sethi  %hi(0x40025400), %l0                    
          break;                                                      
        case RTEMS_BDPART_MBR_FAT_16:                                 
          type = "FAT 16";                                            
40002ab4:	35 10 00 95 	sethi  %hi(0x40025400), %i2                    
    } else {                                                          
      rtems_bdpart_type_to_string( p->type, type_buffer);             
      type = type_buffer;                                             
    }                                                                 
                                                                      
    printf(                                                           
40002ab8:	10 80 00 19 	b  40002b1c <rtems_bdpart_dump+0xa8>           
40002abc:	b6 16 e2 18 	or  %i3, 0x218, %i3                            
    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) {                                             
40002ac0:	80 a2 e0 0b 	cmp  %o3, 0xb                                  
40002ac4:	22 80 00 0e 	be,a   40002afc <rtems_bdpart_dump+0x88>       <== ALWAYS TAKEN
40002ac8:	96 15 60 b8 	or  %l5, 0xb8, %o3                             
40002acc:	18 80 00 2d 	bgu  40002b80 <rtems_bdpart_dump+0x10c>        <== NOT EXECUTED
40002ad0:	80 a2 e0 0e 	cmp  %o3, 0xe                                  <== NOT EXECUTED
40002ad4:	80 a2 e0 01 	cmp  %o3, 1                                    <== NOT EXECUTED
40002ad8:	02 80 00 36 	be  40002bb0 <rtems_bdpart_dump+0x13c>         <== NOT EXECUTED
40002adc:	80 a2 e0 04 	cmp  %o3, 4                                    <== NOT EXECUTED
40002ae0:	22 80 00 07 	be,a   40002afc <rtems_bdpart_dump+0x88>       <== NOT EXECUTED
40002ae4:	96 16 a0 90 	or  %i2, 0x90, %o3                             <== NOT EXECUTED
          break;                                                      
        case RTEMS_BDPART_MBR_DATA:                                   
          type = "DATA";                                              
          break;                                                      
        default:                                                      
          snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
40002ae8:	90 07 bf c8 	add  %fp, -56, %o0                             <== NOT EXECUTED
40002aec:	92 10 20 34 	mov  0x34, %o1                                 <== NOT EXECUTED
40002af0:	40 00 4d 98 	call  40016150 <snprintf>                      <== NOT EXECUTED
40002af4:	94 10 00 14 	mov  %l4, %o2                                  <== NOT EXECUTED
          type = type_buffer;                                         
40002af8:	96 07 bf c8 	add  %fp, -56, %o3                             <== NOT EXECUTED
    } else {                                                          
      rtems_bdpart_type_to_string( p->type, type_buffer);             
      type = type_buffer;                                             
    }                                                                 
                                                                      
    printf(                                                           
40002afc:	d2 06 00 00 	ld  [ %i0 ], %o1                               
40002b00:	d4 06 20 04 	ld  [ %i0 + 4 ], %o2                           
40002b04:	40 00 4d 23 	call  40015f90 <printf>                        
40002b08:	90 10 00 1b 	mov  %i3, %o0                                  
    "------------+------------+-----------------------------------------------------\n"
    " BEGIN      | END        | TYPE\n"                               
    "------------+------------+-----------------------------------------------------\n"
  );                                                                  
                                                                      
  for (i = 0; i < count; ++i) {                                       
40002b0c:	ba 07 60 01 	inc  %i5                                       
40002b10:	80 a7 40 19 	cmp  %i5, %i1                                  
40002b14:	02 80 00 16 	be  40002b6c <rtems_bdpart_dump+0xf8>          
40002b18:	b0 06 20 30 	add  %i0, 0x30, %i0                            
    const rtems_bdpart_partition *p = pt + i;                         
    const char *type = NULL;                                          
    char type_buffer [52];                                            
    uint8_t type_mbr = 0;                                             
40002b1c:	c0 2f bf c7 	clrb  [ %fp + -57 ]                            
                                                                      
    if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {    
40002b20:	b8 06 20 08 	add  %i0, 8, %i4                               
40002b24:	92 07 bf c7 	add  %fp, -57, %o1                             
40002b28:	40 00 00 8d 	call  40002d5c <rtems_bdpart_to_mbr_partition_type>
40002b2c:	90 10 00 1c 	mov  %i4, %o0                                  
40002b30:	80 8a 20 ff 	btst  0xff, %o0                                
40002b34:	12 bf ff e3 	bne  40002ac0 <rtems_bdpart_dump+0x4c>         <== ALWAYS TAKEN
40002b38:	d6 0f bf c7 	ldub  [ %fp + -57 ], %o3                       
static void rtems_bdpart_type_to_string(                              
  const uuid_t type,                                                  
  char str [37]                                                       
)                                                                     
{                                                                     
  uuid_unparse_lower( type, str);                                     
40002b3c:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
40002b40:	40 00 2c ca 	call  4000de68 <uuid_unparse_lower>            <== NOT EXECUTED
40002b44:	92 07 bf c8 	add  %fp, -56, %o1                             <== NOT EXECUTED
    } else {                                                          
      rtems_bdpart_type_to_string( p->type, type_buffer);             
      type = type_buffer;                                             
    }                                                                 
                                                                      
    printf(                                                           
40002b48:	d2 06 00 00 	ld  [ %i0 ], %o1                               <== NOT EXECUTED
40002b4c:	d4 06 20 04 	ld  [ %i0 + 4 ], %o2                           <== NOT EXECUTED
          type = type_buffer;                                         
          break;                                                      
      }                                                               
    } else {                                                          
      rtems_bdpart_type_to_string( p->type, type_buffer);             
      type = type_buffer;                                             
40002b50:	96 07 bf c8 	add  %fp, -56, %o3                             <== NOT EXECUTED
    }                                                                 
                                                                      
    printf(                                                           
40002b54:	40 00 4d 0f 	call  40015f90 <printf>                        <== NOT EXECUTED
40002b58:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
    "------------+------------+-----------------------------------------------------\n"
    " BEGIN      | END        | TYPE\n"                               
    "------------+------------+-----------------------------------------------------\n"
  );                                                                  
                                                                      
  for (i = 0; i < count; ++i) {                                       
40002b5c:	ba 07 60 01 	inc  %i5                                       <== NOT EXECUTED
40002b60:	80 a7 40 19 	cmp  %i5, %i1                                  <== NOT EXECUTED
40002b64:	12 bf ff ee 	bne  40002b1c <rtems_bdpart_dump+0xa8>         <== NOT EXECUTED
40002b68:	b0 06 20 30 	add  %i0, 0x30, %i0                            <== NOT EXECUTED
      p->end,                                                         
      type                                                            
    );                                                                
  }                                                                   
                                                                      
  puts( "------------+------------+-----------------------------------------------------");
40002b6c:	11 10 00 95 	sethi  %hi(0x40025400), %o0                    
40002b70:	40 00 4d 3e 	call  40016068 <puts>                          
40002b74:	90 12 21 c0 	or  %o0, 0x1c0, %o0	! 400255c0 <__FUNCTION__.6193+0x388>
40002b78:	81 c7 e0 08 	ret                                            
40002b7c:	81 e8 00 00 	restore                                        
    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) {                                             
40002b80:	02 80 00 0a 	be  40002ba8 <rtems_bdpart_dump+0x134>         <== NOT EXECUTED
40002b84:	80 a2 e0 da 	cmp  %o3, 0xda                                 <== NOT EXECUTED
40002b88:	02 80 00 06 	be  40002ba0 <rtems_bdpart_dump+0x12c>         <== NOT EXECUTED
40002b8c:	80 a2 e0 0c 	cmp  %o3, 0xc                                  <== NOT EXECUTED
40002b90:	12 bf ff d7 	bne  40002aec <rtems_bdpart_dump+0x78>         <== NOT EXECUTED
40002b94:	90 07 bf c8 	add  %fp, -56, %o0                             <== NOT EXECUTED
        case RTEMS_BDPART_MBR_FAT_32:                                 
          type = "FAT 32";                                            
          break;                                                      
        case RTEMS_BDPART_MBR_FAT_32_LBA:                             
          type = "FAT 32 LBA";                                        
          break;                                                      
40002b98:	10 bf ff d9 	b  40002afc <rtems_bdpart_dump+0x88>           <== NOT EXECUTED
40002b9c:	96 14 60 a8 	or  %l1, 0xa8, %o3                             <== NOT EXECUTED
        case RTEMS_BDPART_MBR_DATA:                                   
          type = "DATA";                                              
          break;                                                      
40002ba0:	10 bf ff d7 	b  40002afc <rtems_bdpart_dump+0x88>           <== NOT EXECUTED
40002ba4:	96 14 a0 a0 	or  %l2, 0xa0, %o3                             <== NOT EXECUTED
        case RTEMS_BDPART_MBR_FAT_16:                                 
          type = "FAT 16";                                            
          break;                                                      
        case RTEMS_BDPART_MBR_FAT_16_LBA:                             
          type = "FAT 16 LBA";                                        
          break;                                                      
40002ba8:	10 bf ff d5 	b  40002afc <rtems_bdpart_dump+0x88>           <== NOT EXECUTED
40002bac:	96 14 e0 c0 	or  %l3, 0xc0, %o3                             <== NOT EXECUTED
    uint8_t type_mbr = 0;                                             
                                                                      
    if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {    
      switch (type_mbr) {                                             
        case RTEMS_BDPART_MBR_FAT_12:                                 
          type = "FAT 12";                                            
40002bb0:	10 bf ff d3 	b  40002afc <rtems_bdpart_dump+0x88>           <== NOT EXECUTED
40002bb4:	96 14 20 98 	or  %l0, 0x98, %o3                             <== NOT EXECUTED
                                                                      

40002d8c <rtems_bdpart_get_disk_data>: const char *disk_name, int *fd_ptr, rtems_disk_device **dd_ptr, rtems_blkdev_bnum *disk_end ) {
40002d8c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_disk_device *dd = NULL;                                       
  rtems_blkdev_bnum disk_begin = 0;                                   
  rtems_blkdev_bnum block_size = 0;                                   
                                                                      
  /* Open device file */                                              
  fd = open( disk_name, O_RDWR);                                      
40002d90:	92 10 20 02 	mov  2, %o1                                    
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  int rv = 0;                                                         
  int fd = -1;                                                        
  rtems_disk_device *dd = NULL;                                       
40002d94:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
  rtems_blkdev_bnum disk_begin = 0;                                   
  rtems_blkdev_bnum block_size = 0;                                   
                                                                      
  /* Open device file */                                              
  fd = open( disk_name, O_RDWR);                                      
40002d98:	40 00 0d 2a 	call  40006240 <open>                          
40002d9c:	90 10 00 18 	mov  %i0, %o0                                  
  if (fd < 0) {                                                       
40002da0:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40002da4:	16 80 00 07 	bge  40002dc0 <rtems_bdpart_get_disk_data+0x34><== ALWAYS TAKEN
40002da8:	94 07 bf fc 	add  %fp, -4, %o2                              
    sc = RTEMS_INVALID_NAME;                                          
40002dac:	b0 10 20 03 	mov  3, %i0                                    <== NOT EXECUTED
                                                                      
  if (sc == RTEMS_SUCCESSFUL && fd_ptr != NULL && dd_ptr != NULL) {   
    *fd_ptr = fd;                                                     
    *dd_ptr = dd;                                                     
  } else {                                                            
    close( fd);                                                       
40002db0:	40 00 09 50 	call  400052f0 <close>                         <== NOT EXECUTED
40002db4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40002db8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40002dbc:	81 e8 00 00 	restore                                        <== NOT EXECUTED
static inline int rtems_disk_fd_get_disk_device(                      
  int fd,                                                             
  rtems_disk_device **dd_ptr                                          
)                                                                     
{                                                                     
  return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);                   
40002dc0:	13 10 01 10 	sethi  %hi(0x40044000), %o1                    
40002dc4:	40 00 09 ed 	call  40005578 <ioctl>                         
40002dc8:	92 12 62 09 	or  %o1, 0x209, %o1	! 40044209 <__end+0x1c519> 
    goto error;                                                       
  }                                                                   
                                                                      
  /* Get disk handle */                                               
  rv = rtems_disk_fd_get_disk_device( fd, &dd);                       
  if (rv != 0) {                                                      
40002dcc:	80 a2 20 00 	cmp  %o0, 0                                    
40002dd0:	32 bf ff f8 	bne,a   40002db0 <rtems_bdpart_get_disk_data+0x24><== NEVER TAKEN
40002dd4:	b0 10 20 03 	mov  3, %i0                                    <== NOT EXECUTED
    sc = RTEMS_INVALID_NAME;                                          
    goto error;                                                       
  }                                                                   
                                                                      
  /* Get disk begin, end and block size */                            
  disk_begin = dd->start;                                             
40002dd8:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
  *disk_end = dd->size;                                               
40002ddc:	c4 00 60 1c 	ld  [ %g1 + 0x1c ], %g2                        
    sc = RTEMS_INVALID_NAME;                                          
    goto error;                                                       
  }                                                                   
                                                                      
  /* Get disk begin, end and block size */                            
  disk_begin = dd->start;                                             
40002de0:	c6 00 60 18 	ld  [ %g1 + 0x18 ], %g3                        
  *disk_end = dd->size;                                               
40002de4:	c4 26 c0 00 	st  %g2, [ %i3 ]                               
  block_size = dd->block_size;                                        
                                                                      
  /* Check block size */                                              
  if (block_size < RTEMS_BDPART_BLOCK_SIZE) {                         
40002de8:	c4 00 60 24 	ld  [ %g1 + 0x24 ], %g2                        
40002dec:	80 a0 a1 ff 	cmp  %g2, 0x1ff                                
40002df0:	08 bf ff f0 	bleu  40002db0 <rtems_bdpart_get_disk_data+0x24><== NEVER TAKEN
40002df4:	b0 10 20 1b 	mov  0x1b, %i0                                 
    sc = RTEMS_IO_ERROR;                                              
    goto error;                                                       
  }                                                                   
                                                                      
  /* Check that we have do not have a logical disk */                 
  if (disk_begin != 0) {                                              
40002df8:	80 a0 e0 00 	cmp  %g3, 0                                    
40002dfc:	12 bf ff ed 	bne  40002db0 <rtems_bdpart_get_disk_data+0x24><== NEVER TAKEN
40002e00:	80 a6 60 00 	cmp  %i1, 0                                    
    goto error;                                                       
  }                                                                   
                                                                      
error:                                                                
                                                                      
  if (sc == RTEMS_SUCCESSFUL && fd_ptr != NULL && dd_ptr != NULL) {   
40002e04:	02 80 00 08 	be  40002e24 <rtems_bdpart_get_disk_data+0x98> 
40002e08:	80 a6 a0 00 	cmp  %i2, 0                                    
40002e0c:	02 80 00 07 	be  40002e28 <rtems_bdpart_get_disk_data+0x9c> <== NEVER TAKEN
40002e10:	b0 10 20 00 	clr  %i0                                       
    *fd_ptr = fd;                                                     
40002e14:	fa 26 40 00 	st  %i5, [ %i1 ]                               
    *dd_ptr = dd;                                                     
40002e18:	c2 26 80 00 	st  %g1, [ %i2 ]                               
40002e1c:	81 c7 e0 08 	ret                                            
40002e20:	81 e8 00 00 	restore                                        
  int *fd_ptr,                                                        
  rtems_disk_device **dd_ptr,                                         
  rtems_blkdev_bnum *disk_end                                         
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
40002e24:	b0 10 20 00 	clr  %i0                                       
                                                                      
  if (sc == RTEMS_SUCCESSFUL && fd_ptr != NULL && dd_ptr != NULL) {   
    *fd_ptr = fd;                                                     
    *dd_ptr = dd;                                                     
  } else {                                                            
    close( fd);                                                       
40002e28:	40 00 09 32 	call  400052f0 <close>                         
40002e2c:	90 10 00 1d 	mov  %i5, %o0                                  
40002e30:	81 c7 e0 08 	ret                                            
40002e34:	81 e8 00 00 	restore                                        
                                                                      

40023e40 <rtems_bdpart_mount>: const char *disk_name, const rtems_bdpart_partition *pt __attribute__((unused)), size_t count, const char *mount_base ) {
40023e40:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
  const char *disk_file_name = strrchr( disk_name, '/');              
40023e44:	92 10 20 2f 	mov  0x2f, %o1                                 <== NOT EXECUTED
40023e48:	40 00 7d b9 	call  4004352c <strrchr>                       <== NOT EXECUTED
40023e4c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40023e50:	b8 10 00 08 	mov  %o0, %i4                                  <== 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);                         
40023e54:	40 00 79 93 	call  400424a0 <strlen>                        <== NOT EXECUTED
40023e58:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40023e5c:	a0 10 00 08 	mov  %o0, %l0                                  <== NOT EXECUTED
  size_t mount_base_size = strlen( mount_base);                       
40023e60:	40 00 79 90 	call  400424a0 <strlen>                        <== NOT EXECUTED
40023e64:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
  const char *disk_name,                                              
  const rtems_bdpart_partition *pt __attribute__((unused)),           
  size_t count,                                                       
  const char *mount_base                                              
)                                                                     
{                                                                     
40023e68:	ba 10 00 18 	mov  %i0, %i5                                  <== NOT EXECUTED
  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);                         
  size_t mount_base_size = strlen( mount_base);                       
40023e6c:	a2 10 00 08 	mov  %o0, %l1                                  <== NOT EXECUTED
  size_t i = 0;                                                       
                                                                      
  /* Create logical disk name base */                                 
  logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
  if (logical_disk_name == NULL) {                                    
    return RTEMS_NO_MEMORY;                                           
40023e70:	b0 10 20 1a 	mov  0x1a, %i0                                 <== NOT EXECUTED
  size_t disk_name_size = strlen( disk_name);                         
  size_t mount_base_size = strlen( mount_base);                       
  size_t i = 0;                                                       
                                                                      
  /* Create logical disk name base */                                 
  logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
40023e74:	7f ff 7c 21 	call  40002ef8 <malloc>                        <== NOT EXECUTED
40023e78:	90 04 20 04 	add  %l0, 4, %o0                               <== NOT EXECUTED
  if (logical_disk_name == NULL) {                                    
40023e7c:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40023e80:	02 80 00 4f 	be  40023fbc <rtems_bdpart_mount+0x17c>        <== NOT EXECUTED
40023e84:	b2 10 00 08 	mov  %o0, %i1                                  <== NOT EXECUTED
    return RTEMS_NO_MEMORY;                                           
  }                                                                   
  strncpy( logical_disk_name, disk_name, disk_name_size);             
40023e88:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
40023e8c:	40 00 7a 41 	call  40042790 <strncpy>                       <== NOT EXECUTED
40023e90:	94 10 00 10 	mov  %l0, %o2                                  <== NOT EXECUTED
                                                                      
  /* Get disk file name */                                            
  if (disk_file_name != NULL) {                                       
40023e94:	80 a7 20 00 	cmp  %i4, 0                                    <== NOT EXECUTED
40023e98:	02 80 00 06 	be  40023eb0 <rtems_bdpart_mount+0x70>         <== NOT EXECUTED
40023e9c:	a6 10 00 10 	mov  %l0, %l3                                  <== NOT EXECUTED
    disk_file_name += 1;                                              
40023ea0:	ba 07 20 01 	add  %i4, 1, %i5                               <== NOT EXECUTED
    disk_file_name_size = strlen( disk_file_name);                    
40023ea4:	40 00 79 7f 	call  400424a0 <strlen>                        <== NOT EXECUTED
40023ea8:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40023eac:	a6 10 00 08 	mov  %o0, %l3                                  <== 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);
40023eb0:	a4 04 c0 11 	add  %l3, %l1, %l2                             <== NOT EXECUTED
  if (mount_point == NULL) {                                          
    esc = RTEMS_NO_MEMORY;                                            
40023eb4:	b0 10 20 1a 	mov  0x1a, %i0                                 <== 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);
40023eb8:	7f ff 7c 10 	call  40002ef8 <malloc>                        <== NOT EXECUTED
40023ebc:	90 04 a0 05 	add  %l2, 5, %o0                               <== NOT EXECUTED
  if (mount_point == NULL) {                                          
40023ec0:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40023ec4:	02 80 00 3a 	be  40023fac <rtems_bdpart_mount+0x16c>        <== NOT EXECUTED
40023ec8:	b8 10 00 08 	mov  %o0, %i4                                  <== NOT EXECUTED
    esc = RTEMS_NO_MEMORY;                                            
    goto cleanup;                                                     
  }                                                                   
  strncpy( mount_point, mount_base, mount_base_size);                 
40023ecc:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
40023ed0:	40 00 7a 30 	call  40042790 <strncpy>                       <== NOT EXECUTED
40023ed4:	94 10 00 11 	mov  %l1, %o2                                  <== NOT EXECUTED
  mount_point [mount_base_size] = '/';                                
40023ed8:	82 10 20 2f 	mov  0x2f, %g1                                 <== NOT EXECUTED
  strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
40023edc:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
40023ee0:	90 04 60 01 	add  %l1, 1, %o0                               <== 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] = '/';                                
40023ee4:	c2 2f 00 11 	stb  %g1, [ %i4 + %l1 ]                        <== NOT EXECUTED
  strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
40023ee8:	90 07 00 08 	add  %i4, %o0, %o0                             <== NOT EXECUTED
40023eec:	40 00 7a 29 	call  40042790 <strncpy>                       <== NOT EXECUTED
40023ef0:	94 10 00 13 	mov  %l3, %o2                                  <== NOT EXECUTED
                                                                      
  /* Markers */                                                       
  logical_disk_marker = logical_disk_name + disk_name_size;           
  mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
40023ef4:	b0 04 a0 01 	add  %l2, 1, %i0                               <== NOT EXECUTED
  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);
                                                                      
  /* Markers */                                                       
  logical_disk_marker = logical_disk_name + disk_name_size;           
40023ef8:	b6 06 40 10 	add  %i1, %l0, %i3                             <== NOT EXECUTED
  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) {                                       
40023efc:	ba 10 20 00 	clr  %i5                                       <== NOT EXECUTED
40023f00:	80 a6 a0 00 	cmp  %i2, 0                                    <== NOT EXECUTED
40023f04:	02 80 00 29 	be  40023fa8 <rtems_bdpart_mount+0x168>        <== NOT EXECUTED
40023f08:	b0 07 00 18 	add  %i4, %i0, %i0                             <== NOT EXECUTED
    /* Create logical disk name */                                    
    int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
40023f0c:	21 10 01 81 	sethi  %hi(0x40060400), %l0                    <== NOT EXECUTED
      esc = RTEMS_IO_ERROR;                                           
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Mount */                                                       
    rv = mount(                                                       
40023f10:	23 10 01 7a 	sethi  %hi(0x4005e800), %l1                    <== NOT EXECUTED
  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) {                                       
    /* Create logical disk name */                                    
    int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
40023f14:	a0 14 23 08 	or  %l0, 0x308, %l0                            <== NOT EXECUTED
      esc = RTEMS_IO_ERROR;                                           
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Mount */                                                       
    rv = mount(                                                       
40023f18:	10 80 00 04 	b  40023f28 <rtems_bdpart_mount+0xe8>          <== NOT EXECUTED
40023f1c:	a2 14 60 28 	or  %l1, 0x28, %l1                             <== 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) {                                       
40023f20:	22 80 00 23 	be,a   40023fac <rtems_bdpart_mount+0x16c>     <== NOT EXECUTED
40023f24:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
    /* Create logical disk name */                                    
    int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
40023f28:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40023f2c:	94 10 00 10 	mov  %l0, %o2                                  <== NOT EXECUTED
40023f30:	ba 07 60 01 	inc  %i5                                       <== NOT EXECUTED
40023f34:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
40023f38:	40 00 75 e2 	call  400416c0 <snprintf>                      <== NOT EXECUTED
40023f3c:	96 10 00 1d 	mov  %i5, %o3                                  <== NOT EXECUTED
      esc = RTEMS_INVALID_NAME;                                       
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Create mount point */                                          
    strncpy( mount_marker, logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE);
40023f40:	94 10 20 04 	mov  4, %o2                                    <== 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) {                             
40023f44:	80 a2 20 03 	cmp  %o0, 3                                    <== NOT EXECUTED
      esc = RTEMS_INVALID_NAME;                                       
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Create mount point */                                          
    strncpy( mount_marker, logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE);
40023f48:	92 10 00 1b 	mov  %i3, %o1                                  <== 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) {                             
40023f4c:	14 80 00 1e 	bg  40023fc4 <rtems_bdpart_mount+0x184>        <== NOT EXECUTED
40023f50:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
      esc = RTEMS_INVALID_NAME;                                       
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Create mount point */                                          
    strncpy( mount_marker, logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE);
40023f54:	40 00 7a 0f 	call  40042790 <strncpy>                       <== NOT EXECUTED
40023f58:	01 00 00 00 	nop                                            <== NOT EXECUTED
    rv = rtems_mkdir( mount_point, S_IRWXU | S_IRWXG | S_IRWXO);      
40023f5c:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
40023f60:	40 00 10 17 	call  40027fbc <rtems_mkdir>                   <== NOT EXECUTED
40023f64:	92 10 21 ff 	mov  0x1ff, %o1                                <== NOT EXECUTED
    if (rv != 0) {                                                    
40023f68:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40023f6c:	12 80 00 1c 	bne  40023fdc <rtems_bdpart_mount+0x19c>       <== NOT EXECUTED
40023f70:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
      esc = RTEMS_IO_ERROR;                                           
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Mount */                                                       
    rv = mount(                                                       
40023f74:	94 10 00 11 	mov  %l1, %o2                                  <== NOT EXECUTED
40023f78:	96 10 20 00 	clr  %o3                                       <== NOT EXECUTED
40023f7c:	98 10 20 00 	clr  %o4                                       <== NOT EXECUTED
40023f80:	7f ff 7c 64 	call  40003110 <mount>                         <== NOT EXECUTED
40023f84:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
      mount_point,                                                    
      "msdos",                                                        
      0,                                                              
      NULL                                                            
    );                                                                
    if (rv != 0) {                                                    
40023f88:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40023f8c:	02 bf ff e5 	be  40023f20 <rtems_bdpart_mount+0xe0>         <== NOT EXECUTED
40023f90:	80 a7 40 1a 	cmp  %i5, %i2                                  <== NOT EXECUTED
      rmdir( mount_point);                                            
40023f94:	40 00 0f de 	call  40027f0c <rmdir>                         <== NOT EXECUTED
40023f98:	90 10 00 1c 	mov  %i4, %o0                                  <== 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) {                                       
40023f9c:	80 a7 40 1a 	cmp  %i5, %i2                                  <== NOT EXECUTED
40023fa0:	12 bf ff e3 	bne  40023f2c <rtems_bdpart_mount+0xec>        <== NOT EXECUTED
40023fa4:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
  const rtems_bdpart_partition *pt __attribute__((unused)),           
  size_t count,                                                       
  const char *mount_base                                              
)                                                                     
{                                                                     
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
40023fa8:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
cleanup:                                                              
                                                                      
  free( logical_disk_name);                                           
40023fac:	7f ff 7a f9 	call  40002b90 <free>                          <== NOT EXECUTED
40023fb0:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
  free( mount_point);                                                 
40023fb4:	7f ff 7a f7 	call  40002b90 <free>                          <== NOT EXECUTED
40023fb8:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
                                                                      
  return esc;                                                         
}                                                                     
40023fbc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40023fc0:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
cleanup:                                                              
                                                                      
  free( logical_disk_name);                                           
40023fc4:	7f ff 7a f3 	call  40002b90 <free>                          <== NOT EXECUTED
40023fc8:	90 10 00 19 	mov  %i1, %o0                                  <== 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) {                             
      esc = RTEMS_INVALID_NAME;                                       
40023fcc:	b0 10 20 03 	mov  3, %i0                                    <== NOT EXECUTED
  }                                                                   
                                                                      
cleanup:                                                              
                                                                      
  free( logical_disk_name);                                           
  free( mount_point);                                                 
40023fd0:	7f ff 7a f0 	call  40002b90 <free>                          <== NOT EXECUTED
40023fd4:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
40023fd8:	30 bf ff f9 	b,a   40023fbc <rtems_bdpart_mount+0x17c>      <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
cleanup:                                                              
                                                                      
  free( logical_disk_name);                                           
40023fdc:	7f ff 7a ed 	call  40002b90 <free>                          <== NOT EXECUTED
40023fe0:	90 10 00 19 	mov  %i1, %o0                                  <== 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) {                                                    
      esc = RTEMS_IO_ERROR;                                           
40023fe4:	b0 10 20 1b 	mov  0x1b, %i0                                 <== NOT EXECUTED
  }                                                                   
                                                                      
cleanup:                                                              
                                                                      
  free( logical_disk_name);                                           
  free( mount_point);                                                 
40023fe8:	7f ff 7a ea 	call  40002b90 <free>                          <== NOT EXECUTED
40023fec:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
40023ff0:	30 bf ff f3 	b,a   40023fbc <rtems_bdpart_mount+0x17c>      <== NOT EXECUTED
                                                                      

400032ac <rtems_bdpart_new_record>: static rtems_status_code rtems_bdpart_new_record( rtems_disk_device *dd, rtems_blkdev_bnum index, rtems_bdbuf_buffer **block ) {
400032ac:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  /* Synchronize previous block if necessary */                       
  if (*block != NULL) {                                               
400032b0:	d0 06 80 00 	ld  [ %i2 ], %o0                               
400032b4:	80 a2 20 00 	cmp  %o0, 0                                    
400032b8:	22 80 00 07 	be,a   400032d4 <rtems_bdpart_new_record+0x28> 
400032bc:	90 10 00 18 	mov  %i0, %o0                                  
    sc = rtems_bdbuf_sync( *block);                                   
400032c0:	40 00 34 24 	call  40010350 <rtems_bdbuf_sync>              
400032c4:	01 00 00 00 	nop                                            
    if (sc != RTEMS_SUCCESSFUL) {                                     
400032c8:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400032cc:	12 80 00 17 	bne  40003328 <rtems_bdpart_new_record+0x7c>   <== NEVER TAKEN
400032d0:	90 10 00 18 	mov  %i0, %o0                                  
      return sc;                                                      
    }                                                                 
  }                                                                   
                                                                      
  /* Read the new record block (this accounts for disk block sizes > 512) */
  sc = rtems_bdbuf_read( dd, index, block);                           
400032d4:	92 10 00 19 	mov  %i1, %o1                                  
400032d8:	40 00 33 41 	call  4000ffdc <rtems_bdbuf_read>              
400032dc:	94 10 00 1a 	mov  %i2, %o2                                  
  if (sc != RTEMS_SUCCESSFUL) {                                       
400032e0:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400032e4:	12 80 00 11 	bne  40003328 <rtems_bdpart_new_record+0x7c>   <== NEVER TAKEN
400032e8:	01 00 00 00 	nop                                            
    return sc;                                                        
  }                                                                   
                                                                      
  /* just in case block did not get filled in */                      
  if ( *block == NULL ) {                                             
400032ec:	c2 06 80 00 	ld  [ %i2 ], %g1                               
400032f0:	80 a0 60 00 	cmp  %g1, 0                                    
400032f4:	02 80 00 0f 	be  40003330 <rtems_bdpart_new_record+0x84>    <== NEVER TAKEN
400032f8:	92 10 20 00 	clr  %o1                                       
    return RTEMS_INVALID_ADDRESS;                                     
  }                                                                   
                                                                      
  /* Clear record */                                                  
  memset( (*block)->buffer, 0, RTEMS_BDPART_BLOCK_SIZE);              
400032fc:	d0 00 60 1c 	ld  [ %g1 + 0x1c ], %o0                        
40003300:	40 00 4a d1 	call  40015e44 <memset>                        
40003304:	94 10 22 00 	mov  0x200, %o2                                
                                                                      
  /* Write signature */                                               
  (*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_0] =            
40003308:	c2 06 80 00 	ld  [ %i2 ], %g1                               
4000330c:	84 10 20 55 	mov  0x55, %g2                                 
40003310:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        
40003314:	c4 28 61 fe 	stb  %g2, [ %g1 + 0x1fe ]                      
    RTEMS_BDPART_MBR_SIGNATURE_0;                                     
  (*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_1] =            
40003318:	c2 06 80 00 	ld  [ %i2 ], %g1                               
4000331c:	84 10 3f aa 	mov  -86, %g2                                  
40003320:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        
40003324:	c4 28 61 ff 	stb  %g2, [ %g1 + 0x1ff ]                      
    RTEMS_BDPART_MBR_SIGNATURE_1;                                     
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
40003328:	81 c7 e0 08 	ret                                            
4000332c:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
    return sc;                                                        
  }                                                                   
                                                                      
  /* just in case block did not get filled in */                      
  if ( *block == NULL ) {                                             
    return RTEMS_INVALID_ADDRESS;                                     
40003330:	ba 10 20 09 	mov  9, %i5                                    <== NOT EXECUTED
    RTEMS_BDPART_MBR_SIGNATURE_0;                                     
  (*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_1] =            
    RTEMS_BDPART_MBR_SIGNATURE_1;                                     
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
40003334:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40003338:	91 e8 00 1d 	restore  %g0, %i5, %o0                         <== NOT EXECUTED
                                                                      

40002e38 <rtems_bdpart_read>: const char *disk_name, rtems_bdpart_format *format, rtems_bdpart_partition *pt, size_t *count ) {
40002e38:	9d e3 bf 88 	save  %sp, -120, %sp                           
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
  rtems_bdbuf_buffer *block = NULL;                                   
  rtems_bdpart_partition *p = pt - 1;                                 
40002e3c:	82 06 bf d0 	add  %i2, -48, %g1                             
  size_t *count                                                       
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
  rtems_bdbuf_buffer *block = NULL;                                   
40002e40:	c0 27 bf e8 	clr  [ %fp + -24 ]                             
  rtems_bdpart_partition *p = pt - 1;                                 
  const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
40002e44:	80 a6 e0 00 	cmp  %i3, 0                                    
40002e48:	02 80 00 0a 	be  40002e70 <rtems_bdpart_read+0x38>          <== NEVER TAKEN
40002e4c:	c2 27 bf ec 	st  %g1, [ %fp + -20 ]                         
  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;                                     
  size_t i = 0;                                                       
  const uint8_t *data = NULL;                                         
  int fd = -1;                                                        
40002e50:	82 10 3f ff 	mov  -1, %g1                                   
  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 */      
40002e54:	c0 27 bf f0 	clr  [ %fp + -16 ]                             
  rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */   
  rtems_blkdev_bnum disk_end = 0;                                     
40002e58:	c0 27 bf f4 	clr  [ %fp + -12 ]                             
  size_t i = 0;                                                       
  const uint8_t *data = NULL;                                         
  int fd = -1;                                                        
40002e5c:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]                          
  rtems_disk_device *dd = NULL;                                       
40002e60:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
                                                                      
  /* Check parameter */                                               
  if (format == NULL || pt == NULL || count == NULL) {                
40002e64:	80 a6 a0 00 	cmp  %i2, 0                                    
40002e68:	12 80 00 04 	bne  40002e78 <rtems_bdpart_read+0x40>         <== ALWAYS TAKEN
40002e6c:	fa 06 c0 00 	ld  [ %i3 ], %i5                               
    return RTEMS_INVALID_ADDRESS;                                     
40002e70:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40002e74:	91 e8 20 09 	restore  %g0, 9, %o0                           <== NOT EXECUTED
  const uint8_t *data = NULL;                                         
  int fd = -1;                                                        
  rtems_disk_device *dd = NULL;                                       
                                                                      
  /* Check parameter */                                               
  if (format == NULL || pt == NULL || count == NULL) {                
40002e78:	80 a6 60 00 	cmp  %i1, 0                                    
40002e7c:	02 bf ff fd 	be  40002e70 <rtems_bdpart_read+0x38>          <== NEVER TAKEN
40002e80:	90 10 00 18 	mov  %i0, %o0                                  
    return RTEMS_INVALID_ADDRESS;                                     
  }                                                                   
                                                                      
  /* Set count to a save value */                                     
  *count = 0;                                                         
40002e84:	c0 26 c0 00 	clr  [ %i3 ]                                   
                                                                      
  /* Get disk data */                                                 
  sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);   
40002e88:	92 07 bf f8 	add  %fp, -8, %o1                              
40002e8c:	94 07 bf fc 	add  %fp, -4, %o2                              
40002e90:	7f ff ff bf 	call  40002d8c <rtems_bdpart_get_disk_data>    
40002e94:	96 07 bf f4 	add  %fp, -12, %o3                             
  if (sc != RTEMS_SUCCESSFUL) {                                       
40002e98:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40002e9c:	12 80 00 14 	bne  40002eec <rtems_bdpart_read+0xb4>         <== NEVER TAKEN
40002ea0:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
    return sc;                                                        
  }                                                                   
                                                                      
  /* Read MBR */                                                      
  sc = rtems_bdpart_read_record( dd, 0, &block);                      
40002ea4:	92 10 20 00 	clr  %o1                                       
40002ea8:	7f ff ff 44 	call  40002bb8 <rtems_bdpart_read_record>      
40002eac:	94 07 bf e8 	add  %fp, -24, %o2                             
  if (sc != RTEMS_SUCCESSFUL) {                                       
40002eb0:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40002eb4:	02 80 00 10 	be  40002ef4 <rtems_bdpart_read+0xbc>          <== ALWAYS TAKEN
40002eb8:	c4 07 bf e8 	ld  [ %fp + -24 ], %g2                         
  /* Return partition count */                                        
  *count = (size_t) (p - pt + 1);                                     
                                                                      
cleanup:                                                              
                                                                      
  if (fd >= 0) {                                                      
40002ebc:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0                          
40002ec0:	80 a2 20 00 	cmp  %o0, 0                                    
40002ec4:	26 80 00 05 	bl,a   40002ed8 <rtems_bdpart_read+0xa0>       <== NEVER TAKEN
40002ec8:	d0 07 bf e8 	ld  [ %fp + -24 ], %o0                         <== NOT EXECUTED
    close( fd);                                                       
40002ecc:	40 00 09 09 	call  400052f0 <close>                         
40002ed0:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  if (block != NULL) {                                                
40002ed4:	d0 07 bf e8 	ld  [ %fp + -24 ], %o0                         
40002ed8:	80 a2 20 00 	cmp  %o0, 0                                    
40002edc:	02 80 00 04 	be  40002eec <rtems_bdpart_read+0xb4>          <== NEVER TAKEN
40002ee0:	01 00 00 00 	nop                                            
    rtems_bdbuf_release( block);                                      
40002ee4:	40 00 34 c3 	call  400101f0 <rtems_bdbuf_release>           
40002ee8:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  return esc;                                                         
}                                                                     
40002eec:	81 c7 e0 08 	ret                                            
40002ef0:	81 e8 00 00 	restore                                        
{                                                                     
  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);
40002ef4:	83 2f 60 04 	sll  %i5, 4, %g1                               
    esc = sc;                                                         
    goto cleanup;                                                     
  }                                                                   
                                                                      
  /* Read the first partition entry */                                
  data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;             
40002ef8:	e2 00 a0 1c 	ld  [ %g2 + 0x1c ], %l1                        
{                                                                     
  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);
40002efc:	b9 2f 60 06 	sll  %i5, 6, %i4                               
    esc = sc;                                                         
    goto cleanup;                                                     
  }                                                                   
                                                                      
  /* Read the first partition entry */                                
  data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;             
40002f00:	a0 04 61 be 	add  %l1, 0x1be, %l0                           
{                                                                     
  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);
40002f04:	b8 27 00 01 	sub  %i4, %g1, %i4                             
    goto cleanup;                                                     
  }                                                                   
                                                                      
  /* Read the first partition entry */                                
  data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;             
  sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);  
40002f08:	90 10 00 10 	mov  %l0, %o0                                  
{                                                                     
  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);
40002f0c:	b8 06 80 1c 	add  %i2, %i4, %i4                             
    goto cleanup;                                                     
  }                                                                   
                                                                      
  /* Read the first partition entry */                                
  data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;             
  sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);  
40002f10:	92 07 bf ec 	add  %fp, -20, %o1                             
40002f14:	94 10 00 1c 	mov  %i4, %o2                                  
40002f18:	7f ff ff 54 	call  40002c68 <rtems_bdpart_read_mbr_partition>
40002f1c:	96 07 bf f0 	add  %fp, -16, %o3                             
  if (sc != RTEMS_SUCCESSFUL) {                                       
40002f20:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40002f24:	32 bf ff e7 	bne,a   40002ec0 <rtems_bdpart_read+0x88>      <== NEVER TAKEN
40002f28:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0                          <== 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) {
40002f2c:	c2 07 bf ec 	ld  [ %fp + -20 ], %g1                         
40002f30:	c2 08 60 08 	ldub  [ %g1 + 8 ], %g1                         
40002f34:	80 a0 60 ee 	cmp  %g1, 0xee                                 
40002f38:	02 bf ff e1 	be  40002ebc <rtems_bdpart_read+0x84>          <== NEVER TAKEN
40002f3c:	b0 10 20 18 	mov  0x18, %i0                                 
  }                                                                   
                                                                      
  /* Set format */                                                    
  format->type = RTEMS_BDPART_FORMAT_MBR;                             
  format->mbr.disk_id = rtems_uint32_from_little_endian(              
    block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID                   
40002f40:	c2 07 bf e8 	ld  [ %fp + -24 ], %g1                         
    esc = RTEMS_NOT_IMPLEMENTED;                                      
    goto cleanup;                                                     
  }                                                                   
                                                                      
  /* Set format */                                                    
  format->type = RTEMS_BDPART_FORMAT_MBR;                             
40002f44:	c0 26 40 00 	clr  [ %i1 ]                                   
  format->mbr.disk_id = rtems_uint32_from_little_endian(              
    block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID                   
40002f48:	c8 00 60 1c 	ld  [ %g1 + 0x1c ], %g4                        
  return value;                                                       
}                                                                     
                                                                      
static inline uint32_t rtems_uint32_from_little_endian( const uint8_t *data)
{                                                                     
  uint32_t value = 0;                                                 
40002f4c:	84 10 20 00 	clr  %g2                                       
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
                                                                      
rtems_status_code rtems_bdpart_read(                                  
40002f50:	82 01 21 bb 	add  %g4, 0x1bb, %g1                           
40002f54:	88 01 21 b7 	add  %g4, 0x1b7, %g4                           
  ssize_t i = 0;                                                      
                                                                      
  for (i = 3; i >= 0; --i) {                                          
    value = (value << 8) + data [i];                                  
40002f58:	c6 08 40 00 	ldub  [ %g1 ], %g3                             
40002f5c:	85 28 a0 08 	sll  %g2, 8, %g2                               
40002f60:	82 00 7f ff 	add  %g1, -1, %g1                              
static inline uint32_t rtems_uint32_from_little_endian( const uint8_t *data)
{                                                                     
  uint32_t value = 0;                                                 
  ssize_t i = 0;                                                      
                                                                      
  for (i = 3; i >= 0; --i) {                                          
40002f64:	80 a0 40 04 	cmp  %g1, %g4                                  
40002f68:	12 bf ff fc 	bne  40002f58 <rtems_bdpart_read+0x120>        
40002f6c:	84 00 c0 02 	add  %g3, %g2, %g2                             
  /* Set format */                                                    
  format->type = RTEMS_BDPART_FORMAT_MBR;                             
  format->mbr.disk_id = rtems_uint32_from_little_endian(              
    block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID                   
  );                                                                  
  format->mbr.dos_compatibility = true;                               
40002f70:	82 10 20 01 	mov  1, %g1                                    
    goto cleanup;                                                     
  }                                                                   
                                                                      
  /* Set format */                                                    
  format->type = RTEMS_BDPART_FORMAT_MBR;                             
  format->mbr.disk_id = rtems_uint32_from_little_endian(              
40002f74:	c4 26 60 04 	st  %g2, [ %i1 + 4 ]                           
    block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID                   
  );                                                                  
  format->mbr.dos_compatibility = true;                               
40002f78:	c2 2e 60 08 	stb  %g1, [ %i1 + 8 ]                          
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
                                                                      
rtems_status_code rtems_bdpart_read(                                  
40002f7c:	a2 04 61 ee 	add  %l1, 0x1ee, %l1                           
  );                                                                  
  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;                        
40002f80:	a0 04 20 10 	add  %l0, 0x10, %l0                            
                                                                      
    sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
40002f84:	92 07 bf ec 	add  %fp, -20, %o1                             
40002f88:	90 10 00 10 	mov  %l0, %o0                                  
40002f8c:	94 10 00 1c 	mov  %i4, %o2                                  
40002f90:	7f ff ff 36 	call  40002c68 <rtems_bdpart_read_mbr_partition>
40002f94:	96 07 bf f0 	add  %fp, -16, %o3                             
    if (sc != RTEMS_SUCCESSFUL) {                                     
40002f98:	80 a2 20 00 	cmp  %o0, 0                                    
40002f9c:	12 80 00 4a 	bne  400030c4 <rtems_bdpart_read+0x28c>        <== NEVER TAKEN
40002fa0:	80 a4 00 11 	cmp  %l0, %l1                                  
    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) {                                           
40002fa4:	32 bf ff f8 	bne,a   40002f84 <rtems_bdpart_read+0x14c>     
40002fa8:	a0 04 20 10 	add  %l0, 0x10, %l0                            
      goto cleanup;                                                   
    }                                                                 
  }                                                                   
                                                                      
  /* Iterate through the logical partitions within the extended partition */
  ebr = ep_begin;                                                     
40002fac:	fa 07 bf f0 	ld  [ %fp + -16 ], %i5                         
  while (ebr != 0) {                                                  
40002fb0:	80 a7 60 00 	cmp  %i5, 0                                    
40002fb4:	02 80 00 2c 	be  40003064 <rtems_bdpart_read+0x22c>         <== NEVER TAKEN
40002fb8:	c8 07 bf ec 	ld  [ %fp + -20 ], %g4                         
    rtems_blkdev_bnum tmp = 0;                                        
                                                                      
    /* Read EBR */                                                    
    sc = rtems_bdpart_read_record( dd, ebr, &block);                  
40002fbc:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
40002fc0:	92 10 00 1d 	mov  %i5, %o1                                  
40002fc4:	7f ff fe fd 	call  40002bb8 <rtems_bdpart_read_record>      
40002fc8:	94 07 bf e8 	add  %fp, -24, %o2                             
    if (sc != RTEMS_SUCCESSFUL) {                                     
40002fcc:	80 a2 20 00 	cmp  %o0, 0                                    
40002fd0:	12 80 00 3d 	bne  400030c4 <rtems_bdpart_read+0x28c>        <== NEVER TAKEN
40002fd4:	c2 07 bf e8 	ld  [ %fp + -24 ], %g1                         
      esc = sc;                                                       
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Read first partition entry */                                  
    sc = rtems_bdpart_read_mbr_partition(                             
40002fd8:	92 07 bf ec 	add  %fp, -20, %o1                             
40002fdc:	d0 00 60 1c 	ld  [ %g1 + 0x1c ], %o0                        
40002fe0:	94 10 00 1c 	mov  %i4, %o2                                  
40002fe4:	90 02 21 be 	add  %o0, 0x1be, %o0                           
40002fe8:	7f ff ff 20 	call  40002c68 <rtems_bdpart_read_mbr_partition>
40002fec:	96 10 20 00 	clr  %o3                                       
      block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,                
      &p,                                                             
      p_end,                                                          
      NULL                                                            
    );                                                                
    if (sc != RTEMS_SUCCESSFUL) {                                     
40002ff0:	80 a2 20 00 	cmp  %o0, 0                                    
40002ff4:	12 80 00 34 	bne  400030c4 <rtems_bdpart_read+0x28c>        <== NEVER TAKEN
40002ff8:	c8 07 bf ec 	ld  [ %fp + -20 ], %g4                         
      esc = sc;                                                       
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Adjust partition begin */                                      
    tmp = p->begin + ebr;                                             
40002ffc:	c2 01 00 00 	ld  [ %g4 ], %g1                               
40003000:	84 07 40 01 	add  %i5, %g1, %g2                             
    if (tmp > p->begin) {                                             
40003004:	80 a0 40 02 	cmp  %g1, %g2                                  
40003008:	3a bf ff ad 	bcc,a   40002ebc <rtems_bdpart_read+0x84>      <== NEVER TAKEN
4000300c:	b0 10 20 1b 	mov  0x1b, %i0                                 <== NOT EXECUTED
      esc = RTEMS_IO_ERROR;                                           
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Adjust partition end */                                        
    tmp = p->end + ebr;                                               
40003010:	c2 01 20 04 	ld  [ %g4 + 4 ], %g1                           
40003014:	ba 07 40 01 	add  %i5, %g1, %i5                             
    if (tmp > p->end) {                                               
40003018:	80 a0 40 1d 	cmp  %g1, %i5                                  
4000301c:	1a 80 00 28 	bcc  400030bc <rtems_bdpart_read+0x284>        <== NEVER TAKEN
40003020:	c4 21 00 00 	st  %g2, [ %g4 ]                               
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Read second partition entry for next EBR block */              
    ebr = rtems_bdpart_next_ebr(                                      
      block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1                 
40003024:	c2 07 bf e8 	ld  [ %fp + -24 ], %g1                         
    }                                                                 
                                                                      
    /* Adjust partition end */                                        
    tmp = p->end + ebr;                                               
    if (tmp > p->end) {                                               
      p->end = tmp;                                                   
40003028:	fa 21 20 04 	st  %i5, [ %g4 + 4 ]                           
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Read second partition entry for next EBR block */              
    ebr = rtems_bdpart_next_ebr(                                      
      block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1                 
4000302c:	f2 00 60 1c 	ld  [ %g1 + 0x1c ], %i1                        
  return value;                                                       
}                                                                     
                                                                      
static inline uint32_t rtems_uint32_from_little_endian( const uint8_t *data)
{                                                                     
  uint32_t value = 0;                                                 
40003030:	84 10 20 00 	clr  %g2                                       
  ssize_t i = 0;                                                      
                                                                      
  for (i = 3; i >= 0; --i) {                                          
40003034:	82 10 20 03 	mov  3, %g1                                    
}                                                                     
                                                                      
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);
40003038:	ba 06 61 d6 	add  %i1, 0x1d6, %i5                           
    value = (value << 8) + data [i];                                  
4000303c:	c6 0f 40 01 	ldub  [ %i5 + %g1 ], %g3                       
40003040:	85 28 a0 08 	sll  %g2, 8, %g2                               
static inline uint32_t rtems_uint32_from_little_endian( const uint8_t *data)
{                                                                     
  uint32_t value = 0;                                                 
  ssize_t i = 0;                                                      
                                                                      
  for (i = 3; i >= 0; --i) {                                          
40003044:	82 00 7f ff 	add  %g1, -1, %g1                              
40003048:	80 a0 7f ff 	cmp  %g1, -1                                   
4000304c:	12 bf ff fc 	bne  4000303c <rtems_bdpart_read+0x204>        
40003050:	84 00 c0 02 	add  %g3, %g2, %g2                             
  uint8_t type = data [RTEMS_BDPART_MBR_OFFSET_TYPE];                 
                                                                      
  if (type == RTEMS_BDPART_MBR_EXTENDED) {                            
40003054:	c2 0e 61 d2 	ldub  [ %i1 + 0x1d2 ], %g1                     
40003058:	80 a0 60 05 	cmp  %g1, 5                                    
4000305c:	02 80 00 11 	be  400030a0 <rtems_bdpart_read+0x268>         
40003060:	80 a0 a0 00 	cmp  %g2, 0                                    
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  /* Return partition count */                                        
  *count = (size_t) (p - pt + 1);                                     
40003064:	82 21 00 1a 	sub  %g4, %i2, %g1                             
40003068:	83 38 60 04 	sra  %g1, 4, %g1                               
4000306c:	85 28 60 02 	sll  %g1, 2, %g2                               
40003070:	82 00 80 01 	add  %g2, %g1, %g1                             
40003074:	85 28 60 04 	sll  %g1, 4, %g2                               
40003078:	82 00 40 02 	add  %g1, %g2, %g1                             
4000307c:	85 28 60 08 	sll  %g1, 8, %g2                               
  rtems_bdpart_partition *pt,                                         
  size_t *count                                                       
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
40003080:	b0 10 20 00 	clr  %i0                                       
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  /* Return partition count */                                        
  *count = (size_t) (p - pt + 1);                                     
40003084:	82 00 40 02 	add  %g1, %g2, %g1                             
40003088:	85 28 60 10 	sll  %g1, 0x10, %g2                            
4000308c:	82 00 40 02 	add  %g1, %g2, %g1                             
40003090:	82 20 00 01 	neg  %g1                                       
40003094:	82 00 60 01 	inc  %g1                                       
40003098:	10 bf ff 89 	b  40002ebc <rtems_bdpart_read+0x84>           
4000309c:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
                                                                      
    /* Read second partition entry for next EBR block */              
    ebr = rtems_bdpart_next_ebr(                                      
      block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1                 
    );                                                                
    if (ebr != 0) {                                                   
400030a0:	02 bf ff f2 	be  40003068 <rtems_bdpart_read+0x230>         <== NEVER TAKEN
400030a4:	82 21 00 1a 	sub  %g4, %i2, %g1                             
      /* Adjust partition EBR block index */                          
      tmp = ebr + ep_begin;                                           
400030a8:	fa 07 bf f0 	ld  [ %fp + -16 ], %i5                         
400030ac:	ba 00 80 1d 	add  %g2, %i5, %i5                             
      if (tmp > ebr) {                                                
400030b0:	80 a7 40 02 	cmp  %i5, %g2                                  
400030b4:	18 bf ff c3 	bgu  40002fc0 <rtems_bdpart_read+0x188>        <== ALWAYS TAKEN
400030b8:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
    /* Adjust partition begin */                                      
    tmp = p->begin + ebr;                                             
    if (tmp > p->begin) {                                             
      p->begin = tmp;                                                 
    } else {                                                          
      esc = RTEMS_IO_ERROR;                                           
400030bc:	10 bf ff 80 	b  40002ebc <rtems_bdpart_read+0x84>           <== NOT EXECUTED
400030c0:	b0 10 20 1b 	mov  0x1b, %i0                                 <== NOT EXECUTED
      esc = sc;                                                       
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Read first partition entry */                                  
    sc = rtems_bdpart_read_mbr_partition(                             
400030c4:	10 bf ff 7e 	b  40002ebc <rtems_bdpart_read+0x84>           <== NOT EXECUTED
400030c8:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
                                                                      

40002c68 <rtems_bdpart_read_mbr_partition>: const uint8_t *data, rtems_bdpart_partition **p, const rtems_bdpart_partition *p_end, rtems_blkdev_bnum *ep_begin ) {
40002c68:	9d e3 bf a0 	save  %sp, -96, %sp                            
  return value;                                                       
}                                                                     
                                                                      
static inline uint32_t rtems_uint32_from_little_endian( const uint8_t *data)
{                                                                     
  uint32_t value = 0;                                                 
40002c6c:	ba 10 20 00 	clr  %i5                                       
  } else {                                                            
    return 0;                                                         
  }                                                                   
}                                                                     
                                                                      
static rtems_status_code rtems_bdpart_read_mbr_partition(             
40002c70:	88 06 20 0b 	add  %i0, 0xb, %g4                             
  const uint8_t *data,                                                
  rtems_bdpart_partition **p,                                         
  const rtems_bdpart_partition *p_end,                                
  rtems_blkdev_bnum *ep_begin                                         
)                                                                     
{                                                                     
40002c74:	b8 10 00 18 	mov  %i0, %i4                                  
  } else {                                                            
    return 0;                                                         
  }                                                                   
}                                                                     
                                                                      
static rtems_status_code rtems_bdpart_read_mbr_partition(             
40002c78:	82 10 00 04 	mov  %g4, %g1                                  
40002c7c:	86 06 20 07 	add  %i0, 7, %g3                               
  ssize_t i = 0;                                                      
                                                                      
  for (i = 3; i >= 0; --i) {                                          
    value = (value << 8) + data [i];                                  
40002c80:	c4 08 40 00 	ldub  [ %g1 ], %g2                             
40002c84:	bb 2f 60 08 	sll  %i5, 8, %i5                               
40002c88:	82 00 7f ff 	add  %g1, -1, %g1                              
static inline uint32_t rtems_uint32_from_little_endian( const uint8_t *data)
{                                                                     
  uint32_t value = 0;                                                 
  ssize_t i = 0;                                                      
                                                                      
  for (i = 3; i >= 0; --i) {                                          
40002c8c:	80 a0 40 03 	cmp  %g1, %g3                                  
40002c90:	12 bf ff fc 	bne  40002c80 <rtems_bdpart_read_mbr_partition+0x18>
40002c94:	ba 00 80 1d 	add  %g2, %i5, %i5                             
40002c98:	82 07 20 0f 	add  %i4, 0xf, %g1                             
  return value;                                                       
}                                                                     
                                                                      
static inline uint32_t rtems_uint32_from_little_endian( const uint8_t *data)
{                                                                     
  uint32_t value = 0;                                                 
40002c9c:	84 10 20 00 	clr  %g2                                       
  ssize_t i = 0;                                                      
                                                                      
  for (i = 3; i >= 0; --i) {                                          
    value = (value << 8) + data [i];                                  
40002ca0:	c6 08 40 00 	ldub  [ %g1 ], %g3                             
40002ca4:	85 28 a0 08 	sll  %g2, 8, %g2                               
40002ca8:	82 00 7f ff 	add  %g1, -1, %g1                              
static inline uint32_t rtems_uint32_from_little_endian( const uint8_t *data)
{                                                                     
  uint32_t value = 0;                                                 
  ssize_t i = 0;                                                      
                                                                      
  for (i = 3; i >= 0; --i) {                                          
40002cac:	80 a0 40 04 	cmp  %g1, %g4                                  
40002cb0:	12 bf ff fc 	bne  40002ca0 <rtems_bdpart_read_mbr_partition+0x38>
40002cb4:	84 00 c0 02 	add  %g3, %g2, %g2                             
  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) {                               
40002cb8:	e0 0f 20 04 	ldub  [ %i4 + 4 ], %l0                         
40002cbc:	80 a4 20 00 	cmp  %l0, 0                                    
40002cc0:	02 80 00 0a 	be  40002ce8 <rtems_bdpart_read_mbr_partition+0x80><== NEVER TAKEN
40002cc4:	b0 10 20 00 	clr  %i0                                       
    return RTEMS_SUCCESSFUL;                                          
  } else if (*p == p_end) {                                           
40002cc8:	c2 06 40 00 	ld  [ %i1 ], %g1                               
40002ccc:	80 a0 40 1a 	cmp  %g1, %i2                                  
40002cd0:	02 80 00 06 	be  40002ce8 <rtems_bdpart_read_mbr_partition+0x80><== NEVER TAKEN
40002cd4:	b0 10 20 05 	mov  5, %i0                                    
{                                                                     
  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;                               
40002cd8:	b4 00 80 1d 	add  %g2, %i5, %i2                             
                                                                      
  if (type == RTEMS_BDPART_MBR_EMPTY) {                               
    return RTEMS_SUCCESSFUL;                                          
  } else if (*p == p_end) {                                           
    return RTEMS_TOO_MANY;                                            
  } else if (begin >= end) {                                          
40002cdc:	80 a6 80 1d 	cmp  %i2, %i5                                  
40002ce0:	18 80 00 04 	bgu  40002cf0 <rtems_bdpart_read_mbr_partition+0x88><== ALWAYS TAKEN
40002ce4:	b0 10 20 1b 	mov  0x1b, %i0                                 
    rtems_bdpart_to_partition_type( type, (*p)->type);                
    (*p)->flags = data [RTEMS_BDPART_MBR_OFFSET_FLAGS];               
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
40002ce8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40002cec:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    return RTEMS_SUCCESSFUL;                                          
  } else if (*p == p_end) {                                           
    return RTEMS_TOO_MANY;                                            
  } else if (begin >= end) {                                          
    return RTEMS_IO_ERROR;                                            
  } else if (type == RTEMS_BDPART_MBR_EXTENDED) {                     
40002cf0:	80 a4 20 05 	cmp  %l0, 5                                    
40002cf4:	12 80 00 08 	bne  40002d14 <rtems_bdpart_read_mbr_partition+0xac>
40002cf8:	90 00 60 30 	add  %g1, 0x30, %o0                            
    if (ep_begin != NULL) {                                           
40002cfc:	80 a6 e0 00 	cmp  %i3, 0                                    
40002d00:	02 80 00 15 	be  40002d54 <rtems_bdpart_read_mbr_partition+0xec><== NEVER TAKEN
40002d04:	01 00 00 00 	nop                                            
      *ep_begin = begin;                                              
40002d08:	fa 26 c0 00 	st  %i5, [ %i3 ]                               
    (*p)->end = end;                                                  
    rtems_bdpart_to_partition_type( type, (*p)->type);                
    (*p)->flags = data [RTEMS_BDPART_MBR_OFFSET_FLAGS];               
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
40002d0c:	81 c7 e0 08 	ret                                            
40002d10:	91 e8 20 00 	restore  %g0, 0, %o0                           
  } else {                                                            
    /* Increment partition index */                                   
    ++(*p);                                                           
                                                                      
    /* Clear partition */                                             
    memset( *p, 0, sizeof( rtems_bdpart_partition));                  
40002d14:	94 10 20 30 	mov  0x30, %o2                                 
40002d18:	92 10 20 00 	clr  %o1                                       
40002d1c:	40 00 4c 4a 	call  40015e44 <memset>                        
40002d20:	d0 26 40 00 	st  %o0, [ %i1 ]                               
                                                                      
    /* Set values */                                                  
    (*p)->begin = begin;                                              
40002d24:	d2 06 40 00 	ld  [ %i1 ], %o1                               
    (*p)->end = end;                                                  
    rtems_bdpart_to_partition_type( type, (*p)->type);                
40002d28:	90 10 00 10 	mov  %l0, %o0                                  
                                                                      
    /* Clear partition */                                             
    memset( *p, 0, sizeof( rtems_bdpart_partition));                  
                                                                      
    /* Set values */                                                  
    (*p)->begin = begin;                                              
40002d2c:	fa 22 40 00 	st  %i5, [ %o1 ]                               
    (*p)->end = end;                                                  
40002d30:	f4 22 60 04 	st  %i2, [ %o1 + 4 ]                           
    rtems_bdpart_to_partition_type( type, (*p)->type);                
40002d34:	7f ff ff c4 	call  40002c44 <rtems_bdpart_to_partition_type>
40002d38:	92 02 60 08 	add  %o1, 8, %o1                               
    (*p)->flags = data [RTEMS_BDPART_MBR_OFFSET_FLAGS];               
40002d3c:	c2 06 40 00 	ld  [ %i1 ], %g1                               
40002d40:	c4 0f 00 00 	ldub  [ %i4 ], %g2                             
40002d44:	c0 20 60 28 	clr  [ %g1 + 0x28 ]                            
40002d48:	c4 20 60 2c 	st  %g2, [ %g1 + 0x2c ]                        
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
40002d4c:	81 c7 e0 08 	ret                                            
40002d50:	91 e8 20 00 	restore  %g0, 0, %o0                           
}                                                                     
40002d54:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40002d58:	91 e8 20 00 	restore  %g0, 0, %o0                           <== NOT EXECUTED
                                                                      

40002bb8 <rtems_bdpart_read_record>: static rtems_status_code rtems_bdpart_read_record( rtems_disk_device *dd, rtems_blkdev_bnum index, rtems_bdbuf_buffer **block ) {
40002bb8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  /* Release previous block if necessary */                           
  if (*block != NULL) {                                               
40002bbc:	d0 06 80 00 	ld  [ %i2 ], %o0                               
40002bc0:	80 a2 20 00 	cmp  %o0, 0                                    
40002bc4:	22 80 00 08 	be,a   40002be4 <rtems_bdpart_read_record+0x2c>
40002bc8:	90 10 00 18 	mov  %i0, %o0                                  
    sc = rtems_bdbuf_release( *block);                                
40002bcc:	40 00 35 89 	call  400101f0 <rtems_bdbuf_release>           
40002bd0:	01 00 00 00 	nop                                            
    if (sc != RTEMS_SUCCESSFUL) {                                     
40002bd4:	80 a2 20 00 	cmp  %o0, 0                                    
40002bd8:	12 80 00 13 	bne  40002c24 <rtems_bdpart_read_record+0x6c>  <== NEVER TAKEN
40002bdc:	01 00 00 00 	nop                                            
      return sc;                                                      
    }                                                                 
  }                                                                   
                                                                      
  /* Read the record block */                                         
  sc = rtems_bdbuf_read( dd, index, block);                           
40002be0:	90 10 00 18 	mov  %i0, %o0                                  
40002be4:	92 10 00 19 	mov  %i1, %o1                                  
40002be8:	40 00 34 fd 	call  4000ffdc <rtems_bdbuf_read>              
40002bec:	94 10 00 1a 	mov  %i2, %o2                                  
  if (sc != RTEMS_SUCCESSFUL) {                                       
40002bf0:	80 a2 20 00 	cmp  %o0, 0                                    
40002bf4:	12 80 00 0c 	bne  40002c24 <rtems_bdpart_read_record+0x6c>  <== NEVER TAKEN
40002bf8:	01 00 00 00 	nop                                            
    return sc;                                                        
  }                                                                   
                                                                      
  /* just in case block did not get filled in */                      
  if ( *block == NULL ) {                                             
40002bfc:	c2 06 80 00 	ld  [ %i2 ], %g1                               
40002c00:	80 a0 60 00 	cmp  %g1, 0                                    
40002c04:	22 80 00 0e 	be,a   40002c3c <rtems_bdpart_read_record+0x84><== NEVER TAKEN
40002c08:	90 10 20 09 	mov  9, %o0                                    <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
  }                                                                   
                                                                      
  /* Check MBR signature */                                           
  if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {             
40002c0c:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        
                                                                      
static bool rtems_bdpart_is_valid_record( const uint8_t *data)        
{                                                                     
  return data [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_0]                   
      == RTEMS_BDPART_MBR_SIGNATURE_0                                 
    && data [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_1]                     
40002c10:	c4 08 61 fe 	ldub  [ %g1 + 0x1fe ], %g2                     
40002c14:	80 a0 a0 55 	cmp  %g2, 0x55                                 
40002c18:	22 80 00 05 	be,a   40002c2c <rtems_bdpart_read_record+0x74><== ALWAYS TAKEN
40002c1c:	c2 08 61 ff 	ldub  [ %g1 + 0x1ff ], %g1                     
    return RTEMS_INVALID_ADDRESS;                                     
  }                                                                   
                                                                      
  /* Check MBR signature */                                           
  if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {             
    return RTEMS_IO_ERROR;                                            
40002c20:	90 10 20 1b 	mov  0x1b, %o0                                 <== NOT EXECUTED
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
40002c24:	81 c7 e0 08 	ret                                            
40002c28:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      
static bool rtems_bdpart_is_valid_record( const uint8_t *data)        
{                                                                     
  return data [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_0]                   
      == RTEMS_BDPART_MBR_SIGNATURE_0                                 
    && data [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_1]                     
40002c2c:	80 a0 60 aa 	cmp  %g1, 0xaa                                 
40002c30:	32 bf ff fd 	bne,a   40002c24 <rtems_bdpart_read_record+0x6c><== NEVER TAKEN
40002c34:	90 10 20 1b 	mov  0x1b, %o0                                 <== NOT EXECUTED
40002c38:	30 bf ff fb 	b,a   40002c24 <rtems_bdpart_read_record+0x6c> 
  if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {             
    return RTEMS_IO_ERROR;                                            
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
40002c3c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40002c40:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
                                                                      

400030cc <rtems_bdpart_register>: rtems_status_code rtems_bdpart_register( const char *disk_name, const rtems_bdpart_partition *pt, size_t count ) {
400030cc:	9d e3 bf 88 	save  %sp, -120, %sp                           
  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);                         
400030d0:	90 10 00 18 	mov  %i0, %o0                                  
400030d4:	40 00 4d 0e 	call  4001650c <strlen>                        
400030d8:	c0 27 bf f4 	clr  [ %fp + -12 ]                             
  size_t i = 0;                                                       
  int fd = -1;                                                        
400030dc:	82 10 3f ff 	mov  -1, %g1                                   
rtems_status_code rtems_bdpart_register(                              
  const char *disk_name,                                              
  const rtems_bdpart_partition *pt,                                   
  size_t count                                                        
)                                                                     
{                                                                     
400030e0:	ba 10 00 18 	mov  %i0, %i5                                  
  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);                         
400030e4:	a4 10 00 08 	mov  %o0, %l2                                  
  size_t i = 0;                                                       
  int fd = -1;                                                        
400030e8:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]                          
  rtems_disk_device *dd = NULL;                                       
                                                                      
  /* Get disk data */                                                 
  sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);   
400030ec:	90 10 00 18 	mov  %i0, %o0                                  
  char *logical_disk_name = NULL;                                     
  char *logical_disk_marker = NULL;                                   
  size_t disk_name_size = strlen( disk_name);                         
  size_t i = 0;                                                       
  int fd = -1;                                                        
  rtems_disk_device *dd = NULL;                                       
400030f0:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
                                                                      
  /* Get disk data */                                                 
  sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);   
400030f4:	92 07 bf f8 	add  %fp, -8, %o1                              
400030f8:	94 07 bf fc 	add  %fp, -4, %o2                              
400030fc:	7f ff ff 24 	call  40002d8c <rtems_bdpart_get_disk_data>    
40003100:	96 07 bf f4 	add  %fp, -12, %o3                             
  if (sc != RTEMS_SUCCESSFUL) {                                       
40003104:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40003108:	12 80 00 32 	bne  400031d0 <rtems_bdpart_register+0x104>    <== NEVER TAKEN
4000310c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
    return sc;                                                        
  }                                                                   
  disk = rtems_disk_get_device_identifier( dd);                       
  close( fd);                                                         
40003110:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0                          
                                                                      
static inline dev_t rtems_disk_get_device_identifier(                 
  const rtems_disk_device *dd                                         
)                                                                     
{                                                                     
  return dd->dev;                                                     
40003114:	e2 00 60 04 	ld  [ %g1 + 4 ], %l1                           
40003118:	40 00 08 76 	call  400052f0 <close>                         
4000311c:	f6 00 40 00 	ld  [ %g1 ], %i3                               
                                                                      
  /* Get the disk device identifier */                                
  rtems_filesystem_split_dev_t( disk, major, minor);                  
                                                                      
  /* Create logical disk name */                                      
  logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
40003120:	90 04 a0 04 	add  %l2, 4, %o0                               
40003124:	40 00 0a 32 	call  400059ec <malloc>                        
40003128:	b8 10 00 11 	mov  %l1, %i4                                  
  if (logical_disk_name == NULL) {                                    
    return RTEMS_NO_MEMORY;                                           
4000312c:	b0 10 20 1a 	mov  0x1a, %i0                                 
  /* Get the disk device identifier */                                
  rtems_filesystem_split_dev_t( disk, major, minor);                  
                                                                      
  /* Create logical disk name */                                      
  logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
  if (logical_disk_name == NULL) {                                    
40003130:	80 a2 20 00 	cmp  %o0, 0                                    
40003134:	02 80 00 27 	be  400031d0 <rtems_bdpart_register+0x104>     <== NEVER TAKEN
40003138:	a0 10 00 08 	mov  %o0, %l0                                  
    return RTEMS_NO_MEMORY;                                           
  }                                                                   
  strncpy( logical_disk_name, disk_name, disk_name_size);             
4000313c:	92 10 00 1d 	mov  %i5, %o1                                  
40003140:	40 00 4d 7b 	call  4001672c <strncpy>                       
40003144:	94 10 00 12 	mov  %l2, %o2                                  
                                                                      
    /* 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);
40003148:	31 10 00 95 	sethi  %hi(0x40025400), %i0                    
  logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
  if (logical_disk_name == NULL) {                                    
    return RTEMS_NO_MEMORY;                                           
  }                                                                   
  strncpy( logical_disk_name, disk_name, disk_name_size);             
  logical_disk_marker = logical_disk_name + disk_name_size;           
4000314c:	a4 04 00 12 	add  %l0, %l2, %l2                             
                                                                      
  /* Create a logical disk for each partition */                      
  for (i = 0; i < count; ++i) {                                       
40003150:	ba 10 20 00 	clr  %i5                                       
40003154:	80 a6 a0 00 	cmp  %i2, 0                                    
40003158:	12 80 00 06 	bne  40003170 <rtems_bdpart_register+0xa4>     <== ALWAYS TAKEN
4000315c:	b0 16 22 40 	or  %i0, 0x240, %i0                            
  const rtems_bdpart_partition *pt,                                   
  size_t count                                                        
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
40003160:	10 80 00 1a 	b  400031c8 <rtems_bdpart_register+0xfc>       <== NOT EXECUTED
40003164:	b0 10 20 00 	clr  %i0                                       <== 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) {                                       
40003168:	02 80 00 1c 	be  400031d8 <rtems_bdpart_register+0x10c>     
4000316c:	b2 06 60 30 	add  %i1, 0x30, %i1                            
                                                                      
    /* 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);
40003170:	92 10 20 04 	mov  4, %o1                                    
40003174:	94 10 00 18 	mov  %i0, %o2                                  
40003178:	ba 07 60 01 	inc  %i5                                       
4000317c:	90 10 00 12 	mov  %l2, %o0                                  
40003180:	40 00 4b f4 	call  40016150 <snprintf>                      
40003184:	96 10 00 1d 	mov  %i5, %o3                                  
  for (i = 0; i < count; ++i) {                                       
    const rtems_bdpart_partition *p = pt + i;                         
    int rv = 0;                                                       
                                                                      
    /* New minor number */                                            
    ++minor;                                                          
40003188:	b8 07 20 01 	inc  %i4                                       
    /* 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) {                             
4000318c:	80 a2 20 03 	cmp  %o0, 3                                    
      esc = RTEMS_INVALID_NAME;                                       
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Create logical disk */                                         
    sc = rtems_disk_create_log(                                       
40003190:	92 10 00 1c 	mov  %i4, %o1                                  
40003194:	94 10 00 1b 	mov  %i3, %o2                                  
40003198:	96 10 00 11 	mov  %l1, %o3                                  
    /* 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) {                             
4000319c:	14 80 00 11 	bg  400031e0 <rtems_bdpart_register+0x114>     <== NEVER TAKEN
400031a0:	90 10 00 1b 	mov  %i3, %o0                                  
      esc = RTEMS_INVALID_NAME;                                       
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Create logical disk */                                         
    sc = rtems_disk_create_log(                                       
400031a4:	da 06 60 04 	ld  [ %i1 + 4 ], %o5                           
      logical_disk,                                                   
      disk,                                                           
      p->begin,                                                       
      p->end - p->begin,                                              
400031a8:	d8 06 40 00 	ld  [ %i1 ], %o4                               
      esc = RTEMS_INVALID_NAME;                                       
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Create logical disk */                                         
    sc = rtems_disk_create_log(                                       
400031ac:	e0 23 a0 5c 	st  %l0, [ %sp + 0x5c ]                        
400031b0:	40 00 03 7d 	call  40003fa4 <rtems_disk_create_log>         
400031b4:	9a 23 40 0c 	sub  %o5, %o4, %o5                             
      disk,                                                           
      p->begin,                                                       
      p->end - p->begin,                                              
      logical_disk_name                                               
    );                                                                
    if (sc != RTEMS_SUCCESSFUL) {                                     
400031b8:	80 a2 20 00 	cmp  %o0, 0                                    
400031bc:	02 bf ff eb 	be  40003168 <rtems_bdpart_register+0x9c>      <== ALWAYS TAKEN
400031c0:	80 a7 40 1a 	cmp  %i5, %i2                                  
      esc = RTEMS_INVALID_NAME;                                       
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Create logical disk */                                         
    sc = rtems_disk_create_log(                                       
400031c4:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
cleanup:                                                              
                                                                      
  free( logical_disk_name);                                           
400031c8:	40 00 08 6c 	call  40005378 <free>                          
400031cc:	90 10 00 10 	mov  %l0, %o0                                  
                                                                      
  return esc;                                                         
}                                                                     
400031d0:	81 c7 e0 08 	ret                                            
400031d4:	81 e8 00 00 	restore                                        
  const rtems_bdpart_partition *pt,                                   
  size_t count                                                        
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
400031d8:	10 bf ff fc 	b  400031c8 <rtems_bdpart_register+0xfc>       
400031dc:	b0 10 20 00 	clr  %i0                                       
    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) {                             
      esc = RTEMS_INVALID_NAME;                                       
400031e0:	10 bf ff fa 	b  400031c8 <rtems_bdpart_register+0xfc>       <== NOT EXECUTED
400031e4:	b0 10 20 03 	mov  3, %i0                                    <== NOT EXECUTED
                                                                      

400031e8 <rtems_bdpart_register_from_disk>: return esc; } rtems_status_code rtems_bdpart_register_from_disk( const char *disk_name) {
400031e8:	9d e3 bc 88 	save  %sp, -888, %sp                           
  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;                  
400031ec:	82 10 20 10 	mov  0x10, %g1                                 
                                                                      
  /* Read partitions */                                               
  sc = rtems_bdpart_read( disk_name, &format, pt, &count);            
400031f0:	90 10 00 18 	mov  %i0, %o0                                  
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;                  
400031f4:	c2 27 bc e8 	st  %g1, [ %fp + -792 ]                        
                                                                      
  /* Read partitions */                                               
  sc = rtems_bdpart_read( disk_name, &format, pt, &count);            
400031f8:	92 07 bc ec 	add  %fp, -788, %o1                            
400031fc:	94 07 bd 00 	add  %fp, -768, %o2                            
40003200:	7f ff ff 0e 	call  40002e38 <rtems_bdpart_read>             
40003204:	96 07 bc e8 	add  %fp, -792, %o3                            
  if (sc != RTEMS_SUCCESSFUL) {                                       
40003208:	80 a2 20 00 	cmp  %o0, 0                                    
4000320c:	12 80 00 05 	bne  40003220 <rtems_bdpart_register_from_disk+0x38><== NEVER TAKEN
40003210:	d4 07 bc e8 	ld  [ %fp + -792 ], %o2                        
    return sc;                                                        
  }                                                                   
                                                                      
  /* Register partitions */                                           
  return rtems_bdpart_register( disk_name, pt, count);                
40003214:	90 10 00 18 	mov  %i0, %o0                                  
40003218:	7f ff ff ad 	call  400030cc <rtems_bdpart_register>         
4000321c:	92 07 bd 00 	add  %fp, -768, %o1                            
}                                                                     
40003220:	81 c7 e0 08 	ret                                            
40003224:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

40023ff4 <rtems_bdpart_unmount>: const char *disk_name, const rtems_bdpart_partition *pt __attribute__((unused)), size_t count, const char *mount_base ) {
40023ff4:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
  const char *disk_file_name = strrchr( disk_name, '/');              
40023ff8:	92 10 20 2f 	mov  0x2f, %o1                                 <== NOT EXECUTED
40023ffc:	40 00 7d 4c 	call  4004352c <strrchr>                       <== NOT EXECUTED
40024000:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40024004:	b8 10 00 08 	mov  %o0, %i4                                  <== 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);                         
40024008:	40 00 79 26 	call  400424a0 <strlen>                        <== NOT EXECUTED
4002400c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40024010:	a0 10 00 08 	mov  %o0, %l0                                  <== NOT EXECUTED
  size_t mount_base_size = strlen( mount_base);                       
40024014:	40 00 79 23 	call  400424a0 <strlen>                        <== NOT EXECUTED
40024018:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
  size_t i = 0;                                                       
                                                                      
  /* Get disk file name */                                            
  if (disk_file_name != NULL) {                                       
4002401c:	80 a7 20 00 	cmp  %i4, 0                                    <== NOT EXECUTED
40024020:	02 80 00 42 	be  40024128 <rtems_bdpart_unmount+0x134>      <== NOT EXECUTED
40024024:	ba 10 00 08 	mov  %o0, %i5                                  <== NOT EXECUTED
    disk_file_name += 1;                                              
40024028:	a2 07 20 01 	add  %i4, 1, %l1                               <== NOT EXECUTED
    disk_file_name_size = strlen( disk_file_name);                    
4002402c:	40 00 79 1d 	call  400424a0 <strlen>                        <== NOT EXECUTED
40024030:	90 10 00 11 	mov  %l1, %o0                                  <== NOT EXECUTED
40024034:	a0 10 00 08 	mov  %o0, %l0                                  <== 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);
40024038:	b2 04 00 1d 	add  %l0, %i5, %i1                             <== NOT EXECUTED
  if (mount_point == NULL) {                                          
    esc = RTEMS_NO_MEMORY;                                            
4002403c:	b0 10 20 1a 	mov  0x1a, %i0                                 <== 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);
40024040:	7f ff 7b ae 	call  40002ef8 <malloc>                        <== NOT EXECUTED
40024044:	90 06 60 05 	add  %i1, 5, %o0                               <== NOT EXECUTED
  if (mount_point == NULL) {                                          
40024048:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4002404c:	02 80 00 2b 	be  400240f8 <rtems_bdpart_unmount+0x104>      <== NOT EXECUTED
40024050:	b8 10 00 08 	mov  %o0, %i4                                  <== NOT EXECUTED
    esc = RTEMS_NO_MEMORY;                                            
    goto cleanup;                                                     
  }                                                                   
  strncpy( mount_point, mount_base, mount_base_size);                 
40024054:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
40024058:	40 00 79 ce 	call  40042790 <strncpy>                       <== NOT EXECUTED
4002405c:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
  mount_point [mount_base_size] = '/';                                
40024060:	82 10 20 2f 	mov  0x2f, %g1                                 <== NOT EXECUTED
  strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
40024064:	90 07 60 01 	add  %i5, 1, %o0                               <== 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] = '/';                                
40024068:	c2 2f 00 1d 	stb  %g1, [ %i4 + %i5 ]                        <== NOT EXECUTED
  strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
4002406c:	92 10 00 11 	mov  %l1, %o1                                  <== NOT EXECUTED
40024070:	90 07 00 08 	add  %i4, %o0, %o0                             <== NOT EXECUTED
40024074:	40 00 79 c7 	call  40042790 <strncpy>                       <== NOT EXECUTED
40024078:	94 10 00 10 	mov  %l0, %o2                                  <== NOT EXECUTED
                                                                      
  /* Marker */                                                        
  mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
4002407c:	b2 06 60 01 	inc  %i1                                       <== 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);
40024080:	37 10 01 81 	sethi  %hi(0x40060400), %i3                    <== 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) {                                       
40024084:	ba 10 20 00 	clr  %i5                                       <== NOT EXECUTED
  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);
                                                                      
  /* Marker */                                                        
  mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
40024088:	b2 07 00 19 	add  %i4, %i1, %i1                             <== NOT EXECUTED
                                                                      
  /* Mount supported file systems for each partition */               
  for (i = 0; i < count; ++i) {                                       
4002408c:	80 a6 a0 00 	cmp  %i2, 0                                    <== NOT EXECUTED
40024090:	12 80 00 06 	bne  400240a8 <rtems_bdpart_unmount+0xb4>      <== NOT EXECUTED
40024094:	b6 16 e3 08 	or  %i3, 0x308, %i3                            <== NOT EXECUTED
  const rtems_bdpart_partition *pt __attribute__((unused)),           
  size_t count,                                                       
  const char *mount_base                                              
)                                                                     
{                                                                     
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
40024098:	10 80 00 1c 	b  40024108 <rtems_bdpart_unmount+0x114>       <== NOT EXECUTED
4002409c:	b0 10 20 00 	clr  %i0                                       <== 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) {                                       
400240a0:	02 80 00 1a 	be  40024108 <rtems_bdpart_unmount+0x114>      <== NOT EXECUTED
400240a4:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
    /* Create mount point */                                          
    int rv = snprintf( mount_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
400240a8:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
400240ac:	94 10 00 1b 	mov  %i3, %o2                                  <== NOT EXECUTED
400240b0:	ba 07 60 01 	inc  %i5                                       <== NOT EXECUTED
400240b4:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
400240b8:	40 00 75 82 	call  400416c0 <snprintf>                      <== NOT EXECUTED
400240bc:	96 10 00 1d 	mov  %i5, %o3                                  <== NOT EXECUTED
    if (rv >= RTEMS_BDPART_NUMBER_SIZE) {                             
400240c0:	80 a2 20 03 	cmp  %o0, 3                                    <== NOT EXECUTED
400240c4:	14 80 00 15 	bg  40024118 <rtems_bdpart_unmount+0x124>      <== NOT EXECUTED
400240c8:	b0 10 20 03 	mov  3, %i0                                    <== NOT EXECUTED
      esc = RTEMS_INVALID_NAME;                                       
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Unmount */                                                     
    rv = unmount( mount_point);                                       
400240cc:	40 00 11 45 	call  400285e0 <unmount>                       <== NOT EXECUTED
400240d0:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
    if (rv == 0) {                                                    
400240d4:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
400240d8:	12 bf ff f2 	bne  400240a0 <rtems_bdpart_unmount+0xac>      <== NOT EXECUTED
400240dc:	80 a7 40 1a 	cmp  %i5, %i2                                  <== NOT EXECUTED
      /* Remove mount point */                                        
      rv = rmdir( mount_point);                                       
400240e0:	40 00 0f 8b 	call  40027f0c <rmdir>                         <== NOT EXECUTED
400240e4:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
      if (rv != 0) {                                                  
400240e8:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
400240ec:	02 bf ff ed 	be  400240a0 <rtems_bdpart_unmount+0xac>       <== NOT EXECUTED
400240f0:	80 a7 40 1a 	cmp  %i5, %i2                                  <== NOT EXECUTED
        esc = RTEMS_IO_ERROR;                                         
400240f4:	b0 10 20 1b 	mov  0x1b, %i0                                 <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
cleanup:                                                              
                                                                      
  free( mount_point);                                                 
400240f8:	7f ff 7a a6 	call  40002b90 <free>                          <== NOT EXECUTED
400240fc:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
                                                                      
  return esc;                                                         
}                                                                     
40024100:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40024104:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
cleanup:                                                              
                                                                      
  free( mount_point);                                                 
40024108:	7f ff 7a a2 	call  40002b90 <free>                          <== NOT EXECUTED
4002410c:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
                                                                      
  return esc;                                                         
}                                                                     
40024110:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40024114:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
cleanup:                                                              
                                                                      
  free( mount_point);                                                 
40024118:	7f ff 7a 9e 	call  40002b90 <free>                          <== NOT EXECUTED
4002411c:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
                                                                      
  return esc;                                                         
}                                                                     
40024120:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40024124:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  /* Get disk file name */                                            
  if (disk_file_name != NULL) {                                       
    disk_file_name += 1;                                              
    disk_file_name_size = strlen( disk_file_name);                    
  } else {                                                            
    disk_file_name = disk_name;                                       
40024128:	10 bf ff c4 	b  40024038 <rtems_bdpart_unmount+0x44>        <== NOT EXECUTED
4002412c:	a2 10 00 18 	mov  %i0, %l1                                  <== NOT EXECUTED
                                                                      

40003228 <rtems_bdpart_unregister>: rtems_status_code rtems_bdpart_unregister( const char *disk_name, const rtems_bdpart_partition *pt __attribute__((unused)), size_t count ) {
40003228:	9d e3 bf 90 	save  %sp, -112, %sp                           
  rtems_device_minor_number minor = 0;                                
  rtems_blkdev_bnum disk_end = 0;                                     
  dev_t disk = 0;                                                     
  dev_t logical_disk = 0;                                             
  size_t i = 0;                                                       
  int fd = -1;                                                        
4000322c:	82 10 3f ff 	mov  -1, %g1                                   
  rtems_disk_device *dd = NULL;                                       
                                                                      
  /* Get disk data */                                                 
  sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);   
40003230:	90 10 00 18 	mov  %i0, %o0                                  
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_device_major_number major = 0;                                
  rtems_device_minor_number minor = 0;                                
  rtems_blkdev_bnum disk_end = 0;                                     
40003234:	c0 27 bf f4 	clr  [ %fp + -12 ]                             
  dev_t disk = 0;                                                     
  dev_t logical_disk = 0;                                             
  size_t i = 0;                                                       
  int fd = -1;                                                        
40003238:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]                          
  rtems_disk_device *dd = NULL;                                       
4000323c:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
                                                                      
  /* Get disk data */                                                 
  sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);   
40003240:	92 07 bf f8 	add  %fp, -8, %o1                              
40003244:	94 07 bf fc 	add  %fp, -4, %o2                              
40003248:	7f ff fe d1 	call  40002d8c <rtems_bdpart_get_disk_data>    
4000324c:	96 07 bf f4 	add  %fp, -12, %o3                             
  if (sc != RTEMS_SUCCESSFUL) {                                       
40003250:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40003254:	12 80 00 14 	bne  400032a4 <rtems_bdpart_unregister+0x7c>   <== NEVER TAKEN
40003258:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
    return sc;                                                        
  }                                                                   
  disk = rtems_disk_get_device_identifier( dd);                       
  close( fd);                                                         
4000325c:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0                          
40003260:	40 00 08 24 	call  400052f0 <close>                         
40003264:	f8 18 40 00 	ldd  [ %g1 ], %i4                              
                                                                      
  /* 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) {                                       
40003268:	80 a6 a0 00 	cmp  %i2, 0                                    
4000326c:	12 80 00 05 	bne  40003280 <rtems_bdpart_unregister+0x58>   <== ALWAYS TAKEN
40003270:	b4 06 80 1d 	add  %i2, %i5, %i2                             
40003274:	30 80 00 0c 	b,a   400032a4 <rtems_bdpart_unregister+0x7c>  <== NOT EXECUTED
40003278:	02 80 00 0b 	be  400032a4 <rtems_bdpart_unregister+0x7c>    
4000327c:	01 00 00 00 	nop                                            
    /* New minor number */                                            
    ++minor;                                                          
40003280:	ba 07 60 01 	inc  %i5                                       
                                                                      
    /* Get the device identifier */                                   
    logical_disk = rtems_filesystem_make_dev_t( major, minor);        
                                                                      
    /* Delete logical disk */                                         
    sc = rtems_disk_delete( logical_disk);                            
40003284:	90 10 00 1c 	mov  %i4, %o0                                  
40003288:	40 00 02 cc 	call  40003db8 <rtems_disk_delete>             
4000328c:	92 10 00 1d 	mov  %i5, %o1                                  
    if (sc != RTEMS_SUCCESSFUL) {                                     
40003290:	80 a2 20 00 	cmp  %o0, 0                                    
40003294:	02 bf ff f9 	be  40003278 <rtems_bdpart_unregister+0x50>    <== ALWAYS TAKEN
40003298:	80 a7 40 1a 	cmp  %i5, %i2                                  
      return sc;                                                      
    }                                                                 
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
4000329c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400032a0:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
400032a4:	81 c7 e0 08 	ret                                            
400032a8:	81 e8 00 00 	restore                                        
                                                                      

4000333c <rtems_bdpart_write>: const char *disk_name, const rtems_bdpart_format *format, const rtems_bdpart_partition *pt, size_t count ) {
4000333c:	9d e3 bf 88 	save  %sp, -120, %sp                           
  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;                                 
40003340:	80 a6 60 00 	cmp  %i1, 0                                    
40003344:	02 80 00 06 	be  4000335c <rtems_bdpart_write+0x20>         <== NEVER TAKEN
40003348:	90 10 00 18 	mov  %i0, %o0                                  
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
  bool dos_compatibility = format != NULL                             
    && format->type == RTEMS_BDPART_FORMAT_MBR                        
4000334c:	c2 06 40 00 	ld  [ %i1 ], %g1                               
40003350:	80 a0 60 00 	cmp  %g1, 0                                    
40003354:	22 80 00 11 	be,a   40003398 <rtems_bdpart_write+0x5c>      <== ALWAYS TAKEN
40003358:	c2 0e 60 08 	ldub  [ %i1 + 8 ], %g1                         
    && format->mbr.dos_compatibility;                                 
  rtems_bdbuf_buffer *block = NULL;                                   
4000335c:	c0 27 bf f0 	clr  [ %fp + -16 ]                             <== NOT EXECUTED
  rtems_blkdev_bnum disk_end = 0;                                     
40003360:	c0 27 bf f4 	clr  [ %fp + -12 ]                             <== NOT EXECUTED
  size_t count                                                        
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
  bool dos_compatibility = format != NULL                             
40003364:	ba 10 20 00 	clr  %i5                                       <== 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 =                                    
40003368:	b8 10 20 01 	mov  1, %i4                                    <== NOT EXECUTED
    dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;           
  size_t ppc = 0; /* Primary partition count */                       
  size_t i = 0;                                                       
  uint8_t *data = NULL;                                               
  int fd = -1;                                                        
4000336c:	82 10 3f ff 	mov  -1, %g1                                   
  rtems_disk_device *dd = NULL;                                       
40003370:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
  rtems_blkdev_bnum record_space =                                    
    dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;           
  size_t ppc = 0; /* Primary partition count */                       
  size_t i = 0;                                                       
  uint8_t *data = NULL;                                               
  int fd = -1;                                                        
40003374:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]                          
  rtems_disk_device *dd = NULL;                                       
                                                                      
  /* Check if we have something to do */                              
  if (count == 0) {                                                   
40003378:	80 a6 e0 00 	cmp  %i3, 0                                    
4000337c:	02 80 00 4e 	be  400034b4 <rtems_bdpart_write+0x178>        <== NEVER TAKEN
40003380:	b0 10 20 00 	clr  %i0                                       
    /* Nothing to do */                                               
    return RTEMS_SUCCESSFUL;                                          
  }                                                                   
                                                                      
  /* Check parameter */                                               
  if (format == NULL || pt == NULL) {                                 
40003384:	80 a6 a0 00 	cmp  %i2, 0                                    
40003388:	12 80 00 0b 	bne  400033b4 <rtems_bdpart_write+0x78>        <== ALWAYS TAKEN
4000338c:	80 a6 60 00 	cmp  %i1, 0                                    
    return RTEMS_INVALID_ADDRESS;                                     
40003390:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40003394:	91 e8 20 09 	restore  %g0, 9, %o0                           <== 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;                                 
40003398:	80 a0 60 00 	cmp  %g1, 0                                    
4000339c:	02 bf ff f1 	be  40003360 <rtems_bdpart_write+0x24>         <== NEVER TAKEN
400033a0:	c0 27 bf f0 	clr  [ %fp + -16 ]                             
  rtems_bdbuf_buffer *block = NULL;                                   
  rtems_blkdev_bnum disk_end = 0;                                     
400033a4:	c0 27 bf f4 	clr  [ %fp + -12 ]                             
  size_t count                                                        
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
  bool dos_compatibility = format != NULL                             
400033a8:	ba 10 20 01 	mov  1, %i5                                    
    && 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 =                                    
400033ac:	10 bf ff f0 	b  4000336c <rtems_bdpart_write+0x30>          
400033b0:	b8 10 20 3f 	mov  0x3f, %i4                                 
    /* Nothing to do */                                               
    return RTEMS_SUCCESSFUL;                                          
  }                                                                   
                                                                      
  /* Check parameter */                                               
  if (format == NULL || pt == NULL) {                                 
400033b4:	02 bf ff f7 	be  40003390 <rtems_bdpart_write+0x54>         <== NEVER TAKEN
400033b8:	92 07 bf f8 	add  %fp, -8, %o1                              
    return RTEMS_INVALID_ADDRESS;                                     
  }                                                                   
                                                                      
  /* Get disk data */                                                 
  sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);   
400033bc:	94 07 bf fc 	add  %fp, -4, %o2                              
400033c0:	7f ff fe 73 	call  40002d8c <rtems_bdpart_get_disk_data>    
400033c4:	96 07 bf f4 	add  %fp, -12, %o3                             
  if (sc != RTEMS_SUCCESSFUL) {                                       
400033c8:	b0 92 20 00 	orcc  %o0, 0, %i0                              
400033cc:	12 80 00 3a 	bne  400034b4 <rtems_bdpart_write+0x178>       <== NEVER TAKEN
400033d0:	ba 8f 60 ff 	andcc  %i5, 0xff, %i5                          
    return sc;                                                        
  }                                                                   
                                                                      
  /* Align end of disk on cylinder boundary if necessary */           
  if (dos_compatibility) {                                            
400033d4:	32 80 00 25 	bne,a   40003468 <rtems_bdpart_write+0x12c>    <== ALWAYS TAKEN
400033d8:	f0 07 bf f4 	ld  [ %fp + -12 ], %i0                         
400033dc:	d0 07 bf f4 	ld  [ %fp + -12 ], %o0                         <== 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) {                  
400033e0:	de 06 80 00 	ld  [ %i2 ], %o7                               
400033e4:	80 a3 c0 08 	cmp  %o7, %o0                                  
400033e8:	3a 80 00 27 	bcc,a   40003484 <rtems_bdpart_write+0x148>    <== NEVER TAKEN
400033ec:	b0 10 20 0a 	mov  0xa, %i0                                  <== NOT EXECUTED
400033f0:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1                           
400033f4:	80 a2 00 01 	cmp  %o0, %g1                                  
400033f8:	0a 80 00 22 	bcs  40003480 <rtems_bdpart_write+0x144>       <== NEVER TAKEN
400033fc:	80 a3 c0 01 	cmp  %o7, %g1                                  
      esc = RTEMS_INVALID_NUMBER;                                     
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Check that begin and end are valid */                          
    if (p->begin >= p->end) {                                         
40003400:	1a 80 00 20 	bcc  40003480 <rtems_bdpart_write+0x144>       <== NEVER TAKEN
40003404:	a2 10 00 1a 	mov  %i2, %l1                                  
40003408:	82 10 00 1a 	mov  %i2, %g1                                  
  if (dos_compatibility) {                                            
    disk_end -= (disk_end % record_space);                            
  }                                                                   
                                                                      
  /* Check that we have a consistent partition table */               
  for (i = 0; i < count; ++i) {                                       
4000340c:	84 10 20 00 	clr  %g2                                       
40003410:	84 00 a0 01 	inc  %g2                                       
40003414:	80 a0 80 1b 	cmp  %g2, %i3                                  
40003418:	22 80 00 29 	be,a   400034bc <rtems_bdpart_write+0x180>     
4000341c:	c2 06 40 00 	ld  [ %i1 ], %g1                               
    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) {                  
40003420:	c6 00 60 30 	ld  [ %g1 + 0x30 ], %g3                        
40003424:	80 a0 c0 08 	cmp  %g3, %o0                                  
40003428:	3a 80 00 17 	bcc,a   40003484 <rtems_bdpart_write+0x148>    <== NEVER TAKEN
4000342c:	b0 10 20 0a 	mov  0xa, %i0                                  <== NOT EXECUTED
40003430:	c8 00 60 34 	ld  [ %g1 + 0x34 ], %g4                        
40003434:	80 a1 00 08 	cmp  %g4, %o0                                  
40003438:	18 80 00 12 	bgu  40003480 <rtems_bdpart_write+0x144>       <== NEVER TAKEN
4000343c:	80 a0 c0 04 	cmp  %g3, %g4                                  
      esc = RTEMS_INVALID_NUMBER;                                     
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Check that begin and end are valid */                          
    if (p->begin >= p->end) {                                         
40003440:	1a 80 00 10 	bcc  40003480 <rtems_bdpart_write+0x144>       <== NEVER TAKEN
40003444:	80 a0 a0 00 	cmp  %g2, 0                                    
      esc = RTEMS_INVALID_NUMBER;                                     
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Check that partitions do not overlap */                        
    if (i > 0 && pt [i - 1].end > p->begin) {                         
40003448:	22 bf ff f2 	be,a   40003410 <rtems_bdpart_write+0xd4>      <== NEVER TAKEN
4000344c:	82 00 60 30 	add  %g1, 0x30, %g1                            <== NOT EXECUTED
40003450:	c8 00 60 04 	ld  [ %g1 + 4 ], %g4                           
40003454:	80 a0 c0 04 	cmp  %g3, %g4                                  
40003458:	0a 80 00 0a 	bcs  40003480 <rtems_bdpart_write+0x144>       <== NEVER TAKEN
4000345c:	82 00 60 30 	add  %g1, 0x30, %g1                            
  if (dos_compatibility) {                                            
    disk_end -= (disk_end % record_space);                            
  }                                                                   
                                                                      
  /* Check that we have a consistent partition table */               
  for (i = 0; i < count; ++i) {                                       
40003460:	10 bf ff ed 	b  40003414 <rtems_bdpart_write+0xd8>          
40003464:	84 00 a0 01 	inc  %g2                                       
    return sc;                                                        
  }                                                                   
                                                                      
  /* Align end of disk on cylinder boundary if necessary */           
  if (dos_compatibility) {                                            
    disk_end -= (disk_end % record_space);                            
40003468:	92 10 00 1c 	mov  %i4, %o1                                  
4000346c:	40 00 7a a5 	call  40021f00 <.urem>                         
40003470:	90 10 00 18 	mov  %i0, %o0                                  
40003474:	90 26 00 08 	sub  %i0, %o0, %o0                             
40003478:	10 bf ff da 	b  400033e0 <rtems_bdpart_write+0xa4>          
4000347c:	d0 27 bf f4 	st  %o0, [ %fp + -12 ]                         
  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) {                  
      esc = RTEMS_INVALID_NUMBER;                                     
40003480:	b0 10 20 0a 	mov  0xa, %i0                                  <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
cleanup:                                                              
                                                                      
  if (fd >= 0) {                                                      
40003484:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0                          
40003488:	80 a2 20 00 	cmp  %o0, 0                                    
4000348c:	26 80 00 05 	bl,a   400034a0 <rtems_bdpart_write+0x164>     <== NEVER TAKEN
40003490:	d0 07 bf f0 	ld  [ %fp + -16 ], %o0                         <== NOT EXECUTED
    close( fd);                                                       
40003494:	40 00 07 97 	call  400052f0 <close>                         
40003498:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  if (block != NULL) {                                                
4000349c:	d0 07 bf f0 	ld  [ %fp + -16 ], %o0                         
400034a0:	80 a2 20 00 	cmp  %o0, 0                                    
400034a4:	02 80 00 04 	be  400034b4 <rtems_bdpart_write+0x178>        <== NEVER TAKEN
400034a8:	01 00 00 00 	nop                                            
    rtems_bdbuf_sync( block);                                         
400034ac:	40 00 33 a9 	call  40010350 <rtems_bdbuf_sync>              
400034b0:	01 00 00 00 	nop                                            
400034b4:	81 c7 e0 08 	ret                                            
400034b8:	81 e8 00 00 	restore                                        
      goto cleanup;                                                   
    }                                                                 
  }                                                                   
                                                                      
  /* Check format */                                                  
  if (format->type != RTEMS_BDPART_FORMAT_MBR) {                      
400034bc:	80 a0 60 00 	cmp  %g1, 0                                    
400034c0:	12 bf ff f1 	bne  40003484 <rtems_bdpart_write+0x148>       <== NEVER TAKEN
400034c4:	b0 10 20 18 	mov  0x18, %i0                                 
   * 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;                                       
400034c8:	80 a6 e0 04 	cmp  %i3, 4                                    
400034cc:	08 80 00 03 	bleu  400034d8 <rtems_bdpart_write+0x19c>      <== NEVER TAKEN
400034d0:	a0 10 00 1b 	mov  %i3, %l0                                  
400034d4:	a0 10 20 03 	mov  3, %l0                                    
                                                                      
  /*                                                                  
   * 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) {
400034d8:	80 a7 60 00 	cmp  %i5, 0                                    
400034dc:	02 80 00 06 	be  400034f4 <rtems_bdpart_write+0x1b8>        <== NEVER TAKEN
400034e0:	80 a4 00 1b 	cmp  %l0, %i3                                  
400034e4:	80 a3 e0 3f 	cmp  %o7, 0x3f                                 
400034e8:	12 bf ff e7 	bne  40003484 <rtems_bdpart_write+0x148>       <== NEVER TAKEN
400034ec:	b0 10 20 0a 	mov  0xa, %i0                                  
   * 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) {                                     
400034f0:	80 a4 00 1b 	cmp  %l0, %i3                                  
400034f4:	1a 80 00 1c 	bcc  40003564 <rtems_bdpart_write+0x228>       <== NEVER TAKEN
400034f8:	84 04 3f ff 	add  %l0, -1, %g2                              
    if ((pt [i].begin - pt [i - 1].end) < record_space) {             
400034fc:	89 2c 20 06 	sll  %l0, 6, %g4                               
40003500:	87 28 a0 04 	sll  %g2, 4, %g3                               
40003504:	83 2c 20 04 	sll  %l0, 4, %g1                               
40003508:	85 28 a0 06 	sll  %g2, 6, %g2                               
4000350c:	82 21 00 01 	sub  %g4, %g1, %g1                             
40003510:	84 20 80 03 	sub  %g2, %g3, %g2                             
40003514:	c8 06 80 01 	ld  [ %i2 + %g1 ], %g4                         
40003518:	84 06 80 02 	add  %i2, %g2, %g2                             
4000351c:	c6 00 a0 04 	ld  [ %g2 + 4 ], %g3                           
40003520:	84 06 80 01 	add  %i2, %g1, %g2                             
40003524:	82 21 00 03 	sub  %g4, %g3, %g1                             
40003528:	80 a7 00 01 	cmp  %i4, %g1                                  
4000352c:	18 bf ff d5 	bgu  40003480 <rtems_bdpart_write+0x144>       <== NEVER TAKEN
40003530:	82 10 00 10 	mov  %l0, %g1                                  
   * 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) {                                     
40003534:	10 80 00 09 	b  40003558 <rtems_bdpart_write+0x21c>         
40003538:	82 00 60 01 	inc  %g1                                       
    if ((pt [i].begin - pt [i - 1].end) < record_space) {             
4000353c:	c8 00 e0 30 	ld  [ %g3 + 0x30 ], %g4                        
40003540:	c6 00 e0 04 	ld  [ %g3 + 4 ], %g3                           
40003544:	86 21 00 03 	sub  %g4, %g3, %g3                             
40003548:	80 a7 00 03 	cmp  %i4, %g3                                  
4000354c:	18 bf ff cd 	bgu  40003480 <rtems_bdpart_write+0x144>       <== NEVER TAKEN
40003550:	84 00 a0 30 	add  %g2, 0x30, %g2                            
   * 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) {                                     
40003554:	82 00 60 01 	inc  %g1                                       
40003558:	80 a6 c0 01 	cmp  %i3, %g1                                  
4000355c:	18 bf ff f8 	bgu  4000353c <rtems_bdpart_write+0x200>       
40003560:	86 10 00 02 	mov  %g2, %g3                                  
40003564:	ba 10 00 1a 	mov  %i2, %i5                                  
40003568:	b0 10 20 00 	clr  %i0                                       
4000356c:	10 80 00 0c 	b  4000359c <rtems_bdpart_write+0x260>         
40003570:	a4 07 bf ef 	add  %fp, -17, %l2                             
      esc =  RTEMS_INVALID_ID;                                        
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Check flags */                                                 
    if (p->flags > 0xffU) {                                           
40003574:	80 a0 60 00 	cmp  %g1, 0                                    
40003578:	12 80 00 10 	bne  400035b8 <rtems_bdpart_write+0x27c>       <== NEVER TAKEN
4000357c:	b0 06 20 01 	inc  %i0                                       
40003580:	c2 07 60 2c 	ld  [ %i5 + 0x2c ], %g1                        
40003584:	80 a0 60 ff 	cmp  %g1, 0xff                                 
40003588:	18 80 00 0c 	bgu  400035b8 <rtems_bdpart_write+0x27c>       <== NEVER TAKEN
4000358c:	ba 07 60 30 	add  %i5, 0x30, %i5                            
      goto cleanup;                                                   
    }                                                                 
  }                                                                   
                                                                      
  /* Check that we can convert the parition descriptions to the MBR format */
  for (i = 0; i < count; ++i) {                                       
40003590:	80 a6 00 1b 	cmp  %i0, %i3                                  
40003594:	02 80 00 0b 	be  400035c0 <rtems_bdpart_write+0x284>        
40003598:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
    uint8_t type = 0;                                                 
                                                                      
    const rtems_bdpart_partition *p = pt + i;                         
                                                                      
    /* Check type */                                                  
    if (!rtems_bdpart_to_mbr_partition_type( p->type, &type)) {       
4000359c:	90 07 60 08 	add  %i5, 8, %o0                               
    }                                                                 
  }                                                                   
                                                                      
  /* Check that we can convert the parition descriptions to the MBR format */
  for (i = 0; i < count; ++i) {                                       
    uint8_t type = 0;                                                 
400035a0:	c0 2f bf ef 	clrb  [ %fp + -17 ]                            
                                                                      
    const rtems_bdpart_partition *p = pt + i;                         
                                                                      
    /* Check type */                                                  
    if (!rtems_bdpart_to_mbr_partition_type( p->type, &type)) {       
400035a4:	7f ff fd ee 	call  40002d5c <rtems_bdpart_to_mbr_partition_type>
400035a8:	92 10 00 12 	mov  %l2, %o1                                  
400035ac:	80 8a 20 ff 	btst  0xff, %o0                                
400035b0:	32 bf ff f1 	bne,a   40003574 <rtems_bdpart_write+0x238>    <== ALWAYS TAKEN
400035b4:	c2 07 60 28 	ld  [ %i5 + 0x28 ], %g1                        
400035b8:	10 bf ff b3 	b  40003484 <rtems_bdpart_write+0x148>         <== NOT EXECUTED
400035bc:	b0 10 20 04 	mov  4, %i0                                    <== NOT EXECUTED
    /* Check ID */                                                    
    /* TODO */                                                        
  }                                                                   
                                                                      
  /* New MBR */                                                       
  sc = rtems_bdpart_new_record( dd, 0, &block);                       
400035c0:	92 10 20 00 	clr  %o1                                       
400035c4:	7f ff ff 3a 	call  400032ac <rtems_bdpart_new_record>       
400035c8:	94 07 bf f0 	add  %fp, -16, %o2                             
  if (sc != RTEMS_SUCCESSFUL) {                                       
400035cc:	b0 92 20 00 	orcc  %o0, 0, %i0                              
400035d0:	12 bf ff ae 	bne  40003488 <rtems_bdpart_write+0x14c>       <== NEVER TAKEN
400035d4:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0                          
  }                                                                   
                                                                      
  /* Write disk ID */                                                 
  rtems_uint32_to_little_endian(                                      
    format->mbr.disk_id,                                              
    block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID                   
400035d8:	c2 07 bf f0 	ld  [ %fp + -16 ], %g1                         
    esc = sc;                                                         
    goto cleanup;                                                     
  }                                                                   
                                                                      
  /* Write disk ID */                                                 
  rtems_uint32_to_little_endian(                                      
400035dc:	c4 06 60 04 	ld  [ %i1 + 4 ], %g2                           
    format->mbr.disk_id,                                              
    block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID                   
400035e0:	c6 00 60 1c 	ld  [ %g1 + 0x1c ], %g3                        
    esc = sc;                                                         
    goto cleanup;                                                     
  }                                                                   
                                                                      
  /* Write disk ID */                                                 
  rtems_uint32_to_little_endian(                                      
400035e4:	82 00 e1 b8 	add  %g3, 0x1b8, %g1                           
    RTEMS_BDPART_MBR_SIGNATURE_1;                                     
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
                                                                      
rtems_status_code rtems_bdpart_write(                                 
400035e8:	86 00 e1 bc 	add  %g3, 0x1bc, %g3                           
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;                                       
400035ec:	c4 28 40 00 	stb  %g2, [ %g1 ]                              
400035f0:	82 00 60 01 	inc  %g1                                       
                                                                      
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{                                                                     
  size_t i = 0;                                                       
                                                                      
  for (i = 0; i < 4; ++i) {                                           
400035f4:	80 a0 40 03 	cmp  %g1, %g3                                  
400035f8:	12 bf ff fd 	bne  400035ec <rtems_bdpart_write+0x2b0>       
400035fc:	85 30 a0 08 	srl  %g2, 8, %g2                               
    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;             
40003600:	c2 07 bf f0 	ld  [ %fp + -16 ], %g1                         
    RTEMS_BDPART_MBR_SIGNATURE_1;                                     
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
                                                                      
rtems_status_code rtems_bdpart_write(                                 
40003604:	9f 2c 20 04 	sll  %l0, 4, %o7                               
    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;             
40003608:	c8 00 60 1c 	ld  [ %g1 + 0x1c ], %g4                        
    RTEMS_BDPART_MBR_SIGNATURE_1;                                     
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
                                                                      
rtems_status_code rtems_bdpart_write(                                 
4000360c:	99 2c 20 06 	sll  %l0, 6, %o4                               
    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;             
40003610:	9a 01 21 be 	add  %g4, 0x1be, %o5                           
    RTEMS_BDPART_MBR_SIGNATURE_1;                                     
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
                                                                      
rtems_status_code rtems_bdpart_write(                                 
40003614:	98 23 00 0f 	sub  %o4, %o7, %o4                             
40003618:	88 01 21 ca 	add  %g4, 0x1ca, %g4                           
4000361c:	b0 06 80 0c 	add  %i2, %o4, %i0                             
                                                                      
    /* Write partition entry */                                       
    rtems_bdpart_write_mbr_partition(                                 
      data,                                                           
      p->begin,                                                       
      p->end - p->begin,                                              
40003620:	c4 04 40 00 	ld  [ %l1 ], %g2                               
  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(                                 
40003624:	c6 04 60 04 	ld  [ %l1 + 4 ], %g3                           
  if (block != NULL) {                                                
    rtems_bdbuf_sync( block);                                         
  }                                                                   
                                                                      
  return esc;                                                         
}                                                                     
40003628:	f2 0c 60 08 	ldub  [ %l1 + 8 ], %i1                         
  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(                                 
4000362c:	fa 0c 60 2f 	ldub  [ %l1 + 0x2f ], %i5                      
40003630:	86 20 c0 02 	sub  %g3, %g2, %g3                             
    RTEMS_BDPART_MBR_SIGNATURE_1;                                     
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
                                                                      
rtems_status_code rtems_bdpart_write(                                 
40003634:	82 01 3f fc 	add  %g4, -4, %g1                              
    data [i] = (uint8_t) value;                                       
40003638:	c4 28 40 00 	stb  %g2, [ %g1 ]                              
4000363c:	82 00 60 01 	inc  %g1                                       
                                                                      
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{                                                                     
  size_t i = 0;                                                       
                                                                      
  for (i = 0; i < 4; ++i) {                                           
40003640:	80 a1 00 01 	cmp  %g4, %g1                                  
40003644:	12 bf ff fd 	bne  40003638 <rtems_bdpart_write+0x2fc>       
40003648:	85 30 a0 08 	srl  %g2, 8, %g2                               
4000364c:	84 01 20 04 	add  %g4, 4, %g2                               
40003650:	82 10 00 04 	mov  %g4, %g1                                  
    data [i] = (uint8_t) value;                                       
40003654:	c6 28 40 00 	stb  %g3, [ %g1 ]                              
40003658:	82 00 60 01 	inc  %g1                                       
                                                                      
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{                                                                     
  size_t i = 0;                                                       
                                                                      
  for (i = 0; i < 4; ++i) {                                           
4000365c:	80 a0 40 02 	cmp  %g1, %g2                                  
40003660:	12 bf ff fd 	bne  40003654 <rtems_bdpart_write+0x318>       
40003664:	87 30 e0 08 	srl  %g3, 8, %g3                               
  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;                         
40003668:	f2 29 3f f8 	stb  %i1, [ %g4 + -8 ]                         
  data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;                       
4000366c:	fa 29 3f f4 	stb  %i5, [ %g4 + -12 ]                        
40003670:	a2 04 60 30 	add  %l1, 0x30, %l1                            
    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) {                                         
40003674:	80 a4 40 18 	cmp  %l1, %i0                                  
40003678:	12 bf ff ea 	bne  40003620 <rtems_bdpart_write+0x2e4>       
4000367c:	88 01 20 10 	add  %g4, 0x10, %g4                            
40003680:	84 03 40 0f 	add  %o5, %o7, %g2                             
                                                                      
    data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;                        
  }                                                                   
                                                                      
  /* Write extended partition with logical partitions if necessary */ 
  if (ppc != count) {                                                 
40003684:	80 a4 00 1b 	cmp  %l0, %i3                                  
40003688:	02 bf ff 7f 	be  40003484 <rtems_bdpart_write+0x148>        <== NEVER TAKEN
4000368c:	b0 10 20 00 	clr  %i0                                       
    rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */ 
                                                                      
    /* Begin of extended partition */                                 
    rtems_blkdev_bnum ep_begin = pt [ppc].begin - record_space;       
40003690:	fa 06 80 0c 	ld  [ %i2 + %o4 ], %i5                         
                                                                      
    /* Write extended partition */                                    
    rtems_bdpart_write_mbr_partition(                                 
40003694:	c6 07 bf f4 	ld  [ %fp + -12 ], %g3                         
  /* 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;       
40003698:	ba 27 40 1c 	sub  %i5, %i4, %i5                             
  uint32_t size,                                                      
  uint8_t type,                                                       
  uint8_t flags                                                       
)                                                                     
{                                                                     
  rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
4000369c:	82 00 a0 08 	add  %g2, 8, %g1                               
                                                                      
    /* Begin of extended partition */                                 
    rtems_blkdev_bnum ep_begin = pt [ppc].begin - record_space;       
                                                                      
    /* Write extended partition */                                    
    rtems_bdpart_write_mbr_partition(                                 
400036a0:	86 20 c0 1d 	sub  %g3, %i5, %g3                             
    RTEMS_BDPART_MBR_SIGNATURE_1;                                     
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
                                                                      
rtems_status_code rtems_bdpart_write(                                 
400036a4:	b2 00 a0 0c 	add  %g2, 0xc, %i1                             
400036a8:	88 10 00 1d 	mov  %i5, %g4                                  
    data [i] = (uint8_t) value;                                       
400036ac:	c8 28 40 00 	stb  %g4, [ %g1 ]                              
400036b0:	82 00 60 01 	inc  %g1                                       
                                                                      
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{                                                                     
  size_t i = 0;                                                       
                                                                      
  for (i = 0; i < 4; ++i) {                                           
400036b4:	80 a0 40 19 	cmp  %g1, %i1                                  
400036b8:	12 bf ff fd 	bne  400036ac <rtems_bdpart_write+0x370>       
400036bc:	89 31 20 08 	srl  %g4, 8, %g4                               
400036c0:	88 00 a0 10 	add  %g2, 0x10, %g4                            
    data [i] = (uint8_t) value;                                       
400036c4:	c6 28 40 00 	stb  %g3, [ %g1 ]                              
400036c8:	82 00 60 01 	inc  %g1                                       
                                                                      
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{                                                                     
  size_t i = 0;                                                       
                                                                      
  for (i = 0; i < 4; ++i) {                                           
400036cc:	80 a0 40 04 	cmp  %g1, %g4                                  
400036d0:	12 bf ff fd 	bne  400036c4 <rtems_bdpart_write+0x388>       
400036d4:	87 30 e0 08 	srl  %g3, 8, %g3                               
  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;                         
400036d8:	82 10 20 05 	mov  5, %g1                                    
400036dc:	c2 28 a0 04 	stb  %g1, [ %g2 + 4 ]                          
      RTEMS_BDPART_MBR_EXTENDED,                                      
      0                                                               
    );                                                                
                                                                      
    /* Write logical partitions */                                    
    for (i = ppc; i < count; ++i) {                                   
400036e0:	80 a4 00 1b 	cmp  %l0, %i3                                  
400036e4:	1a 80 00 44 	bcc  400037f4 <rtems_bdpart_write+0x4b8>       <== NEVER TAKEN
400036e8:	c0 2b 40 0f 	clrb  [ %o5 + %o7 ]                            
400036ec:	a4 04 20 01 	add  %l0, 1, %l2                               
  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;                         
400036f0:	b2 10 20 05 	mov  5, %i1                                    
    RTEMS_BDPART_MBR_SIGNATURE_1;                                     
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
                                                                      
rtems_status_code rtems_bdpart_write(                                 
400036f4:	83 2c a0 04 	sll  %l2, 4, %g1                               
400036f8:	85 2c a0 06 	sll  %l2, 6, %g2                               
400036fc:	82 20 80 01 	sub  %g2, %g1, %g1                             
40003700:	b4 06 80 01 	add  %i2, %g1, %i2                             
          0                                                           
        );                                                            
      }                                                               
                                                                      
      /* New EBR */                                                   
      ebr = p->begin - record_space;                                  
40003704:	d2 04 40 00 	ld  [ %l1 ], %o1                               
      sc = rtems_bdpart_new_record( dd, ebr, &block);                 
40003708:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
4000370c:	92 22 40 1c 	sub  %o1, %i4, %o1                             
40003710:	7f ff fe e7 	call  400032ac <rtems_bdpart_new_record>       
40003714:	94 07 bf f0 	add  %fp, -16, %o2                             
      if (sc != RTEMS_SUCCESSFUL) {                                   
40003718:	80 a2 20 00 	cmp  %o0, 0                                    
4000371c:	12 80 00 34 	bne  400037ec <rtems_bdpart_write+0x4b0>       <== NEVER TAKEN
40003720:	c2 07 bf f0 	ld  [ %fp + -16 ], %g1                         
        esc = sc;                                                     
        goto cleanup;                                                 
      }                                                               
                                                                      
      /* Write first partition entry */                               
      rtems_bdpart_write_mbr_partition(                               
40003724:	c4 04 60 04 	ld  [ %l1 + 4 ], %g2                           
        block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,              
40003728:	c6 00 60 1c 	ld  [ %g1 + 0x1c ], %g3                        
        esc = sc;                                                     
        goto cleanup;                                                 
      }                                                               
                                                                      
      /* Write first partition entry */                               
      rtems_bdpart_write_mbr_partition(                               
4000372c:	c2 04 40 00 	ld  [ %l1 ], %g1                               
  if (block != NULL) {                                                
    rtems_bdbuf_sync( block);                                         
  }                                                                   
                                                                      
  return esc;                                                         
}                                                                     
40003730:	de 0c 60 08 	ldub  [ %l1 + 8 ], %o7                         
        esc = sc;                                                     
        goto cleanup;                                                 
      }                                                               
                                                                      
      /* Write first partition entry */                               
      rtems_bdpart_write_mbr_partition(                               
40003734:	f0 0c 60 2f 	ldub  [ %l1 + 0x2f ], %i0                      
40003738:	84 20 80 01 	sub  %g2, %g1, %g2                             
    data [i] = (uint8_t) value;                                       
4000373c:	f8 28 e1 c6 	stb  %i4, [ %g3 + 0x1c6 ]                      
40003740:	c0 28 e1 c7 	clrb  [ %g3 + 0x1c7 ]                          
40003744:	c0 28 e1 c8 	clrb  [ %g3 + 0x1c8 ]                          
40003748:	c0 28 e1 c9 	clrb  [ %g3 + 0x1c9 ]                          
  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);
4000374c:	88 00 e1 ca 	add  %g3, 0x1ca, %g4                           
                                                                      
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{                                                                     
  size_t i = 0;                                                       
                                                                      
  for (i = 0; i < 4; ++i) {                                           
40003750:	82 10 20 00 	clr  %g1                                       
    data [i] = (uint8_t) value;                                       
40003754:	c4 29 00 01 	stb  %g2, [ %g4 + %g1 ]                        
                                                                      
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{                                                                     
  size_t i = 0;                                                       
                                                                      
  for (i = 0; i < 4; ++i) {                                           
40003758:	82 00 60 01 	inc  %g1                                       
4000375c:	80 a0 60 04 	cmp  %g1, 4                                    
40003760:	12 bf ff fd 	bne  40003754 <rtems_bdpart_write+0x418>       
40003764:	85 30 a0 08 	srl  %g2, 8, %g2                               
  data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;                         
40003768:	de 28 e1 c2 	stb  %o7, [ %g3 + 0x1c2 ]                      
      RTEMS_BDPART_MBR_EXTENDED,                                      
      0                                                               
    );                                                                
                                                                      
    /* Write logical partitions */                                    
    for (i = ppc; i < count; ++i) {                                   
4000376c:	80 a4 80 1b 	cmp  %l2, %i3                                  
40003770:	02 80 00 21 	be  400037f4 <rtems_bdpart_write+0x4b8>        
40003774:	f0 28 e1 be 	stb  %i0, [ %g3 + 0x1be ]                      
      const rtems_bdpart_partition *p = pt + i;                       
                                                                      
      /* Write second partition entry */                              
      if (i > ppc) {                                                  
40003778:	80 a4 00 12 	cmp  %l0, %l2                                  
4000377c:	1a 80 00 19 	bcc  400037e0 <rtems_bdpart_write+0x4a4>       <== NEVER TAKEN
40003780:	a2 10 00 1a 	mov  %i2, %l1                                  
        rtems_blkdev_bnum begin = p->begin - record_space;            
                                                                      
        rtems_bdpart_write_mbr_partition(                             
          block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1,            
40003784:	c4 07 bf f0 	ld  [ %fp + -16 ], %g2                         
    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;            
40003788:	c2 06 80 00 	ld  [ %i2 ], %g1                               
                                                                      
        rtems_bdpart_write_mbr_partition(                             
          block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1,            
4000378c:	f0 00 a0 1c 	ld  [ %g2 + 0x1c ], %i0                        
                                                                      
      /* Write second partition entry */                              
      if (i > ppc) {                                                  
        rtems_blkdev_bnum begin = p->begin - record_space;            
                                                                      
        rtems_bdpart_write_mbr_partition(                             
40003790:	c4 07 bf f4 	ld  [ %fp + -12 ], %g2                         
    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;            
40003794:	82 20 40 1c 	sub  %g1, %i4, %g1                             
  uint32_t size,                                                      
  uint8_t type,                                                       
  uint8_t flags                                                       
)                                                                     
{                                                                     
  rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
40003798:	88 06 21 d6 	add  %i0, 0x1d6, %g4                           
                                                                      
      /* Write second partition entry */                              
      if (i > ppc) {                                                  
        rtems_blkdev_bnum begin = p->begin - record_space;            
                                                                      
        rtems_bdpart_write_mbr_partition(                             
4000379c:	86 20 40 1d 	sub  %g1, %i5, %g3                             
400037a0:	84 20 80 01 	sub  %g2, %g1, %g2                             
400037a4:	82 10 20 00 	clr  %g1                                       
    data [i] = (uint8_t) value;                                       
400037a8:	c6 29 00 01 	stb  %g3, [ %g4 + %g1 ]                        
                                                                      
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{                                                                     
  size_t i = 0;                                                       
                                                                      
  for (i = 0; i < 4; ++i) {                                           
400037ac:	82 00 60 01 	inc  %g1                                       
400037b0:	80 a0 60 04 	cmp  %g1, 4                                    
400037b4:	12 bf ff fd 	bne  400037a8 <rtems_bdpart_write+0x46c>       
400037b8:	87 30 e0 08 	srl  %g3, 8, %g3                               
  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);
400037bc:	86 06 21 da 	add  %i0, 0x1da, %g3                           
400037c0:	82 10 20 00 	clr  %g1                                       
    data [i] = (uint8_t) value;                                       
400037c4:	c4 28 c0 01 	stb  %g2, [ %g3 + %g1 ]                        
                                                                      
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{                                                                     
  size_t i = 0;                                                       
                                                                      
  for (i = 0; i < 4; ++i) {                                           
400037c8:	82 00 60 01 	inc  %g1                                       
400037cc:	80 a0 60 04 	cmp  %g1, 4                                    
400037d0:	12 bf ff fd 	bne  400037c4 <rtems_bdpart_write+0x488>       
400037d4:	85 30 a0 08 	srl  %g2, 8, %g2                               
  data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;                         
400037d8:	f2 2e 21 d2 	stb  %i1, [ %i0 + 0x1d2 ]                      
  data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;                       
400037dc:	c0 2e 21 ce 	clrb  [ %i0 + 0x1ce ]                          
400037e0:	a4 04 a0 01 	inc  %l2                                       
400037e4:	10 bf ff c8 	b  40003704 <rtems_bdpart_write+0x3c8>         
400037e8:	b4 06 a0 30 	add  %i2, 0x30, %i2                            
      }                                                               
                                                                      
      /* New EBR */                                                   
      ebr = p->begin - record_space;                                  
      sc = rtems_bdpart_new_record( dd, ebr, &block);                 
      if (sc != RTEMS_SUCCESSFUL) {                                   
400037ec:	10 bf ff 26 	b  40003484 <rtems_bdpart_write+0x148>         <== NOT EXECUTED
400037f0:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
  const rtems_bdpart_partition *pt,                                   
  size_t count                                                        
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
400037f4:	10 bf ff 24 	b  40003484 <rtems_bdpart_write+0x148>         
400037f8:	b0 10 20 00 	clr  %i0                                       
                                                                      

4000330c <rtems_blkdev_create_partition>: const char *partition, const char *parent_block_device, rtems_blkdev_bnum media_block_begin, rtems_blkdev_bnum media_block_count ) {
4000330c:	9d e3 bf 50 	save  %sp, -176, %sp                           
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  int fd = open(parent_block_device, O_RDWR);                         
40003310:	92 10 20 02 	mov  2, %o1                                    
40003314:	90 10 00 19 	mov  %i1, %o0                                  
40003318:	40 00 09 a0 	call  40005998 <open>                          
4000331c:	b8 10 00 18 	mov  %i0, %i4                                  
                                                                      
    if (sc != RTEMS_SUCCESSFUL) {                                     
      close(fd);                                                      
    }                                                                 
  } else {                                                            
    sc = RTEMS_INVALID_ID;                                            
40003320:	b0 10 20 04 	mov  4, %i0                                    
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  int fd = open(parent_block_device, O_RDWR);                         
                                                                      
  if (fd >= 0) {                                                      
40003324:	80 a2 20 00 	cmp  %o0, 0                                    
40003328:	06 80 00 0a 	bl  40003350 <rtems_blkdev_create_partition+0x44>
4000332c:	ba 10 00 08 	mov  %o0, %i5                                  
    int rv;                                                           
    struct stat st;                                                   
                                                                      
    rv = fstat(fd, &st);                                              
40003330:	40 00 06 12 	call  40004b78 <fstat>                         
40003334:	92 07 bf b8 	add  %fp, -72, %o1                             
    if (rv == 0 && S_ISBLK(st.st_mode)) {                             
40003338:	80 a2 20 00 	cmp  %o0, 0                                    
4000333c:	02 80 00 07 	be  40003358 <rtems_blkdev_create_partition+0x4c><== ALWAYS TAKEN
40003340:	f2 07 bf c4 	ld  [ %fp + -60 ], %i1                         
40003344:	b0 10 20 15 	mov  0x15, %i0                                 <== NOT EXECUTED
    } else {                                                          
      sc = RTEMS_INVALID_NODE;                                        
    }                                                                 
                                                                      
    if (sc != RTEMS_SUCCESSFUL) {                                     
      close(fd);                                                      
40003348:	40 00 05 c0 	call  40004a48 <close>                         
4000334c:	90 10 00 1d 	mov  %i5, %o0                                  
40003350:	81 c7 e0 08 	ret                                            
40003354:	81 e8 00 00 	restore                                        
  if (fd >= 0) {                                                      
    int rv;                                                           
    struct stat st;                                                   
                                                                      
    rv = fstat(fd, &st);                                              
    if (rv == 0 && S_ISBLK(st.st_mode)) {                             
40003358:	03 00 00 3c 	sethi  %hi(0xf000), %g1                        
4000335c:	b2 0e 40 01 	and  %i1, %g1, %i1                             
40003360:	03 00 00 18 	sethi  %hi(0x6000), %g1                        
40003364:	80 a6 40 01 	cmp  %i1, %g1                                  
40003368:	12 bf ff f8 	bne  40003348 <rtems_blkdev_create_partition+0x3c>
4000336c:	b0 10 20 15 	mov  0x15, %i0                                 
static inline int rtems_disk_fd_get_disk_device(                      
  int fd,                                                             
  rtems_disk_device **dd_ptr                                          
)                                                                     
{                                                                     
  return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);                   
40003370:	90 10 00 1d 	mov  %i5, %o0                                  
40003374:	94 07 bf b4 	add  %fp, -76, %o2                             
40003378:	13 10 01 10 	sethi  %hi(0x40044000), %o1                    
          }                                                           
        } else {                                                      
          sc = RTEMS_NO_MEMORY;                                       
        }                                                             
      } else {                                                        
        sc = RTEMS_NOT_IMPLEMENTED;                                   
4000337c:	b0 10 20 18 	mov  0x18, %i0                                 
40003380:	40 00 06 54 	call  40004cd0 <ioctl>                         
40003384:	92 12 62 09 	or  %o1, 0x209, %o1                            
    rv = fstat(fd, &st);                                              
    if (rv == 0 && S_ISBLK(st.st_mode)) {                             
      rtems_disk_device *phys_dd;                                     
                                                                      
      rv = rtems_disk_fd_get_disk_device(fd, &phys_dd);               
      if (rv == 0) {                                                  
40003388:	80 a2 20 00 	cmp  %o0, 0                                    
4000338c:	12 bf ff ef 	bne  40003348 <rtems_blkdev_create_partition+0x3c>
40003390:	01 00 00 00 	nop                                            
        rtems_blkdev_imfs_context *ctx = malloc(sizeof(*ctx));        
40003394:	40 00 07 6c 	call  40005144 <malloc>                        
40003398:	90 10 20 80 	mov  0x80, %o0	! 80 <PROM_START+0x80>          
                                                                      
        if (ctx != NULL) {                                            
4000339c:	a0 92 20 00 	orcc  %o0, 0, %l0                              
400033a0:	02 80 00 17 	be  400033fc <rtems_blkdev_create_partition+0xf0>
400033a4:	d2 07 bf b4 	ld  [ %fp + -76 ], %o1                         
          sc = rtems_disk_init_log(                                   
400033a8:	94 10 00 1a 	mov  %i2, %o2                                  
400033ac:	40 00 00 96 	call  40003604 <rtems_disk_init_log>           
400033b0:	96 10 00 1b 	mov  %i3, %o3                                  
            phys_dd,                                                  
            media_block_begin,                                        
            media_block_count                                         
          );                                                          
                                                                      
          if (sc == RTEMS_SUCCESSFUL) {                               
400033b4:	b0 92 20 00 	orcc  %o0, 0, %i0                              
400033b8:	12 80 00 0e 	bne  400033f0 <rtems_blkdev_create_partition+0xe4>
400033bc:	90 10 00 1c 	mov  %i4, %o0                                  
            ctx->fd = fd;                                             
400033c0:	fa 24 20 78 	st  %i5, [ %l0 + 0x78 ]                        
                                                                      
            rv = IMFS_make_generic_node(                              
400033c4:	92 16 61 ff 	or  %i1, 0x1ff, %o1                            
400033c8:	96 10 00 10 	mov  %l0, %o3                                  
400033cc:	15 10 00 68 	sethi  %hi(0x4001a000), %o2                    
400033d0:	40 00 03 cb 	call  400042fc <IMFS_make_generic_node>        
400033d4:	94 12 a0 50 	or  %o2, 0x50, %o2	! 4001a050 <rtems_blkdev_imfs_control>
              S_IFBLK | S_IRWXU | S_IRWXG | S_IRWXO,                  
              &rtems_blkdev_imfs_control,                             
              ctx                                                     
            );                                                        
                                                                      
            if (rv != 0) {                                            
400033d8:	80 a2 20 00 	cmp  %o0, 0                                    
400033dc:	02 bf ff dd 	be  40003350 <rtems_blkdev_create_partition+0x44>
400033e0:	90 10 00 10 	mov  %l0, %o0                                  
              free(ctx);                                              
400033e4:	40 00 05 bb 	call  40004ad0 <free>                          
400033e8:	b0 10 20 0d 	mov  0xd, %i0                                  
400033ec:	30 bf ff d7 	b,a   40003348 <rtems_blkdev_create_partition+0x3c>
              sc = RTEMS_UNSATISFIED;                                 
            }                                                         
          } else {                                                    
            free(ctx);                                                
400033f0:	40 00 05 b8 	call  40004ad0 <free>                          
400033f4:	90 10 00 10 	mov  %l0, %o0                                  
400033f8:	30 bf ff d4 	b,a   40003348 <rtems_blkdev_create_partition+0x3c>
          }                                                           
        } else {                                                      
          sc = RTEMS_NO_MEMORY;                                       
400033fc:	10 bf ff d3 	b  40003348 <rtems_blkdev_create_partition+0x3c>
40003400:	b0 10 20 1a 	mov  0x1a, %i0                                 
                                                                      

4000f468 <rtems_blkdev_generic_ioctl>: rtems_device_driver rtems_blkdev_generic_ioctl( rtems_device_major_number major __attribute__((unused)), rtems_device_minor_number minor __attribute__((unused)), void * arg) {
4000f468:	9d e3 bf a0 	save  %sp, -96, %sp                            
    rtems_libio_ioctl_args_t *args = arg;                             
    rtems_libio_t *iop = args->iop;                                   
    rtems_disk_device *dd = iop->data1;                               
4000f46c:	c2 06 80 00 	ld  [ %i2 ], %g1                               
                                                                      
    if (args->command != RTEMS_BLKIO_REQUEST)                         
4000f470:	d2 06 a0 04 	ld  [ %i2 + 4 ], %o1                           
    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;                               
4000f474:	d0 00 60 30 	ld  [ %g1 + 0x30 ], %o0                        
                                                                      
    if (args->command != RTEMS_BLKIO_REQUEST)                         
4000f478:	03 30 06 10 	sethi  %hi(0xc0184000), %g1                    
4000f47c:	82 10 62 01 	or  %g1, 0x201, %g1	! c0184201 <LEON_REG+0x40184201>
4000f480:	80 a2 40 01 	cmp  %o1, %g1                                  
4000f484:	12 80 00 05 	bne  4000f498 <rtems_blkdev_generic_ioctl+0x30><== ALWAYS TAKEN
4000f488:	82 10 3f ff 	mov  -1, %g1                                   
    {                                                                 
        /*                                                            
         * It is not allowed to directly access the driver circumventing the
         * cache.                                                     
         */                                                           
        args->ioctl_return = -1;                                      
4000f48c:	c2 26 a0 0c 	st  %g1, [ %i2 + 0xc ]                         <== NOT EXECUTED
    }                                                                 
                                                                      
    return RTEMS_SUCCESSFUL;                                          
}                                                                     
4000f490:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000f494:	91 e8 20 00 	restore  %g0, 0, %o0                           <== NOT EXECUTED
    rtems_libio_t *iop = args->iop;                                   
    rtems_disk_device *dd = iop->data1;                               
                                                                      
    if (args->command != RTEMS_BLKIO_REQUEST)                         
    {                                                                 
        args->ioctl_return = dd->ioctl(dd,                            
4000f498:	c2 02 20 38 	ld  [ %o0 + 0x38 ], %g1                        
4000f49c:	d4 06 a0 08 	ld  [ %i2 + 8 ], %o2                           
4000f4a0:	9f c0 40 00 	call  %g1                                      
4000f4a4:	b0 10 20 00 	clr  %i0                                       
4000f4a8:	d0 26 a0 0c 	st  %o0, [ %i2 + 0xc ]                         
         */                                                           
        args->ioctl_return = -1;                                      
    }                                                                 
                                                                      
    return RTEMS_SUCCESSFUL;                                          
}                                                                     
4000f4ac:	81 c7 e0 08 	ret                                            
4000f4b0:	81 e8 00 00 	restore                                        
                                                                      

4000f224 <rtems_blkdev_generic_read>: rtems_device_driver rtems_blkdev_generic_read( rtems_device_major_number major __attribute__((unused)), rtems_device_minor_number minor __attribute__((unused)), void * arg) {
4000f224:	9d e3 bf 98 	save  %sp, -104, %sp                           
    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;                               
4000f228:	c2 06 80 00 	ld  [ %i2 ], %g1                               
    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);
4000f22c:	f8 1e a0 08 	ldd  [ %i2 + 8 ], %i4                          
    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;                               
4000f230:	e4 00 60 30 	ld  [ %g1 + 0x30 ], %l2                        
    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);
4000f234:	94 10 20 00 	clr  %o2                                       
{                                                                     
    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;                             
4000f238:	e2 04 a0 24 	ld  [ %l2 + 0x24 ], %l1                        
    char *buf = args->buffer;                                         
    uint32_t count = args->count;                                     
    rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
4000f23c:	90 10 00 1c 	mov  %i4, %o0                                  
4000f240:	96 10 00 11 	mov  %l1, %o3                                  
    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;                                         
    uint32_t count = args->count;                                     
4000f244:	f6 06 a0 14 	ld  [ %i2 + 0x14 ], %i3                        
    rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
4000f248:	40 00 22 06 	call  40017a60 <__divdi3>                      
4000f24c:	92 10 00 1d 	mov  %i5, %o1                                  
    uint32_t blkofs = (uint32_t) (args->offset % block_size);         
4000f250:	90 10 00 1c 	mov  %i4, %o0                                  
    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);
4000f254:	b2 10 00 09 	mov  %o1, %i1                                  
    uint32_t blkofs = (uint32_t) (args->offset % block_size);         
4000f258:	94 10 20 00 	clr  %o2                                       
4000f25c:	92 10 00 1d 	mov  %i5, %o1                                  
4000f260:	40 00 22 eb 	call  40017e0c <__moddi3>                      
4000f264:	96 10 00 11 	mov  %l1, %o3                                  
                                                                      
    args->bytes_moved = 0;                                            
4000f268:	c0 26 a0 1c 	clr  [ %i2 + 0x1c ]                            
    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);         
4000f26c:	a0 10 00 09 	mov  %o1, %l0                                  
                                                                      
    args->bytes_moved = 0;                                            
                                                                      
    while (count > 0)                                                 
4000f270:	80 a6 e0 00 	cmp  %i3, 0                                    
4000f274:	12 80 00 1a 	bne  4000f2dc <rtems_blkdev_generic_read+0xb8> <== ALWAYS TAKEN
4000f278:	f8 06 a0 10 	ld  [ %i2 + 0x10 ], %i4                        
rtems_blkdev_generic_read(                                            
    rtems_device_major_number major __attribute__((unused)),          
    rtems_device_minor_number minor __attribute__((unused)),          
    void                    * arg)                                    
{                                                                     
    rtems_status_code rc = RTEMS_SUCCESSFUL;                          
4000f27c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000f280:	91 e8 20 00 	restore  %g0, 0, %o0                           <== NOT EXECUTED
        uint32_t            copy;                                     
                                                                      
        rc = rtems_bdbuf_read(dd, block, &diskbuf);                   
        if (rc != RTEMS_SUCCESSFUL)                                   
            break;                                                    
        copy = block_size - blkofs;                                   
4000f284:	ba 24 40 10 	sub  %l1, %l0, %i5                             
4000f288:	80 a7 40 1b 	cmp  %i5, %i3                                  
        if (copy > count)                                             
            copy = count;                                             
        memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);          
4000f28c:	08 80 00 03 	bleu  4000f298 <rtems_blkdev_generic_read+0x74><== ALWAYS TAKEN
4000f290:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4000f294:	ba 10 00 1b 	mov  %i3, %i5                                  <== NOT EXECUTED
4000f298:	d2 00 60 1c 	ld  [ %g1 + 0x1c ], %o1                        
4000f29c:	94 10 00 1d 	mov  %i5, %o2                                  
4000f2a0:	40 00 15 14 	call  400146f0 <memcpy>                        
4000f2a4:	92 02 40 10 	add  %o1, %l0, %o1                             
        rc = rtems_bdbuf_release(diskbuf);                            
4000f2a8:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
4000f2ac:	7f ff fd e9 	call  4000ea50 <rtems_bdbuf_release>           
4000f2b0:	b8 07 00 1d 	add  %i4, %i5, %i4                             
        args->bytes_moved += copy;                                    
4000f2b4:	c2 06 a0 1c 	ld  [ %i2 + 0x1c ], %g1                        
            break;                                                    
        copy = block_size - blkofs;                                   
        if (copy > count)                                             
            copy = count;                                             
        memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);          
        rc = rtems_bdbuf_release(diskbuf);                            
4000f2b8:	b0 10 00 08 	mov  %o0, %i0                                  
        args->bytes_moved += copy;                                    
4000f2bc:	82 00 40 1d 	add  %g1, %i5, %g1                             
        if (rc != RTEMS_SUCCESSFUL)                                   
4000f2c0:	80 a2 20 00 	cmp  %o0, 0                                    
4000f2c4:	12 80 00 0e 	bne  4000f2fc <rtems_blkdev_generic_read+0xd8> <== NEVER TAKEN
4000f2c8:	c2 26 a0 1c 	st  %g1, [ %i2 + 0x1c ]                        
            break;                                                    
        count -= copy;                                                
        buf += copy;                                                  
        blkofs = 0;                                                   
        block++;                                                      
4000f2cc:	b2 06 60 01 	inc  %i1                                       
    rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
    uint32_t blkofs = (uint32_t) (args->offset % block_size);         
                                                                      
    args->bytes_moved = 0;                                            
                                                                      
    while (count > 0)                                                 
4000f2d0:	b6 a6 c0 1d 	subcc  %i3, %i5, %i3                           
4000f2d4:	02 80 00 0c 	be  4000f304 <rtems_blkdev_generic_read+0xe0>  <== ALWAYS TAKEN
4000f2d8:	a0 10 20 00 	clr  %l0                                       
    {                                                                 
        rtems_bdbuf_buffer *diskbuf;                                  
        uint32_t            copy;                                     
                                                                      
        rc = rtems_bdbuf_read(dd, block, &diskbuf);                   
4000f2dc:	92 10 00 19 	mov  %i1, %o1                                  
4000f2e0:	94 07 bf fc 	add  %fp, -4, %o2                              
4000f2e4:	7f ff fd 56 	call  4000e83c <rtems_bdbuf_read>              
4000f2e8:	90 10 00 12 	mov  %l2, %o0                                  
4000f2ec:	b0 10 00 08 	mov  %o0, %i0                                  
        if (rc != RTEMS_SUCCESSFUL)                                   
4000f2f0:	80 a6 20 00 	cmp  %i0, 0                                    
4000f2f4:	02 bf ff e4 	be  4000f284 <rtems_blkdev_generic_read+0x60>  <== ALWAYS TAKEN
4000f2f8:	90 10 00 1c 	mov  %i4, %o0                                  
        blkofs = 0;                                                   
        block++;                                                      
    }                                                                 
                                                                      
    return rc;                                                        
}                                                                     
4000f2fc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000f300:	81 e8 00 00 	restore                                        <== NOT EXECUTED
rtems_blkdev_generic_read(                                            
    rtems_device_major_number major __attribute__((unused)),          
    rtems_device_minor_number minor __attribute__((unused)),          
    void                    * arg)                                    
{                                                                     
    rtems_status_code rc = RTEMS_SUCCESSFUL;                          
4000f304:	b0 10 20 00 	clr  %i0                                       
4000f308:	81 c7 e0 08 	ret                                            
4000f30c:	81 e8 00 00 	restore                                        
                                                                      

4000f310 <rtems_blkdev_generic_write>: rtems_device_driver rtems_blkdev_generic_write( rtems_device_major_number major __attribute__((unused)), rtems_device_minor_number minor __attribute__((unused)), void * arg) {
4000f310:	9d e3 bf 98 	save  %sp, -104, %sp                           
    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;                               
4000f314:	c2 06 80 00 	ld  [ %i2 ], %g1                               
    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);
4000f318:	f8 1e a0 08 	ldd  [ %i2 + 8 ], %i4                          
    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;                               
4000f31c:	e2 00 60 30 	ld  [ %g1 + 0x30 ], %l1                        
    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);
4000f320:	94 10 20 00 	clr  %o2                                       
{                                                                     
    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;                             
4000f324:	e0 04 60 24 	ld  [ %l1 + 0x24 ], %l0                        
    char *buf = args->buffer;                                         
    uint32_t count = args->count;                                     
    rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
4000f328:	90 10 00 1c 	mov  %i4, %o0                                  
4000f32c:	96 10 00 10 	mov  %l0, %o3                                  
    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;                                         
    uint32_t count = args->count;                                     
4000f330:	f6 06 a0 14 	ld  [ %i2 + 0x14 ], %i3                        
    rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
4000f334:	40 00 21 cb 	call  40017a60 <__divdi3>                      
4000f338:	92 10 00 1d 	mov  %i5, %o1                                  
    uint32_t blkofs = (uint32_t) (args->offset % block_size);         
4000f33c:	90 10 00 1c 	mov  %i4, %o0                                  
    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);
4000f340:	b0 10 00 09 	mov  %o1, %i0                                  
    uint32_t blkofs = (uint32_t) (args->offset % block_size);         
4000f344:	94 10 20 00 	clr  %o2                                       
4000f348:	92 10 00 1d 	mov  %i5, %o1                                  
4000f34c:	40 00 22 b0 	call  40017e0c <__moddi3>                      
4000f350:	96 10 00 10 	mov  %l0, %o3                                  
                                                                      
    args->bytes_moved = 0;                                            
4000f354:	c0 26 a0 1c 	clr  [ %i2 + 0x1c ]                            
    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);         
4000f358:	b8 10 00 09 	mov  %o1, %i4                                  
                                                                      
    args->bytes_moved = 0;                                            
                                                                      
    while (count > 0)                                                 
4000f35c:	80 a6 e0 00 	cmp  %i3, 0                                    
4000f360:	12 80 00 21 	bne  4000f3e4 <rtems_blkdev_generic_write+0xd4><== ALWAYS TAKEN
4000f364:	f2 06 a0 10 	ld  [ %i2 + 0x10 ], %i1                        
rtems_blkdev_generic_write(                                           
    rtems_device_major_number major __attribute__((unused)),          
    rtems_device_minor_number minor __attribute__((unused)),          
    void                    * arg)                                    
{                                                                     
    rtems_status_code rc = RTEMS_SUCCESSFUL;                          
4000f368:	10 80 00 2c 	b  4000f418 <rtems_blkdev_generic_write+0x108> <== NOT EXECUTED
4000f36c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
    while (count > 0)                                                 
    {                                                                 
        rtems_bdbuf_buffer *diskbuf;                                  
        uint32_t            copy;                                     
                                                                      
        if ((blkofs == 0) && (count >= block_size))                   
4000f370:	12 80 00 21 	bne  4000f3f4 <rtems_blkdev_generic_write+0xe4><== NEVER TAKEN
4000f374:	92 10 00 18 	mov  %i0, %o1                                  
            rc = rtems_bdbuf_get(dd, block, &diskbuf);                
4000f378:	90 10 00 11 	mov  %l1, %o0                                  
4000f37c:	7f ff fc f0 	call  4000e73c <rtems_bdbuf_get>               
4000f380:	94 07 bf fc 	add  %fp, -4, %o2                              
        else                                                          
            rc = rtems_bdbuf_read(dd, block, &diskbuf);               
        if (rc != RTEMS_SUCCESSFUL)                                   
4000f384:	80 a2 20 00 	cmp  %o0, 0                                    
4000f388:	12 80 00 21 	bne  4000f40c <rtems_blkdev_generic_write+0xfc><== NEVER TAKEN
4000f38c:	92 10 00 19 	mov  %i1, %o1                                  
            break;                                                    
                                                                      
        copy = block_size - blkofs;                                   
4000f390:	ba 24 00 1c 	sub  %l0, %i4, %i5                             
4000f394:	80 a7 40 1b 	cmp  %i5, %i3                                  
        if (copy > count)                                             
            copy = count;                                             
        memcpy((char *)diskbuf->buffer + blkofs, buf, copy);          
4000f398:	08 80 00 03 	bleu  4000f3a4 <rtems_blkdev_generic_write+0x94><== ALWAYS TAKEN
4000f39c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4000f3a0:	ba 10 00 1b 	mov  %i3, %i5                                  <== NOT EXECUTED
4000f3a4:	d0 00 60 1c 	ld  [ %g1 + 0x1c ], %o0                        
4000f3a8:	94 10 00 1d 	mov  %i5, %o2                                  
4000f3ac:	40 00 14 d1 	call  400146f0 <memcpy>                        
4000f3b0:	90 02 00 1c 	add  %o0, %i4, %o0                             
        args->bytes_moved += copy;                                    
4000f3b4:	c2 06 a0 1c 	ld  [ %i2 + 0x1c ], %g1                        
                                                                      
        rc = rtems_bdbuf_release_modified(diskbuf);                   
4000f3b8:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
                                                                      
        copy = block_size - blkofs;                                   
        if (copy > count)                                             
            copy = count;                                             
        memcpy((char *)diskbuf->buffer + blkofs, buf, copy);          
        args->bytes_moved += copy;                                    
4000f3bc:	82 00 40 1d 	add  %g1, %i5, %g1                             
        rc = rtems_bdbuf_release_modified(diskbuf);                   
        if (rc != RTEMS_SUCCESSFUL)                                   
            break;                                                    
                                                                      
        count -= copy;                                                
        buf += copy;                                                  
4000f3c0:	b2 06 40 1d 	add  %i1, %i5, %i1                             
        if (copy > count)                                             
            copy = count;                                             
        memcpy((char *)diskbuf->buffer + blkofs, buf, copy);          
        args->bytes_moved += copy;                                    
                                                                      
        rc = rtems_bdbuf_release_modified(diskbuf);                   
4000f3c4:	7f ff fd db 	call  4000eb30 <rtems_bdbuf_release_modified>  
4000f3c8:	c2 26 a0 1c 	st  %g1, [ %i2 + 0x1c ]                        
        if (rc != RTEMS_SUCCESSFUL)                                   
4000f3cc:	80 a2 20 00 	cmp  %o0, 0                                    
4000f3d0:	12 80 00 0f 	bne  4000f40c <rtems_blkdev_generic_write+0xfc><== NEVER TAKEN
4000f3d4:	b6 a6 c0 1d 	subcc  %i3, %i5, %i3                           
            break;                                                    
                                                                      
        count -= copy;                                                
        buf += copy;                                                  
        blkofs = 0;                                                   
        block++;                                                      
4000f3d8:	b0 06 20 01 	inc  %i0                                       
    rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
    uint32_t blkofs = (uint32_t) (args->offset % block_size);         
                                                                      
    args->bytes_moved = 0;                                            
                                                                      
    while (count > 0)                                                 
4000f3dc:	02 80 00 0e 	be  4000f414 <rtems_blkdev_generic_write+0x104><== ALWAYS TAKEN
4000f3e0:	b8 10 20 00 	clr  %i4                                       
    {                                                                 
        rtems_bdbuf_buffer *diskbuf;                                  
        uint32_t            copy;                                     
                                                                      
        if ((blkofs == 0) && (count >= block_size))                   
4000f3e4:	80 a6 c0 10 	cmp  %i3, %l0                                  
4000f3e8:	1a bf ff e2 	bcc  4000f370 <rtems_blkdev_generic_write+0x60><== ALWAYS TAKEN
4000f3ec:	80 a7 20 00 	cmp  %i4, 0                                    
            rc = rtems_bdbuf_get(dd, block, &diskbuf);                
        else                                                          
            rc = rtems_bdbuf_read(dd, block, &diskbuf);               
4000f3f0:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
4000f3f4:	94 07 bf fc 	add  %fp, -4, %o2                              <== NOT EXECUTED
4000f3f8:	7f ff fd 11 	call  4000e83c <rtems_bdbuf_read>              <== NOT EXECUTED
4000f3fc:	90 10 00 11 	mov  %l1, %o0                                  <== NOT EXECUTED
        if (rc != RTEMS_SUCCESSFUL)                                   
4000f400:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4000f404:	02 bf ff e3 	be  4000f390 <rtems_blkdev_generic_write+0x80> <== NOT EXECUTED
4000f408:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
        blkofs = 0;                                                   
        block++;                                                      
    }                                                                 
                                                                      
    return rc;                                                        
}                                                                     
4000f40c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000f410:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
rtems_blkdev_generic_write(                                           
    rtems_device_major_number major __attribute__((unused)),          
    rtems_device_minor_number minor __attribute__((unused)),          
    void                    * arg)                                    
{                                                                     
    rtems_status_code rc = RTEMS_SUCCESSFUL;                          
4000f414:	90 10 20 00 	clr  %o0                                       
        blkofs = 0;                                                   
        block++;                                                      
    }                                                                 
                                                                      
    return rc;                                                        
}                                                                     
4000f418:	81 c7 e0 08 	ret                                            
4000f41c:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

400031e8 <rtems_blkdev_imfs_fsync_or_fdatasync>: } static int rtems_blkdev_imfs_fsync_or_fdatasync( rtems_libio_t *iop ) {
400031e8:	9d e3 bf a0 	save  %sp, -96, %sp                            
400031ec:	c2 06 20 1c 	ld  [ %i0 + 0x1c ], %g1                        
  int rv = 0;                                                         
400031f0:	b0 10 20 00 	clr  %i0                                       
  rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
  rtems_disk_device *dd = &ctx->dd;                                   
  rtems_status_code sc = rtems_bdbuf_syncdev(dd);                     
400031f4:	40 00 31 be 	call  4000f8ec <rtems_bdbuf_syncdev>           
400031f8:	d0 00 60 50 	ld  [ %g1 + 0x50 ], %o0                        
                                                                      
  if (sc != RTEMS_SUCCESSFUL) {                                       
400031fc:	80 a2 20 00 	cmp  %o0, 0                                    
40003200:	12 80 00 04 	bne  40003210 <rtems_blkdev_imfs_fsync_or_fdatasync+0x28><== NEVER TAKEN
40003204:	01 00 00 00 	nop                                            
    errno = EIO;                                                      
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
40003208:	81 c7 e0 08 	ret                                            
4000320c:	81 e8 00 00 	restore                                        
  rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
  rtems_disk_device *dd = &ctx->dd;                                   
  rtems_status_code sc = rtems_bdbuf_syncdev(dd);                     
                                                                      
  if (sc != RTEMS_SUCCESSFUL) {                                       
    errno = EIO;                                                      
40003210:	40 00 44 9c 	call  40014480 <__errno>                       <== NOT EXECUTED
40003214:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40003218:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
4000321c:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
40003220:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40003224:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40003228 <rtems_blkdev_imfs_ioctl>: static int rtems_blkdev_imfs_ioctl( rtems_libio_t *iop, uint32_t request, void *buffer ) {
40003228:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rv = 0;                                                         
                                                                      
  if (request != RTEMS_BLKIO_REQUEST) {                               
4000322c:	03 30 06 10 	sethi  %hi(0xc0184000), %g1                    
40003230:	82 10 62 01 	or  %g1, 0x201, %g1	! c0184201 <LEON_REG+0x40184201>
40003234:	80 a6 40 01 	cmp  %i1, %g1                                  
40003238:	02 80 00 09 	be  4000325c <rtems_blkdev_imfs_ioctl+0x34>    <== NEVER TAKEN
4000323c:	92 10 00 19 	mov  %i1, %o1                                  
40003240:	c2 06 20 1c 	ld  [ %i0 + 0x1c ], %g1                        
40003244:	d0 00 60 50 	ld  [ %g1 + 0x50 ], %o0                        
    rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
    rtems_disk_device *dd = &ctx->dd;                                 
                                                                      
    rv = (*dd->ioctl)(dd, request, buffer);                           
40003248:	c2 02 20 38 	ld  [ %o0 + 0x38 ], %g1                        
4000324c:	9f c0 40 00 	call  %g1                                      
40003250:	94 10 00 1a 	mov  %i2, %o2                                  
40003254:	81 c7 e0 08 	ret                                            
40003258:	91 e8 00 08 	restore  %g0, %o0, %o0                         
  } else {                                                            
    /*                                                                
     * It is not allowed to directly access the driver circumventing the cache.
     */                                                               
    errno = EINVAL;                                                   
4000325c:	40 00 44 89 	call  40014480 <__errno>                       <== NOT EXECUTED
40003260:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40003264:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
40003268:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
4000326c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40003270:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4000305c <rtems_blkdev_imfs_read>: static ssize_t rtems_blkdev_imfs_read( rtems_libio_t *iop, void *buffer, size_t count ) {
4000305c:	9d e3 bf 98 	save  %sp, -104, %sp                           
40003060:	c2 06 20 1c 	ld  [ %i0 + 0x1c ], %g1                        
  int rv;                                                             
  rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
  rtems_disk_device *dd = &ctx->dd;                                   
  ssize_t remaining = (ssize_t) count;                                
  off_t offset = iop->offset;                                         
40003064:	f8 1e 20 08 	ldd  [ %i0 + 8 ], %i4                          
40003068:	e2 00 60 50 	ld  [ %g1 + 0x50 ], %l1                        
  ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);       
  rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
4000306c:	92 10 00 1d 	mov  %i5, %o1                                  
  int rv;                                                             
  rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
  rtems_disk_device *dd = &ctx->dd;                                   
  ssize_t remaining = (ssize_t) count;                                
  off_t offset = iop->offset;                                         
  ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);       
40003070:	e4 04 60 24 	ld  [ %l1 + 0x24 ], %l2                        
  rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
40003074:	90 10 00 1c 	mov  %i4, %o0                                  
40003078:	a1 3c a0 1f 	sra  %l2, 0x1f, %l0                            
4000307c:	96 10 00 12 	mov  %l2, %o3                                  
40003080:	40 00 54 74 	call  40018250 <__divdi3>                      
40003084:	94 10 00 10 	mov  %l0, %o2                                  
  ssize_t block_offset = (ssize_t) (offset % block_size);             
40003088:	94 10 00 10 	mov  %l0, %o2                                  
  rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
  rtems_disk_device *dd = &ctx->dd;                                   
  ssize_t remaining = (ssize_t) count;                                
  off_t offset = iop->offset;                                         
  ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);       
  rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
4000308c:	b6 10 00 09 	mov  %o1, %i3                                  
  ssize_t block_offset = (ssize_t) (offset % block_size);             
40003090:	90 10 00 1c 	mov  %i4, %o0                                  
40003094:	92 10 00 1d 	mov  %i5, %o1                                  
40003098:	40 00 55 59 	call  400185fc <__moddi3>                      
4000309c:	96 10 00 12 	mov  %l2, %o3                                  
  char *dst = buffer;                                                 
                                                                      
  while (remaining > 0) {                                             
400030a0:	ba 96 a0 00 	orcc  %i2, 0, %i5                              
400030a4:	04 80 00 23 	ble  40003130 <rtems_blkdev_imfs_read+0xd4>    <== NEVER TAKEN
400030a8:	a0 10 00 09 	mov  %o1, %l0                                  
    rtems_bdbuf_buffer *bd;                                           
    rtems_status_code sc = rtems_bdbuf_read(dd, block, &bd);          
400030ac:	92 10 00 1b 	mov  %i3, %o1                                  
400030b0:	94 07 bf fc 	add  %fp, -4, %o2                              
400030b4:	40 00 30 df 	call  4000f430 <rtems_bdbuf_read>              
400030b8:	90 10 00 11 	mov  %l1, %o0                                  
                                                                      
    if (sc == RTEMS_SUCCESSFUL) {                                     
400030bc:	80 a2 20 00 	cmp  %o0, 0                                    
400030c0:	02 80 00 09 	be  400030e4 <rtems_blkdev_imfs_read+0x88>     <== ALWAYS TAKEN
400030c4:	90 10 00 19 	mov  %i1, %o0                                  
                                                                      
  if (remaining >= 0) {                                               
    iop->offset += count;                                             
    rv = (ssize_t) count;                                             
  } else {                                                            
    errno = EIO;                                                      
400030c8:	40 00 44 ee 	call  40014480 <__errno>                       <== NOT EXECUTED
400030cc:	01 00 00 00 	nop                                            <== NOT EXECUTED
    rv = -1;                                                          
400030d0:	82 10 3f ff 	mov  -1, %g1	! ffffffff <LEON_REG+0x7fffffff>  <== NOT EXECUTED
                                                                      
  if (remaining >= 0) {                                               
    iop->offset += count;                                             
    rv = (ssize_t) count;                                             
  } else {                                                            
    errno = EIO;                                                      
400030d4:	84 10 20 05 	mov  5, %g2                                    <== NOT EXECUTED
400030d8:	c4 22 00 00 	st  %g2, [ %o0 ]                               <== NOT EXECUTED
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
400030dc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400030e0:	91 e8 00 01 	restore  %g0, %g1, %o0                         <== NOT EXECUTED
  while (remaining > 0) {                                             
    rtems_bdbuf_buffer *bd;                                           
    rtems_status_code sc = rtems_bdbuf_read(dd, block, &bd);          
                                                                      
    if (sc == RTEMS_SUCCESSFUL) {                                     
      ssize_t copy = block_size - block_offset;                       
400030e4:	b8 24 80 10 	sub  %l2, %l0, %i4                             
400030e8:	80 a7 00 1d 	cmp  %i4, %i5                                  
                                                                      
      if (copy > remaining) {                                         
        copy = remaining;                                             
      }                                                               
                                                                      
      memcpy(dst, (char *) bd->buffer + block_offset, (size_t) copy); 
400030ec:	04 80 00 03 	ble  400030f8 <rtems_blkdev_imfs_read+0x9c>    
400030f0:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
400030f4:	b8 10 00 1d 	mov  %i5, %i4                                  
400030f8:	d2 00 60 1c 	ld  [ %g1 + 0x1c ], %o1                        
400030fc:	94 10 00 1c 	mov  %i4, %o2                                  
40003100:	40 00 47 41 	call  40014e04 <memcpy>                        
40003104:	92 02 40 10 	add  %o1, %l0, %o1                             
                                                                      
      sc = rtems_bdbuf_release(bd);                                   
40003108:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
4000310c:	40 00 31 4e 	call  4000f644 <rtems_bdbuf_release>           
40003110:	ba 27 40 1c 	sub  %i5, %i4, %i5                             
      if (sc == RTEMS_SUCCESSFUL) {                                   
40003114:	80 a2 20 00 	cmp  %o0, 0                                    
40003118:	12 bf ff ec 	bne  400030c8 <rtems_blkdev_imfs_read+0x6c>    <== NEVER TAKEN
4000311c:	80 a7 60 00 	cmp  %i5, 0                                    
        block_offset = 0;                                             
        remaining -= copy;                                            
        dst += copy;                                                  
40003120:	b2 06 40 1c 	add  %i1, %i4, %i1                             
        ++block;                                                      
40003124:	b6 06 e0 01 	inc  %i3                                       
  ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);       
  rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
  ssize_t block_offset = (ssize_t) (offset % block_size);             
  char *dst = buffer;                                                 
                                                                      
  while (remaining > 0) {                                             
40003128:	14 bf ff e1 	bg  400030ac <rtems_blkdev_imfs_read+0x50>     
4000312c:	a0 10 20 00 	clr  %l0                                       
    } else {                                                          
      remaining = -1;                                                 
    }                                                                 
  }                                                                   
                                                                      
  if (remaining >= 0) {                                               
40003130:	80 a7 60 00 	cmp  %i5, 0                                    
40003134:	12 bf ff e5 	bne  400030c8 <rtems_blkdev_imfs_read+0x6c>    <== NEVER TAKEN
40003138:	82 10 00 1a 	mov  %i2, %g1                                  
    iop->offset += count;                                             
4000313c:	c4 1e 20 08 	ldd  [ %i0 + 8 ], %g2                          
40003140:	86 80 c0 1a 	addcc  %g3, %i2, %g3                           
40003144:	84 40 a0 00 	addx  %g2, 0, %g2                              
40003148:	c4 3e 20 08 	std  %g2, [ %i0 + 8 ]                          
    errno = EIO;                                                      
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
4000314c:	81 c7 e0 08 	ret                                            
40003150:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      

40002f28 <rtems_blkdev_imfs_write>: static ssize_t rtems_blkdev_imfs_write( rtems_libio_t *iop, const void *buffer, size_t count ) {
40002f28:	9d e3 bf 98 	save  %sp, -104, %sp                           
40002f2c:	c2 06 20 1c 	ld  [ %i0 + 0x1c ], %g1                        
  int rv;                                                             
  rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
  rtems_disk_device *dd = &ctx->dd;                                   
  ssize_t remaining = (ssize_t) count;                                
  off_t offset = iop->offset;                                         
40002f30:	f8 1e 20 08 	ldd  [ %i0 + 8 ], %i4                          
40002f34:	e2 00 60 50 	ld  [ %g1 + 0x50 ], %l1                        
  ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);       
  rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
40002f38:	92 10 00 1d 	mov  %i5, %o1                                  
  int rv;                                                             
  rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
  rtems_disk_device *dd = &ctx->dd;                                   
  ssize_t remaining = (ssize_t) count;                                
  off_t offset = iop->offset;                                         
  ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);       
40002f3c:	f6 04 60 24 	ld  [ %l1 + 0x24 ], %i3                        
  rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
40002f40:	90 10 00 1c 	mov  %i4, %o0                                  
40002f44:	a1 3e e0 1f 	sra  %i3, 0x1f, %l0                            
40002f48:	96 10 00 1b 	mov  %i3, %o3                                  
40002f4c:	40 00 54 c1 	call  40018250 <__divdi3>                      
40002f50:	94 10 00 10 	mov  %l0, %o2                                  
  ssize_t block_offset = (ssize_t) (offset % block_size);             
40002f54:	94 10 00 10 	mov  %l0, %o2                                  
  rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
  rtems_disk_device *dd = &ctx->dd;                                   
  ssize_t remaining = (ssize_t) count;                                
  off_t offset = iop->offset;                                         
  ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);       
  rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
40002f58:	a4 10 00 09 	mov  %o1, %l2                                  
  ssize_t block_offset = (ssize_t) (offset % block_size);             
40002f5c:	90 10 00 1c 	mov  %i4, %o0                                  
40002f60:	92 10 00 1d 	mov  %i5, %o1                                  
40002f64:	40 00 55 a6 	call  400185fc <__moddi3>                      
40002f68:	96 10 00 1b 	mov  %i3, %o3                                  
  const char *src = buffer;                                           
                                                                      
  while (remaining > 0) {                                             
40002f6c:	ba 96 a0 00 	orcc  %i2, 0, %i5                              
40002f70:	04 80 00 2e 	ble  40003028 <rtems_blkdev_imfs_write+0x100>  <== NEVER TAKEN
40002f74:	a0 10 00 09 	mov  %o1, %l0                                  
    rtems_status_code sc;                                             
    rtems_bdbuf_buffer *bd;                                           
                                                                      
    if (block_offset == 0 && remaining >= block_size) {               
40002f78:	80 a7 40 1b 	cmp  %i5, %i3                                  
40002f7c:	16 80 00 03 	bge  40002f88 <rtems_blkdev_imfs_write+0x60>   
40002f80:	82 10 20 01 	mov  1, %g1                                    
40002f84:	82 10 20 00 	clr  %g1                                       
       sc = rtems_bdbuf_get(dd, block, &bd);                          
40002f88:	90 10 00 11 	mov  %l1, %o0                                  
40002f8c:	92 10 00 12 	mov  %l2, %o1                                  
                                                                      
  while (remaining > 0) {                                             
    rtems_status_code sc;                                             
    rtems_bdbuf_buffer *bd;                                           
                                                                      
    if (block_offset == 0 && remaining >= block_size) {               
40002f90:	80 88 60 ff 	btst  0xff, %g1                                
40002f94:	02 80 00 2e 	be  4000304c <rtems_blkdev_imfs_write+0x124>   
40002f98:	94 07 bf fc 	add  %fp, -4, %o2                              
40002f9c:	80 a4 20 00 	cmp  %l0, 0                                    
40002fa0:	12 80 00 2b 	bne  4000304c <rtems_blkdev_imfs_write+0x124>  
40002fa4:	01 00 00 00 	nop                                            
       sc = rtems_bdbuf_get(dd, block, &bd);                          
40002fa8:	40 00 30 e2 	call  4000f330 <rtems_bdbuf_get>               
40002fac:	01 00 00 00 	nop                                            
    } else {                                                          
       sc = rtems_bdbuf_read(dd, block, &bd);                         
    }                                                                 
                                                                      
    if (sc == RTEMS_SUCCESSFUL) {                                     
40002fb0:	80 a2 20 00 	cmp  %o0, 0                                    
40002fb4:	02 80 00 09 	be  40002fd8 <rtems_blkdev_imfs_write+0xb0>    <== ALWAYS TAKEN
40002fb8:	b8 26 c0 10 	sub  %i3, %l0, %i4                             
                                                                      
  if (remaining >= 0) {                                               
    iop->offset += count;                                             
    rv = (ssize_t) count;                                             
  } else {                                                            
    errno = EIO;                                                      
40002fbc:	40 00 45 31 	call  40014480 <__errno>                       <== NOT EXECUTED
40002fc0:	01 00 00 00 	nop                                            <== NOT EXECUTED
    rv = -1;                                                          
40002fc4:	82 10 3f ff 	mov  -1, %g1	! ffffffff <LEON_REG+0x7fffffff>  <== NOT EXECUTED
                                                                      
  if (remaining >= 0) {                                               
    iop->offset += count;                                             
    rv = (ssize_t) count;                                             
  } else {                                                            
    errno = EIO;                                                      
40002fc8:	84 10 20 05 	mov  5, %g2                                    <== NOT EXECUTED
40002fcc:	c4 22 00 00 	st  %g2, [ %o0 ]                               <== NOT EXECUTED
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
40002fd0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40002fd4:	91 e8 00 01 	restore  %g0, %g1, %o0                         <== NOT EXECUTED
40002fd8:	80 a7 00 1d 	cmp  %i4, %i5                                  
40002fdc:	34 80 00 02 	bg,a   40002fe4 <rtems_blkdev_imfs_write+0xbc> 
40002fe0:	b8 10 00 1d 	mov  %i5, %i4                                  
                                                                      
      if (copy > remaining) {                                         
        copy = remaining;                                             
      }                                                               
                                                                      
      memcpy((char *) bd->buffer + block_offset, src, (size_t) copy); 
40002fe4:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40002fe8:	92 10 00 19 	mov  %i1, %o1                                  
40002fec:	d0 00 60 1c 	ld  [ %g1 + 0x1c ], %o0                        
40002ff0:	94 10 00 1c 	mov  %i4, %o2                                  
40002ff4:	40 00 47 84 	call  40014e04 <memcpy>                        
40002ff8:	90 02 00 10 	add  %o0, %l0, %o0                             
                                                                      
      sc = rtems_bdbuf_release_modified(bd);                          
40002ffc:	40 00 31 ca 	call  4000f724 <rtems_bdbuf_release_modified>  
40003000:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
      if (sc == RTEMS_SUCCESSFUL) {                                   
40003004:	80 a2 20 00 	cmp  %o0, 0                                    
40003008:	12 bf ff ed 	bne  40002fbc <rtems_blkdev_imfs_write+0x94>   <== NEVER TAKEN
4000300c:	01 00 00 00 	nop                                            
        block_offset = 0;                                             
        remaining -= copy;                                            
40003010:	ba 27 40 1c 	sub  %i5, %i4, %i5                             
        src += copy;                                                  
40003014:	b2 06 40 1c 	add  %i1, %i4, %i1                             
        ++block;                                                      
40003018:	a4 04 a0 01 	inc  %l2                                       
  ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);       
  rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
  ssize_t block_offset = (ssize_t) (offset % block_size);             
  const char *src = buffer;                                           
                                                                      
  while (remaining > 0) {                                             
4000301c:	80 a7 60 00 	cmp  %i5, 0                                    
40003020:	14 bf ff d6 	bg  40002f78 <rtems_blkdev_imfs_write+0x50>    
40003024:	a0 10 20 00 	clr  %l0                                       
    } else {                                                          
      remaining = -1;                                                 
    }                                                                 
  }                                                                   
                                                                      
  if (remaining >= 0) {                                               
40003028:	80 a7 60 00 	cmp  %i5, 0                                    
4000302c:	12 bf ff e4 	bne  40002fbc <rtems_blkdev_imfs_write+0x94>   <== NEVER TAKEN
40003030:	82 10 00 1a 	mov  %i2, %g1                                  
    iop->offset += count;                                             
40003034:	c4 1e 20 08 	ldd  [ %i0 + 8 ], %g2                          
40003038:	86 80 c0 1a 	addcc  %g3, %i2, %g3                           
4000303c:	84 40 a0 00 	addx  %g2, 0, %g2                              
40003040:	c4 3e 20 08 	std  %g2, [ %i0 + 8 ]                          
    errno = EIO;                                                      
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
40003044:	81 c7 e0 08 	ret                                            
40003048:	91 e8 00 01 	restore  %g0, %g1, %o0                         
    rtems_bdbuf_buffer *bd;                                           
                                                                      
    if (block_offset == 0 && remaining >= block_size) {               
       sc = rtems_bdbuf_get(dd, block, &bd);                          
    } else {                                                          
       sc = rtems_bdbuf_read(dd, block, &bd);                         
4000304c:	40 00 30 f9 	call  4000f430 <rtems_bdbuf_read>              
40003050:	01 00 00 00 	nop                                            
    }                                                                 
                                                                      
    if (sc == RTEMS_SUCCESSFUL) {                                     
40003054:	10 bf ff d8 	b  40002fb4 <rtems_blkdev_imfs_write+0x8c>     
40003058:	80 a2 20 00 	cmp  %o0, 0                                    
                                                                      

4000f0b4 <rtems_blkdev_ioctl>: #include <rtems/blkdev.h> #include <rtems/bdbuf.h> int rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp) {
4000f0b4:	9d e3 bf a0 	save  %sp, -96, %sp                            
    rtems_status_code  sc;                                            
    int                rc = 0;                                        
                                                                      
    switch (req)                                                      
4000f0b8:	05 10 01 10 	sethi  %hi(0x40044000), %g2                    
4000f0bc:	82 10 a2 03 	or  %g2, 0x203, %g1	! 40044203 <__end+0x28403> 
4000f0c0:	80 a6 40 01 	cmp  %i1, %g1                                  
4000f0c4:	22 80 00 55 	be,a   4000f218 <rtems_blkdev_ioctl+0x164>     
4000f0c8:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
4000f0cc:	08 80 00 1c 	bleu  4000f13c <rtems_blkdev_ioctl+0x88>       
4000f0d0:	03 08 00 10 	sethi  %hi(0x20004000), %g1                    
4000f0d4:	82 10 a2 09 	or  %g2, 0x209, %g1                            
4000f0d8:	80 a6 40 01 	cmp  %i1, %g1                                  
4000f0dc:	22 80 00 3c 	be,a   4000f1cc <rtems_blkdev_ioctl+0x118>     
4000f0e0:	f0 26 80 00 	st  %i0, [ %i2 ]                               
4000f0e4:	28 80 00 27 	bleu,a   4000f180 <rtems_blkdev_ioctl+0xcc>    
4000f0e8:	84 10 a2 05 	or  %g2, 0x205, %g2                            
4000f0ec:	84 10 a2 0b 	or  %g2, 0x20b, %g2                            
4000f0f0:	80 a6 40 02 	cmp  %i1, %g2                                  
4000f0f4:	02 80 00 3f 	be  4000f1f0 <rtems_blkdev_ioctl+0x13c>        
4000f0f8:	03 20 01 10 	sethi  %hi(0x80044000), %g1                    
4000f0fc:	82 10 62 04 	or  %g1, 0x204, %g1	! 80044204 <LEON_REG+0x44204>
4000f100:	80 a6 40 01 	cmp  %i1, %g1                                  
4000f104:	12 80 00 22 	bne  4000f18c <rtems_blkdev_ioctl+0xd8>        <== NEVER TAKEN
4000f108:	90 10 00 18 	mov  %i0, %o0                                  
        case RTEMS_BLKIO_GETBLKSIZE:                                  
            *(uint32_t *) argp = dd->block_size;                      
            break;                                                    
                                                                      
        case RTEMS_BLKIO_SETBLKSIZE:                                  
            sc = rtems_bdbuf_set_block_size(dd, *(uint32_t *) argp, true);
4000f10c:	d2 06 80 00 	ld  [ %i2 ], %o1                               
4000f110:	7f ff ff 8f 	call  4000ef4c <rtems_bdbuf_set_block_size>    
4000f114:	94 10 20 01 	mov  1, %o2                                    
            if (sc != RTEMS_SUCCESSFUL) {                             
4000f118:	80 a2 20 00 	cmp  %o0, 0                                    
4000f11c:	02 80 00 2a 	be  4000f1c4 <rtems_blkdev_ioctl+0x110>        <== ALWAYS TAKEN
4000f120:	01 00 00 00 	nop                                            
            break;                                                    
                                                                      
        case RTEMS_BLKIO_SYNCDEV:                                     
            sc = rtems_bdbuf_syncdev(dd);                             
            if (sc != RTEMS_SUCCESSFUL) {                             
                errno = EIO;                                          
4000f124:	40 00 13 3c 	call  40013e14 <__errno>                       <== NOT EXECUTED
4000f128:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <LEON_REG+0x7fffffff>  <== NOT EXECUTED
4000f12c:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
4000f130:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4000f134:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000f138:	81 e8 00 00 	restore                                        <== NOT EXECUTED
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)   
{                                                                     
    rtems_status_code  sc;                                            
    int                rc = 0;                                        
                                                                      
    switch (req)                                                      
4000f13c:	86 10 62 0a 	or  %g1, 0x20a, %g3                            
4000f140:	80 a6 40 03 	cmp  %i1, %g3                                  
4000f144:	02 80 00 31 	be  4000f208 <rtems_blkdev_ioctl+0x154>        
4000f148:	90 10 00 18 	mov  %i0, %o0                                  
4000f14c:	28 80 00 16 	bleu,a   4000f1a4 <rtems_blkdev_ioctl+0xf0>    
4000f150:	82 10 62 06 	or  %g1, 0x206, %g1                            
4000f154:	82 10 62 0c 	or  %g1, 0x20c, %g1                            
4000f158:	80 a6 40 01 	cmp  %i1, %g1                                  
4000f15c:	02 80 00 21 	be  4000f1e0 <rtems_blkdev_ioctl+0x12c>        
4000f160:	84 10 a2 02 	or  %g2, 0x202, %g2                            
4000f164:	80 a6 40 02 	cmp  %i1, %g2                                  
4000f168:	12 80 00 09 	bne  4000f18c <rtems_blkdev_ioctl+0xd8>        <== NEVER TAKEN
4000f16c:	01 00 00 00 	nop                                            
    {                                                                 
        case RTEMS_BLKIO_GETMEDIABLKSIZE:                             
            *(uint32_t *) argp = dd->media_block_size;                
4000f170:	c2 06 20 20 	ld  [ %i0 + 0x20 ], %g1                        
4000f174:	c2 26 80 00 	st  %g1, [ %i2 ]                               
            break;                                                    
4000f178:	81 c7 e0 08 	ret                                            
4000f17c:	91 e8 20 00 	restore  %g0, 0, %o0                           
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)   
{                                                                     
    rtems_status_code  sc;                                            
    int                rc = 0;                                        
                                                                      
    switch (req)                                                      
4000f180:	80 a6 40 02 	cmp  %i1, %g2                                  
4000f184:	22 80 00 14 	be,a   4000f1d4 <rtems_blkdev_ioctl+0x120>     <== ALWAYS TAKEN
4000f188:	c2 06 20 1c 	ld  [ %i0 + 0x1c ], %g1                        
        case RTEMS_BLKIO_RESETDEVSTATS:                               
            rtems_bdbuf_reset_device_stats(dd);                       
            break;                                                    
                                                                      
        default:                                                      
            errno = EINVAL;                                           
4000f18c:	40 00 13 22 	call  40013e14 <__errno>                       
4000f190:	b0 10 3f ff 	mov  -1, %i0                                   
4000f194:	82 10 20 16 	mov  0x16, %g1                                 
4000f198:	c2 22 00 00 	st  %g1, [ %o0 ]                               
            rc = -1;                                                  
            break;                                                    
    }                                                                 
                                                                      
    return rc;                                                        
}                                                                     
4000f19c:	81 c7 e0 08 	ret                                            
4000f1a0:	81 e8 00 00 	restore                                        
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)   
{                                                                     
    rtems_status_code  sc;                                            
    int                rc = 0;                                        
                                                                      
    switch (req)                                                      
4000f1a4:	80 a6 40 01 	cmp  %i1, %g1                                  
4000f1a8:	12 bf ff f9 	bne  4000f18c <rtems_blkdev_ioctl+0xd8>        
4000f1ac:	01 00 00 00 	nop                                            
        case RTEMS_BLKIO_GETSIZE:                                     
            *(rtems_blkdev_bnum *) argp = dd->size;                   
            break;                                                    
                                                                      
        case RTEMS_BLKIO_SYNCDEV:                                     
            sc = rtems_bdbuf_syncdev(dd);                             
4000f1b0:	7f ff fe d2 	call  4000ecf8 <rtems_bdbuf_syncdev>           
4000f1b4:	90 10 00 18 	mov  %i0, %o0                                  
            if (sc != RTEMS_SUCCESSFUL) {                             
4000f1b8:	80 a2 20 00 	cmp  %o0, 0                                    
4000f1bc:	12 bf ff da 	bne  4000f124 <rtems_blkdev_ioctl+0x70>        <== NEVER TAKEN
4000f1c0:	01 00 00 00 	nop                                            
            }                                                         
            break;                                                    
                                                                      
        case RTEMS_BLKIO_GETDISKDEV:                                  
            *(rtems_disk_device **) argp = dd;                        
            break;                                                    
4000f1c4:	81 c7 e0 08 	ret                                            
4000f1c8:	91 e8 20 00 	restore  %g0, 0, %o0                           
4000f1cc:	81 c7 e0 08 	ret                                            
4000f1d0:	91 e8 20 00 	restore  %g0, 0, %o0                           
                rc = -1;                                              
            }                                                         
            break;                                                    
                                                                      
        case RTEMS_BLKIO_GETSIZE:                                     
            *(rtems_blkdev_bnum *) argp = dd->size;                   
4000f1d4:	c2 26 80 00 	st  %g1, [ %i2 ]                               
            break;                                                    
4000f1d8:	81 c7 e0 08 	ret                                            
4000f1dc:	91 e8 20 00 	restore  %g0, 0, %o0                           
        case RTEMS_BLKIO_GETDEVSTATS:                                 
            rtems_bdbuf_get_device_stats(dd, (rtems_blkdev_stats *) argp);
            break;                                                    
                                                                      
        case RTEMS_BLKIO_RESETDEVSTATS:                               
            rtems_bdbuf_reset_device_stats(dd);                       
4000f1e0:	7f ff ff ac 	call  4000f090 <rtems_bdbuf_reset_device_stats>
4000f1e4:	b0 10 20 00 	clr  %i0                                       
            break;                                                    
4000f1e8:	81 c7 e0 08 	ret                                            
4000f1ec:	81 e8 00 00 	restore                                        
        case RTEMS_BLKIO_PURGEDEV:                                    
            rtems_bdbuf_purge_dev(dd);                                
            break;                                                    
                                                                      
        case RTEMS_BLKIO_GETDEVSTATS:                                 
            rtems_bdbuf_get_device_stats(dd, (rtems_blkdev_stats *) argp);
4000f1f0:	90 10 00 18 	mov  %i0, %o0                                  
4000f1f4:	92 10 00 1a 	mov  %i2, %o1                                  
4000f1f8:	7f ff ff 9d 	call  4000f06c <rtems_bdbuf_get_device_stats>  
4000f1fc:	b0 10 20 00 	clr  %i0                                       
            break;                                                    
4000f200:	81 c7 e0 08 	ret                                            
4000f204:	81 e8 00 00 	restore                                        
        case RTEMS_BLKIO_GETDISKDEV:                                  
            *(rtems_disk_device **) argp = dd;                        
            break;                                                    
                                                                      
        case RTEMS_BLKIO_PURGEDEV:                                    
            rtems_bdbuf_purge_dev(dd);                                
4000f208:	7f ff fe d3 	call  4000ed54 <rtems_bdbuf_purge_dev>         
4000f20c:	b0 10 20 00 	clr  %i0                                       
            break;                                                    
4000f210:	81 c7 e0 08 	ret                                            
4000f214:	81 e8 00 00 	restore                                        
        case RTEMS_BLKIO_GETMEDIABLKSIZE:                             
            *(uint32_t *) argp = dd->media_block_size;                
            break;                                                    
                                                                      
        case RTEMS_BLKIO_GETBLKSIZE:                                  
            *(uint32_t *) argp = dd->block_size;                      
4000f218:	c2 26 80 00 	st  %g1, [ %i2 ]                               
            break;                                                    
4000f21c:	81 c7 e0 08 	ret                                            
4000f220:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

40024d74 <rtems_blkstats>: #include <fcntl.h> #include <unistd.h> #include <errno.h> void rtems_blkstats(FILE *output, const char *device, bool reset) {
40024d74:	9d e3 bf 38 	save  %sp, -200, %sp                           <== NOT EXECUTED
  int fd = open(device, O_RDONLY);                                    
40024d78:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
40024d7c:	7f ff 7a 74 	call  4000374c <open>                          <== NOT EXECUTED
40024d80:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
                                                                      
  if (fd >= 0) {                                                      
40024d84:	ba 92 20 00 	orcc  %o0, 0, %i5                              <== NOT EXECUTED
40024d88:	06 80 00 33 	bl  40024e54 <rtems_blkstats+0xe0>             <== NOT EXECUTED
40024d8c:	01 00 00 00 	nop                                            <== NOT EXECUTED
    struct stat st;                                                   
    int rv;                                                           
                                                                      
    rv = fstat(fd, &st);                                              
40024d90:	40 00 07 90 	call  40026bd0 <fstat>                         <== NOT EXECUTED
40024d94:	92 07 bf b8 	add  %fp, -72, %o1                             <== NOT EXECUTED
    if (rv == 0) {                                                    
40024d98:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40024d9c:	12 80 00 39 	bne  40024e80 <rtems_blkstats+0x10c>           <== NOT EXECUTED
40024da0:	c4 07 bf c4 	ld  [ %fp + -60 ], %g2                         <== NOT EXECUTED
      if (S_ISBLK(st.st_mode)) {                                      
40024da4:	03 00 00 3c 	sethi  %hi(0xf000), %g1                        <== NOT EXECUTED
40024da8:	84 08 80 01 	and  %g2, %g1, %g2                             <== NOT EXECUTED
40024dac:	03 00 00 18 	sethi  %hi(0x6000), %g1                        <== NOT EXECUTED
40024db0:	80 a0 80 01 	cmp  %g2, %g1                                  <== NOT EXECUTED
40024db4:	02 80 00 19 	be  40024e18 <rtems_blkstats+0xa4>             <== NOT EXECUTED
40024db8:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
          } else {                                                    
            fprintf(output, "error: get stats: %s\n", strerror(errno));
          }                                                           
        }                                                             
      } else {                                                        
        fprintf(output, "error: not a block device\n");               
40024dbc:	11 10 01 7a 	sethi  %hi(0x4005e800), %o0                    <== NOT EXECUTED
40024dc0:	90 12 20 70 	or  %o0, 0x70, %o0	! 4005e870 <RTEMS_BDPART_MBR_MASTER_TYPE+0x40><== NOT EXECUTED
40024dc4:	94 10 20 1a 	mov  0x1a, %o2                                 <== NOT EXECUTED
40024dc8:	40 00 61 67 	call  4003d364 <fwrite>                        <== NOT EXECUTED
40024dcc:	96 10 00 18 	mov  %i0, %o3                                  <== NOT EXECUTED
      }                                                               
    } else {                                                          
      fprintf(output, "error: get file stats: %s\n", strerror(errno));
    }                                                                 
                                                                      
    rv = close(fd);                                                   
40024dd0:	40 00 06 5f 	call  4002674c <close>                         <== NOT EXECUTED
40024dd4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
    if (rv != 0) {                                                    
40024dd8:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40024ddc:	12 80 00 04 	bne  40024dec <rtems_blkstats+0x78>            <== NOT EXECUTED
40024de0:	01 00 00 00 	nop                                            <== NOT EXECUTED
40024de4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40024de8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
      fprintf(output, "error: close device: %s\n", strerror(errno));  
40024dec:	40 00 59 df 	call  4003b568 <__errno>                       <== NOT EXECUTED
40024df0:	01 00 00 00 	nop                                            <== NOT EXECUTED
40024df4:	40 00 75 84 	call  40042404 <strerror>                      <== NOT EXECUTED
40024df8:	d0 02 00 00 	ld  [ %o0 ], %o0                               <== NOT EXECUTED
40024dfc:	13 10 01 7a 	sethi  %hi(0x4005e800), %o1                    <== NOT EXECUTED
40024e00:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40024e04:	92 12 60 b0 	or  %o1, 0xb0, %o1                             <== NOT EXECUTED
40024e08:	40 00 5c 9b 	call  4003c074 <fprintf>                       <== NOT EXECUTED
40024e0c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40024e10:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40024e14:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    int rv;                                                           
                                                                      
    rv = fstat(fd, &st);                                              
    if (rv == 0) {                                                    
      if (S_ISBLK(st.st_mode)) {                                      
        if (reset) {                                                  
40024e18:	80 a6 a0 00 	cmp  %i2, 0                                    <== NOT EXECUTED
40024e1c:	12 80 00 23 	bne  40024ea8 <rtems_blkstats+0x134>           <== NOT EXECUTED
40024e20:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
static inline int rtems_disk_fd_get_device_stats(                     
  int fd,                                                             
  rtems_blkdev_stats *stats                                           
)                                                                     
{                                                                     
  return ioctl(fd, RTEMS_BLKIO_GETDEVSTATS, stats);                   
40024e24:	94 07 bf 98 	add  %fp, -104, %o2                            <== NOT EXECUTED
40024e28:	13 10 01 10 	sethi  %hi(0x40044000), %o1                    <== NOT EXECUTED
40024e2c:	40 00 0a 4d 	call  40027760 <ioctl>                         <== NOT EXECUTED
40024e30:	92 12 62 0b 	or  %o1, 0x20b, %o1	! 4004420b <_svfprintf_r+0x283><== NOT EXECUTED
          }                                                           
        } else {                                                      
          rtems_blkdev_stats stats;                                   
                                                                      
          rv = rtems_disk_fd_get_device_stats(fd, &stats);            
          if (rv == 0) {                                              
40024e34:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40024e38:	12 80 00 2c 	bne  40024ee8 <rtems_blkstats+0x174>           <== NOT EXECUTED
40024e3c:	13 10 00 f0 	sethi  %hi(0x4003c000), %o1                    <== NOT EXECUTED
            rtems_blkdev_print_stats(                                 
40024e40:	90 07 bf 98 	add  %fp, -104, %o0                            <== NOT EXECUTED
40024e44:	94 10 00 18 	mov  %i0, %o2                                  <== NOT EXECUTED
40024e48:	40 00 00 32 	call  40024f10 <rtems_blkdev_print_stats>      <== NOT EXECUTED
40024e4c:	92 12 60 74 	or  %o1, 0x74, %o1                             <== NOT EXECUTED
40024e50:	30 bf ff e0 	b,a   40024dd0 <rtems_blkstats+0x5c>           <== NOT EXECUTED
    rv = close(fd);                                                   
    if (rv != 0) {                                                    
      fprintf(output, "error: close device: %s\n", strerror(errno));  
    }                                                                 
  } else {                                                            
    fprintf(output, "error: open device: %s\n", strerror(errno));     
40024e54:	40 00 59 c5 	call  4003b568 <__errno>                       <== NOT EXECUTED
40024e58:	01 00 00 00 	nop                                            <== NOT EXECUTED
40024e5c:	40 00 75 6a 	call  40042404 <strerror>                      <== NOT EXECUTED
40024e60:	d0 02 00 00 	ld  [ %o0 ], %o0                               <== NOT EXECUTED
40024e64:	13 10 01 7a 	sethi  %hi(0x4005e800), %o1                    <== NOT EXECUTED
40024e68:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40024e6c:	92 12 60 d0 	or  %o1, 0xd0, %o1                             <== NOT EXECUTED
40024e70:	40 00 5c 81 	call  4003c074 <fprintf>                       <== NOT EXECUTED
40024e74:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40024e78:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40024e7c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
        }                                                             
      } else {                                                        
        fprintf(output, "error: not a block device\n");               
      }                                                               
    } else {                                                          
      fprintf(output, "error: get file stats: %s\n", strerror(errno));
40024e80:	40 00 59 ba 	call  4003b568 <__errno>                       <== NOT EXECUTED
40024e84:	01 00 00 00 	nop                                            <== NOT EXECUTED
40024e88:	40 00 75 5f 	call  40042404 <strerror>                      <== NOT EXECUTED
40024e8c:	d0 02 00 00 	ld  [ %o0 ], %o0                               <== NOT EXECUTED
40024e90:	13 10 01 7a 	sethi  %hi(0x4005e800), %o1                    <== NOT EXECUTED
40024e94:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40024e98:	92 12 60 90 	or  %o1, 0x90, %o1                             <== NOT EXECUTED
40024e9c:	40 00 5c 76 	call  4003c074 <fprintf>                       <== NOT EXECUTED
40024ea0:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40024ea4:	30 bf ff cb 	b,a   40024dd0 <rtems_blkstats+0x5c>           <== NOT EXECUTED
}                                                                     
                                                                      
static inline int rtems_disk_fd_reset_device_stats(int fd)            
{                                                                     
  return ioctl(fd, RTEMS_BLKIO_RESETDEVSTATS);                        
40024ea8:	13 08 00 10 	sethi  %hi(0x20004000), %o1                    <== NOT EXECUTED
40024eac:	40 00 0a 2d 	call  40027760 <ioctl>                         <== NOT EXECUTED
40024eb0:	92 12 62 0c 	or  %o1, 0x20c, %o1	! 2000420c <RAM_SIZE+0x1fc0420c><== NOT EXECUTED
    rv = fstat(fd, &st);                                              
    if (rv == 0) {                                                    
      if (S_ISBLK(st.st_mode)) {                                      
        if (reset) {                                                  
          rv = rtems_disk_fd_reset_device_stats(fd);                  
          if (rv != 0) {                                              
40024eb4:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40024eb8:	02 bf ff c6 	be  40024dd0 <rtems_blkstats+0x5c>             <== NOT EXECUTED
40024ebc:	01 00 00 00 	nop                                            <== NOT EXECUTED
            fprintf(output, "error: reset stats: %s\n", strerror(errno));
40024ec0:	40 00 59 aa 	call  4003b568 <__errno>                       <== NOT EXECUTED
40024ec4:	01 00 00 00 	nop                                            <== NOT EXECUTED
40024ec8:	40 00 75 4f 	call  40042404 <strerror>                      <== NOT EXECUTED
40024ecc:	d0 02 00 00 	ld  [ %o0 ], %o0                               <== NOT EXECUTED
40024ed0:	13 10 01 7a 	sethi  %hi(0x4005e800), %o1                    <== NOT EXECUTED
40024ed4:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40024ed8:	92 12 60 40 	or  %o1, 0x40, %o1                             <== NOT EXECUTED
40024edc:	40 00 5c 66 	call  4003c074 <fprintf>                       <== NOT EXECUTED
40024ee0:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40024ee4:	30 bf ff bb 	b,a   40024dd0 <rtems_blkstats+0x5c>           <== NOT EXECUTED
              &stats,                                                 
              (rtems_printk_plugin_t) fprintf,                        
              output                                                  
            );                                                        
          } else {                                                    
            fprintf(output, "error: get stats: %s\n", strerror(errno));
40024ee8:	40 00 59 a0 	call  4003b568 <__errno>                       <== NOT EXECUTED
40024eec:	01 00 00 00 	nop                                            <== NOT EXECUTED
40024ef0:	40 00 75 45 	call  40042404 <strerror>                      <== NOT EXECUTED
40024ef4:	d0 02 00 00 	ld  [ %o0 ], %o0                               <== NOT EXECUTED
40024ef8:	13 10 01 7a 	sethi  %hi(0x4005e800), %o1                    <== NOT EXECUTED
40024efc:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40024f00:	92 12 60 58 	or  %o1, 0x58, %o1                             <== NOT EXECUTED
40024f04:	40 00 5c 5c 	call  4003c074 <fprintf>                       <== NOT EXECUTED
40024f08:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40024f0c:	30 bf ff b1 	b,a   40024dd0 <rtems_blkstats+0x5c>           <== NOT EXECUTED
                                                                      

40002830 <rtems_bsp_cmdline_get_param>: const char *rtems_bsp_cmdline_get_param( const char *name, char *value, size_t length ) {
40002830:	9d e3 bf a0 	save  %sp, -96, %sp                            
  const char *p;                                                      
                                                                      
  if ( !name )                                                        
40002834:	80 a6 20 00 	cmp  %i0, 0                                    
40002838:	02 80 00 36 	be  40002910 <rtems_bsp_cmdline_get_param+0xe0>
4000283c:	80 a6 60 00 	cmp  %i1, 0                                    
    return NULL;                                                      
                                                                      
  if ( !value )                                                       
40002840:	02 80 00 34 	be  40002910 <rtems_bsp_cmdline_get_param+0xe0>
40002844:	80 a6 a0 00 	cmp  %i2, 0                                    
    return NULL;                                                      
                                                                      
  if ( !length )                                                      
40002848:	22 80 00 33 	be,a   40002914 <rtems_bsp_cmdline_get_param+0xe4>
4000284c:	b2 10 20 00 	clr  %i1                                       
    return NULL;                                                      
                                                                      
  value[0] = '\0';                                                    
40002850:	c0 2e 40 00 	clrb  [ %i1 ]                                  
                                                                      
  p = rtems_bsp_cmdline_get_param_raw( name );                        
40002854:	40 00 00 32 	call  4000291c <rtems_bsp_cmdline_get_param_raw>
40002858:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
  if ( !p )                                                           
4000285c:	80 a2 20 00 	cmp  %o0, 0                                    
40002860:	22 80 00 2d 	be,a   40002914 <rtems_bsp_cmdline_get_param+0xe4>
40002864:	b2 10 20 00 	clr  %i1                                       
  int         i;                                                      
  int         quotes;                                                 
  const char *p = start;                                              
                                                                      
  quotes=0;                                                           
  for (i=0 ; *p && i<length-1; ) {                                    
40002868:	c6 0a 00 00 	ldub  [ %o0 ], %g3                             
4000286c:	85 28 e0 18 	sll  %g3, 0x18, %g2                            
40002870:	80 a0 a0 00 	cmp  %g2, 0                                    
40002874:	02 80 00 25 	be  40002908 <rtems_bsp_cmdline_get_param+0xd8><== NEVER TAKEN
40002878:	80 a6 a0 01 	cmp  %i2, 1                                    
4000287c:	02 80 00 23 	be  40002908 <rtems_bsp_cmdline_get_param+0xd8><== NEVER TAKEN
40002880:	b4 06 bf ff 	add  %i2, -1, %i2                              
    value[i] = '\0';                                                  
  }                                                                   
                                                                      
}                                                                     
                                                                      
const char *rtems_bsp_cmdline_get_param(                              
40002884:	82 10 20 00 	clr  %g1                                       
  int         i;                                                      
  int         quotes;                                                 
  const char *p = start;                                              
                                                                      
  quotes=0;                                                           
  for (i=0 ; *p && i<length-1; ) {                                    
40002888:	88 10 20 00 	clr  %g4                                       
    value[i] = '\0';                                                  
  }                                                                   
                                                                      
}                                                                     
                                                                      
const char *rtems_bsp_cmdline_get_param(                              
4000288c:	10 80 00 12 	b  400028d4 <rtems_bsp_cmdline_get_param+0xa4> 
40002890:	ba 10 20 00 	clr  %i5                                       
                                                                      
  quotes=0;                                                           
  for (i=0 ; *p && i<length-1; ) {                                    
    if ( *p == '\"' ) {                                               
      quotes++;                                                       
    } else if ( ((quotes % 2) == 0) && *p == ' ' )                    
40002894:	32 80 00 06 	bne,a   400028ac <rtems_bsp_cmdline_get_param+0x7c>
40002898:	c6 2e 40 04 	stb  %g3, [ %i1 + %g4 ]                        
4000289c:	80 a0 a0 20 	cmp  %g2, 0x20                                 
400028a0:	02 80 00 1a 	be  40002908 <rtems_bsp_cmdline_get_param+0xd8>
400028a4:	01 00 00 00 	nop                                            
      break;                                                          
    value[i++] = *p++;                                                
400028a8:	c6 2e 40 04 	stb  %g3, [ %i1 + %g4 ]                        
400028ac:	82 00 60 01 	inc  %g1                                       
    value[i] = '\0';                                                  
400028b0:	c0 2e 40 01 	clrb  [ %i1 + %g1 ]                            
  int         i;                                                      
  int         quotes;                                                 
  const char *p = start;                                              
                                                                      
  quotes=0;                                                           
  for (i=0 ; *p && i<length-1; ) {                                    
400028b4:	c6 0a 00 01 	ldub  [ %o0 + %g1 ], %g3                       
400028b8:	85 28 e0 18 	sll  %g3, 0x18, %g2                            
400028bc:	80 a0 a0 00 	cmp  %g2, 0                                    
400028c0:	02 80 00 12 	be  40002908 <rtems_bsp_cmdline_get_param+0xd8>
400028c4:	88 10 00 01 	mov  %g1, %g4                                  
400028c8:	80 a0 40 1a 	cmp  %g1, %i2                                  
400028cc:	02 80 00 0f 	be  40002908 <rtems_bsp_cmdline_get_param+0xd8>
400028d0:	01 00 00 00 	nop                                            
    if ( *p == '\"' ) {                                               
400028d4:	85 38 a0 18 	sra  %g2, 0x18, %g2                            
400028d8:	80 a0 a0 22 	cmp  %g2, 0x22                                 
400028dc:	12 bf ff ee 	bne  40002894 <rtems_bsp_cmdline_get_param+0x64>
400028e0:	80 8f 60 01 	btst  1, %i5                                   
      quotes++;                                                       
    } else if ( ((quotes % 2) == 0) && *p == ' ' )                    
      break;                                                          
    value[i++] = *p++;                                                
400028e4:	c6 2e 40 04 	stb  %g3, [ %i1 + %g4 ]                        
400028e8:	82 00 60 01 	inc  %g1                                       
    value[i] = '\0';                                                  
400028ec:	c0 2e 40 01 	clrb  [ %i1 + %g1 ]                            
  int         i;                                                      
  int         quotes;                                                 
  const char *p = start;                                              
                                                                      
  quotes=0;                                                           
  for (i=0 ; *p && i<length-1; ) {                                    
400028f0:	c6 0a 00 01 	ldub  [ %o0 + %g1 ], %g3                       
    if ( *p == '\"' ) {                                               
      quotes++;                                                       
400028f4:	ba 07 60 01 	inc  %i5                                       
  int         i;                                                      
  int         quotes;                                                 
  const char *p = start;                                              
                                                                      
  quotes=0;                                                           
  for (i=0 ; *p && i<length-1; ) {                                    
400028f8:	85 28 e0 18 	sll  %g3, 0x18, %g2                            
400028fc:	80 a0 a0 00 	cmp  %g2, 0                                    
40002900:	12 bf ff f2 	bne  400028c8 <rtems_bsp_cmdline_get_param+0x98><== ALWAYS TAKEN
40002904:	88 10 00 01 	mov  %g1, %g4                                  
    return NULL;                                                      
                                                                      
  copy_string( p, value, length );                                    
                                                                      
  return value;                                                       
}                                                                     
40002908:	81 c7 e0 08 	ret                                            
4000290c:	91 e8 00 19 	restore  %g0, %i1, %o0                         
)                                                                     
{                                                                     
  const char *p;                                                      
                                                                      
  if ( !name )                                                        
    return NULL;                                                      
40002910:	b2 10 20 00 	clr  %i1                                       
    return NULL;                                                      
                                                                      
  copy_string( p, value, length );                                    
                                                                      
  return value;                                                       
}                                                                     
40002914:	81 c7 e0 08 	ret                                            
40002918:	91 e8 00 19 	restore  %g0, %i1, %o0                         
                                                                      

40007d10 <rtems_chain_get_with_wait>: rtems_chain_control *chain, rtems_event_set events, rtems_interval timeout, rtems_chain_node **node_ptr ) {
40007d10:	9d e3 bf 98 	save  %sp, -104, %sp                           
 */                                                                   
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(               
  rtems_chain_control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Get( the_chain );                                     
40007d14:	40 00 01 a1 	call  40008398 <_Chain_Get>                    
40007d18:	90 10 00 18 	mov  %i0, %o0                                  
  while (                                                             
    sc == RTEMS_SUCCESSFUL                                            
      && (node = rtems_chain_get( chain )) == NULL                    
  ) {                                                                 
    rtems_event_set out;                                              
    sc = rtems_event_receive(                                         
40007d1c:	92 10 20 00 	clr  %o1                                       
40007d20:	ba 10 00 08 	mov  %o0, %i5                                  
40007d24:	94 10 00 1a 	mov  %i2, %o2                                  
40007d28:	90 10 00 19 	mov  %i1, %o0                                  
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_chain_node *node = NULL;                                      
                                                                      
  while (                                                             
    sc == RTEMS_SUCCESSFUL                                            
      && (node = rtems_chain_get( chain )) == NULL                    
40007d2c:	80 a7 60 00 	cmp  %i5, 0                                    
40007d30:	12 80 00 0a 	bne  40007d58 <rtems_chain_get_with_wait+0x48> 
40007d34:	96 07 bf fc 	add  %fp, -4, %o3                              
  ) {                                                                 
    rtems_event_set out;                                              
    sc = rtems_event_receive(                                         
40007d38:	7f ff fc df 	call  400070b4 <rtems_event_receive>           
40007d3c:	01 00 00 00 	nop                                            
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_chain_node *node = NULL;                                      
                                                                      
  while (                                                             
40007d40:	80 a2 20 00 	cmp  %o0, 0                                    
40007d44:	02 bf ff f4 	be  40007d14 <rtems_chain_get_with_wait+0x4>   <== NEVER TAKEN
40007d48:	01 00 00 00 	nop                                            
      timeout,                                                        
      &out                                                            
    );                                                                
  }                                                                   
                                                                      
  *node_ptr = node;                                                   
40007d4c:	fa 26 c0 00 	st  %i5, [ %i3 ]                               
                                                                      
  return sc;                                                          
}                                                                     
40007d50:	81 c7 e0 08 	ret                                            
40007d54:	91 e8 00 08 	restore  %g0, %o0, %o0                         
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_chain_node *node = NULL;                                      
                                                                      
  while (                                                             
    sc == RTEMS_SUCCESSFUL                                            
      && (node = rtems_chain_get( chain )) == NULL                    
40007d58:	90 10 20 00 	clr  %o0                                       
      timeout,                                                        
      &out                                                            
    );                                                                
  }                                                                   
                                                                      
  *node_ptr = node;                                                   
40007d5c:	fa 26 c0 00 	st  %i5, [ %i3 ]                               
                                                                      
  return sc;                                                          
}                                                                     
40007d60:	81 c7 e0 08 	ret                                            
40007d64:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

40003304 <rtems_cpu_usage_report_with_plugin>: */ void rtems_cpu_usage_report_with_plugin( void *context, rtems_printk_plugin_t print ) {
40003304:	9d e3 bf 70 	save  %sp, -144, %sp                           
    uint32_t seconds, nanoseconds;                                    
  #else                                                               
    uint32_t           total_units = 0;                               
  #endif                                                              
                                                                      
  if ( !print )                                                       
40003308:	80 a6 60 00 	cmp  %i1, 0                                    
4000330c:	02 80 00 85 	be  40003520 <rtems_cpu_usage_report_with_plugin+0x21c><== NEVER TAKEN
40003310:	03 10 00 88 	sethi  %hi(0x40022000), %g1                    
                                                                      
static inline void _Timestamp64_implementation_Set_to_zero(           
  Timestamp64_Control *_time                                          
)                                                                     
{                                                                     
  *_time = 0;                                                         
40003314:	c0 27 bf e0 	clr  [ %fp + -32 ]                             
40003318:	c0 27 bf e4 	clr  [ %fp + -28 ]                             
        }                                                             
      }                                                               
    }                                                                 
  #endif                                                              
                                                                      
  (*print)(                                                           
4000331c:	90 10 00 18 	mov  %i0, %o0                                  
   *  the number of "ticks" we gave credit for to give the user a rough
   *  guideline as to what each number means proportionally.          
   */                                                                 
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    _Timestamp_Set_to_zero( &total );                                 
    uptime_at_last_reset = CPU_usage_Uptime_at_last_reset;            
40003320:	f8 18 60 a0 	ldd  [ %g1 + 0xa0 ], %i4                       
        }                                                             
      }                                                               
    }                                                                 
  #endif                                                              
                                                                      
  (*print)(                                                           
40003324:	13 10 00 7b 	sethi  %hi(0x4001ec00), %o1                    
40003328:	2b 10 00 86 	sethi  %hi(0x40021800), %l5                    
4000332c:	92 12 61 b0 	or  %o1, 0x1b0, %o1                            
40003330:	aa 15 62 58 	or  %l5, 0x258, %l5                            
        if ( !the_thread )                                            
          continue;                                                   
                                                                      
        rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
                                                                      
        (*print)(                                                     
40003334:	25 10 00 7b 	sethi  %hi(0x4001ec00), %l2                    
 */                                                                   
static inline void _TOD_Get_uptime(                                   
  Timestamp_Control *time                                             
)                                                                     
{                                                                     
  _TOD_Get_with_nanoseconds( time, &_TOD.uptime );                    
40003338:	29 10 00 86 	sethi  %hi(0x40021800), %l4                    
        }                                                             
      }                                                               
    }                                                                 
  #endif                                                              
                                                                      
  (*print)(                                                           
4000333c:	9f c6 40 00 	call  %i1                                      
40003340:	27 10 00 7b 	sethi  %hi(0x4001ec00), %l3                    
#endif                                                                
                                                                      
/*                                                                    
 *  rtems_cpu_usage_report                                            
 */                                                                   
void rtems_cpu_usage_report_with_plugin(                              
40003344:	ac 05 60 0c 	add  %l5, 0xc, %l6                             
        if ( !the_thread )                                            
          continue;                                                   
                                                                      
        rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
                                                                      
        (*print)(                                                     
40003348:	a4 14 a3 28 	or  %l2, 0x328, %l2                            
4000334c:	a8 15 22 40 	or  %l4, 0x240, %l4                            
           */                                                         
                                                                      
          seconds = _Timestamp_Get_seconds( &ran );                   
          nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /          
            TOD_NANOSECONDS_PER_MICROSECOND;                          
          (*print)( context,                                          
40003350:	a6 14 e3 40 	or  %l3, 0x340, %l3                            
    #if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)             
      if ( !_Objects_Information_table[ api_index ] )                 
        continue;                                                     
    #endif                                                            
                                                                      
    information = _Objects_Information_table[ api_index ][ 1 ];       
40003354:	c2 05 40 00 	ld  [ %l5 ], %g1                               
40003358:	e2 00 60 04 	ld  [ %g1 + 4 ], %l1                           
    if ( information ) {                                              
4000335c:	80 a4 60 00 	cmp  %l1, 0                                    
40003360:	22 80 00 56 	be,a   400034b8 <rtems_cpu_usage_report_with_plugin+0x1b4><== NEVER TAKEN
40003364:	aa 05 60 04 	add  %l5, 4, %l5                               <== NOT EXECUTED
      for ( i=1 ; i <= information->maximum ; i++ ) {                 
40003368:	c2 14 60 10 	lduh  [ %l1 + 0x10 ], %g1                      
4000336c:	86 90 60 00 	orcc  %g1, 0, %g3                              
40003370:	02 80 00 51 	be  400034b4 <rtems_cpu_usage_report_with_plugin+0x1b0>
40003374:	a0 10 20 01 	mov  1, %l0                                    
        the_thread = (Thread_Control *)information->local_table[ i ]; 
40003378:	10 80 00 2d 	b  4000342c <rtems_cpu_usage_report_with_plugin+0x128>
4000337c:	c4 04 60 1c 	ld  [ %l1 + 0x1c ], %g2                        
40003380:	90 07 bf d8 	add  %fp, -40, %o0                             
40003384:	40 00 19 ca 	call  40009aac <_TOD_Get_with_nanoseconds>     
40003388:	92 10 00 14 	mov  %l4, %o1                                  
4000338c:	c4 1f bf d8 	ldd  [ %fp + -40 ], %g2                        
  const Timestamp64_Control *_start,                                  
  const Timestamp64_Control *_end,                                    
  Timestamp64_Control       *_result                                  
)                                                                     
{                                                                     
  *_result = *_end - *_start;                                         
40003390:	86 a0 c0 1d 	subcc  %g3, %i5, %g3                           
40003394:	84 60 80 1c 	subx  %g2, %i4, %g2                            
            _Timestamp_Add_to( &ran, &used );                         
          } else {                                                    
            _TOD_Get_uptime( &uptime );                               
          }                                                           
          _Timestamp_Subtract( &uptime_at_last_reset, &uptime, &total );
          _Timestamp_Divide( &ran, &total, &ival, &fval );            
40003398:	90 07 bf e8 	add  %fp, -24, %o0                             
4000339c:	c4 3f bf e0 	std  %g2, [ %fp + -32 ]                        
400033a0:	92 07 bf e0 	add  %fp, -32, %o1                             
400033a4:	94 07 bf d0 	add  %fp, -48, %o2                             
400033a8:	40 00 23 a2 	call  4000c230 <_Timestamp64_Divide>           
400033ac:	96 07 bf d4 	add  %fp, -44, %o3                             
                                                                      
          /*                                                          
           * Print the information                                    
           */                                                         
                                                                      
          seconds = _Timestamp_Get_seconds( &ran );                   
400033b0:	f4 1f bf e8 	ldd  [ %fp + -24 ], %i2                        
                                                                      
static inline uint32_t _Timestamp64_implementation_Get_seconds(       
  const Timestamp64_Control *_time                                    
)                                                                     
{                                                                     
  return (uint32_t) (*_time / 1000000000L);                           
400033b4:	94 10 20 00 	clr  %o2                                       
400033b8:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
400033bc:	90 10 00 1a 	mov  %i2, %o0                                  
400033c0:	96 12 e2 00 	or  %o3, 0x200, %o3                            
400033c4:	40 00 5e ef 	call  4001af80 <__divdi3>                      
400033c8:	92 10 00 1b 	mov  %i3, %o1                                  
                                                                      
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(   
  const Timestamp64_Control *_time                                    
)                                                                     
{                                                                     
  return (uint32_t) (*_time % 1000000000L);                           
400033cc:	94 10 20 00 	clr  %o2                                       
                                                                      
static inline uint32_t _Timestamp64_implementation_Get_seconds(       
  const Timestamp64_Control *_time                                    
)                                                                     
{                                                                     
  return (uint32_t) (*_time / 1000000000L);                           
400033d0:	ae 10 00 09 	mov  %o1, %l7                                  
                                                                      
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(   
  const Timestamp64_Control *_time                                    
)                                                                     
{                                                                     
  return (uint32_t) (*_time % 1000000000L);                           
400033d4:	90 10 00 1a 	mov  %i2, %o0                                  
400033d8:	92 10 00 1b 	mov  %i3, %o1                                  
400033dc:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
400033e0:	40 00 5f d3 	call  4001b32c <__moddi3>                      
400033e4:	96 12 e2 00 	or  %o3, 0x200, %o3	! 3b9aca00 <RAM_SIZE+0x3b5aca00>
          nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /          
400033e8:	90 10 00 09 	mov  %o1, %o0                                  
400033ec:	40 00 5d 8d 	call  4001aa20 <.udiv>                         
400033f0:	92 10 23 e8 	mov  0x3e8, %o1                                
            TOD_NANOSECONDS_PER_MICROSECOND;                          
          (*print)( context,                                          
400033f4:	d8 1f bf d0 	ldd  [ %fp + -48 ], %o4                        
          /*                                                          
           * Print the information                                    
           */                                                         
                                                                      
          seconds = _Timestamp_Get_seconds( &ran );                   
          nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /          
400033f8:	96 10 00 08 	mov  %o0, %o3                                  
            TOD_NANOSECONDS_PER_MICROSECOND;                          
          (*print)( context,                                          
400033fc:	92 10 00 13 	mov  %l3, %o1                                  
40003400:	90 10 00 18 	mov  %i0, %o0                                  
40003404:	9f c6 40 00 	call  %i1                                      
40003408:	94 10 00 17 	mov  %l7, %o2                                  
4000340c:	c6 14 60 10 	lduh  [ %l1 + 0x10 ], %g3                      
        continue;                                                     
    #endif                                                            
                                                                      
    information = _Objects_Information_table[ api_index ][ 1 ];       
    if ( information ) {                                              
      for ( i=1 ; i <= information->maximum ; i++ ) {                 
40003410:	a0 04 20 01 	inc  %l0                                       
40003414:	83 28 e0 10 	sll  %g3, 0x10, %g1                            
40003418:	83 30 60 10 	srl  %g1, 0x10, %g1                            
4000341c:	80 a0 40 10 	cmp  %g1, %l0                                  
40003420:	2a 80 00 26 	bcs,a   400034b8 <rtems_cpu_usage_report_with_plugin+0x1b4>
40003424:	aa 05 60 04 	add  %l5, 4, %l5                               
        the_thread = (Thread_Control *)information->local_table[ i ]; 
40003428:	c4 04 60 1c 	ld  [ %l1 + 0x1c ], %g2                        
4000342c:	83 2c 20 02 	sll  %l0, 2, %g1                               
40003430:	f6 00 80 01 	ld  [ %g2 + %g1 ], %i3                         
                                                                      
        if ( !the_thread )                                            
          continue;                                                   
                                                                      
        rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
40003434:	94 07 bf f0 	add  %fp, -16, %o2                             
    information = _Objects_Information_table[ api_index ][ 1 ];       
    if ( information ) {                                              
      for ( i=1 ; i <= information->maximum ; i++ ) {                 
        the_thread = (Thread_Control *)information->local_table[ i ]; 
                                                                      
        if ( !the_thread )                                            
40003438:	80 a6 e0 00 	cmp  %i3, 0                                    
4000343c:	02 bf ff f5 	be  40003410 <rtems_cpu_usage_report_with_plugin+0x10c><== NEVER TAKEN
40003440:	92 10 20 0d 	mov  0xd, %o1                                  
          continue;                                                   
                                                                      
        rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
40003444:	40 00 14 2d 	call  400084f8 <rtems_object_get_name>         
40003448:	d0 06 e0 08 	ld  [ %i3 + 8 ], %o0                           
                                                                      
        (*print)(                                                     
4000344c:	d4 06 e0 08 	ld  [ %i3 + 8 ], %o2                           
40003450:	90 10 00 18 	mov  %i0, %o0                                  
40003454:	92 10 00 12 	mov  %l2, %o1                                  
40003458:	9f c6 40 00 	call  %i1                                      
4000345c:	96 07 bf f0 	add  %fp, -16, %o3                             
    Thread_Control    *the_thread,                                    
    Timestamp_Control *time_of_context_switch                         
  )                                                                   
  {                                                                   
    #ifndef RTEMS_SMP                                                 
      if ( _Thread_Executing->Object.id == the_thread->Object.id ) {  
40003460:	03 10 00 88 	sethi  %hi(0x40022000), %g1                    
40003464:	82 10 60 40 	or  %g1, 0x40, %g1	! 40022040 <_Per_CPU_Information>
40003468:	c8 00 60 10 	ld  [ %g1 + 0x10 ], %g4                        
                                                                      
          /*                                                          
           * If this is the currently executing thread, account for time
           * since the last context switch.                           
           */                                                         
          ran = the_thread->cpu_time_used;                            
4000346c:	c4 1e e0 80 	ldd  [ %i3 + 0x80 ], %g2                       
    Thread_Control    *the_thread,                                    
    Timestamp_Control *time_of_context_switch                         
  )                                                                   
  {                                                                   
    #ifndef RTEMS_SMP                                                 
      if ( _Thread_Executing->Object.id == the_thread->Object.id ) {  
40003470:	f4 01 20 08 	ld  [ %g4 + 8 ], %i2                           
40003474:	c8 06 e0 08 	ld  [ %i3 + 8 ], %g4                           
40003478:	80 a6 80 04 	cmp  %i2, %g4                                  
4000347c:	12 bf ff c1 	bne  40003380 <rtems_cpu_usage_report_with_plugin+0x7c>
40003480:	c4 3f bf e8 	std  %g2, [ %fp + -24 ]                        
        *time_of_context_switch = _Thread_Time_of_last_context_switch;
40003484:	f4 18 60 20 	ldd  [ %g1 + 0x20 ], %i2                       
40003488:	92 10 00 14 	mov  %l4, %o1                                  
4000348c:	40 00 19 88 	call  40009aac <_TOD_Get_with_nanoseconds>     
40003490:	90 07 bf d8 	add  %fp, -40, %o0                             
           */                                                         
          ran = the_thread->cpu_time_used;                            
          if ( is_executing_on_a_core( the_thread, &last ) ) {        
            Timestamp_Control used;                                   
            _TOD_Get_uptime( &uptime );                               
            _Timestamp_Subtract( &last, &uptime, &used );             
40003494:	c4 1f bf d8 	ldd  [ %fp + -40 ], %g2                        
  const Timestamp64_Control *_start,                                  
  const Timestamp64_Control *_end,                                    
  Timestamp64_Control       *_result                                  
)                                                                     
{                                                                     
  *_result = *_end - *_start;                                         
40003498:	96 a0 c0 1b 	subcc  %g3, %i3, %o3                           
4000349c:	94 60 80 1a 	subx  %g2, %i2, %o2                            
static inline void _Timestamp64_implementation_Add_to(                
  Timestamp64_Control       *_time,                                   
  const Timestamp64_Control *_add                                     
)                                                                     
{                                                                     
  *_time += *_add;                                                    
400034a0:	f4 1f bf e8 	ldd  [ %fp + -24 ], %i2                        
400034a4:	9a 86 c0 0b 	addcc  %i3, %o3, %o5                           
400034a8:	98 46 80 0a 	addx  %i2, %o2, %o4                            
400034ac:	10 bf ff b9 	b  40003390 <rtems_cpu_usage_report_with_plugin+0x8c>
400034b0:	d8 3f bf e8 	std  %o4, [ %fp + -24 ]                        
400034b4:	aa 05 60 04 	add  %l5, 4, %l5                               
       " ID         | NAME                                   | TICKS         | PERCENT\n"
     #endif                                                           
     "------------+----------------------------------------+---------------+---------\n"
  );                                                                  
                                                                      
  for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
400034b8:	80 a5 40 16 	cmp  %l5, %l6                                  
400034bc:	32 bf ff a7 	bne,a   40003358 <rtems_cpu_usage_report_with_plugin+0x54>
400034c0:	c2 05 40 00 	ld  [ %l5 ], %g1                               
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    seconds = _Timestamp_Get_seconds( &total );                       
400034c4:	f8 1f bf e0 	ldd  [ %fp + -32 ], %i4                        
                                                                      
static inline uint32_t _Timestamp64_implementation_Get_seconds(       
  const Timestamp64_Control *_time                                    
)                                                                     
{                                                                     
  return (uint32_t) (*_time / 1000000000L);                           
400034c8:	94 10 20 00 	clr  %o2                                       
400034cc:	90 10 00 1c 	mov  %i4, %o0                                  
400034d0:	92 10 00 1d 	mov  %i5, %o1                                  
400034d4:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
400034d8:	40 00 5e aa 	call  4001af80 <__divdi3>                      
400034dc:	96 12 e2 00 	or  %o3, 0x200, %o3	! 3b9aca00 <RAM_SIZE+0x3b5aca00>
                                                                      
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(   
  const Timestamp64_Control *_time                                    
)                                                                     
{                                                                     
  return (uint32_t) (*_time % 1000000000L);                           
400034e0:	94 10 20 00 	clr  %o2                                       
                                                                      
static inline uint32_t _Timestamp64_implementation_Get_seconds(       
  const Timestamp64_Control *_time                                    
)                                                                     
{                                                                     
  return (uint32_t) (*_time / 1000000000L);                           
400034e4:	b6 10 00 09 	mov  %o1, %i3                                  
                                                                      
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(   
  const Timestamp64_Control *_time                                    
)                                                                     
{                                                                     
  return (uint32_t) (*_time % 1000000000L);                           
400034e8:	90 10 00 1c 	mov  %i4, %o0                                  
400034ec:	92 10 00 1d 	mov  %i5, %o1                                  
400034f0:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
400034f4:	40 00 5f 8e 	call  4001b32c <__moddi3>                      
400034f8:	96 12 e2 00 	or  %o3, 0x200, %o3	! 3b9aca00 <RAM_SIZE+0x3b5aca00>
    nanoseconds = _Timestamp_Get_nanoseconds( &total ) /              
400034fc:	90 10 00 09 	mov  %o1, %o0                                  
40003500:	40 00 5d 48 	call  4001aa20 <.udiv>                         
40003504:	92 10 23 e8 	mov  0x3e8, %o1                                
      TOD_NANOSECONDS_PER_MICROSECOND;                                
    (*print)(                                                         
40003508:	94 10 00 1b 	mov  %i3, %o2                                  
    }                                                                 
  }                                                                   
                                                                      
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    seconds = _Timestamp_Get_seconds( &total );                       
    nanoseconds = _Timestamp_Get_nanoseconds( &total ) /              
4000350c:	96 10 00 08 	mov  %o0, %o3                                  
      TOD_NANOSECONDS_PER_MICROSECOND;                                
    (*print)(                                                         
40003510:	13 10 00 7b 	sethi  %hi(0x4001ec00), %o1                    
40003514:	90 10 00 18 	mov  %i0, %o0                                  
40003518:	9f c6 40 00 	call  %i1                                      
4000351c:	92 12 63 58 	or  %o1, 0x358, %o1                            
40003520:	81 c7 e0 08 	ret                                            
40003524:	81 e8 00 00 	restore                                        
                                                                      

4000f654 <rtems_deviceio_errno>: [RTEMS_IO_ERROR] = EIO, [RTEMS_PROXY_BLOCKING] = EIO }; int rtems_deviceio_errno(rtems_status_code sc) {
4000f654:	9d e3 bf a0 	save  %sp, -96, %sp                            
4000f658:	82 10 00 18 	mov  %i0, %g1                                  
  if (sc == RTEMS_SUCCESSFUL) {                                       
4000f65c:	80 a0 60 00 	cmp  %g1, 0                                    
4000f660:	02 80 00 0c 	be  4000f690 <rtems_deviceio_errno+0x3c>       
4000f664:	b0 10 20 00 	clr  %i0                                       
    return 0;                                                         
  } else {                                                            
    int eno = EINVAL;                                                 
                                                                      
    if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {                   
4000f668:	80 a0 60 1c 	cmp  %g1, 0x1c                                 
4000f66c:	18 80 00 06 	bgu  4000f684 <rtems_deviceio_errno+0x30>      <== NEVER TAKEN
4000f670:	ba 10 20 16 	mov  0x16, %i5                                 
      eno = status_code_to_errno [sc];                                
4000f674:	83 28 60 02 	sll  %g1, 2, %g1                               
4000f678:	05 10 00 75 	sethi  %hi(0x4001d400), %g2                    
4000f67c:	84 10 a1 b4 	or  %g2, 0x1b4, %g2	! 4001d5b4 <status_code_to_errno>
4000f680:	fa 00 80 01 	ld  [ %g2 + %g1 ], %i5                         
    }                                                                 
                                                                      
    errno = eno;                                                      
4000f684:	40 00 00 2f 	call  4000f740 <__errno>                       
4000f688:	b0 10 3f ff 	mov  -1, %i0                                   
4000f68c:	fa 22 00 00 	st  %i5, [ %o0 ]                               
                                                                      
    return -1;                                                        
  }                                                                   
}                                                                     
4000f690:	81 c7 e0 08 	ret                                            
4000f694:	81 e8 00 00 	restore                                        
                                                                      

40003314 <rtems_disk_create_log>: dev_t phys, rtems_blkdev_bnum block_begin, rtems_blkdev_bnum block_count, const char *name ) {
40003314:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_disk_device *phys_dd = NULL;                                  
  rtems_disk_device *dd = NULL;                                       
40003318:	c0 27 bf f8 	clr  [ %fp + -8 ]                              
  char *alloc_name = NULL;                                            
                                                                      
  sc = disk_lock();                                                   
4000331c:	7f ff fe f5 	call  40002ef0 <disk_lock>                     
40003320:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
  if (sc != RTEMS_SUCCESSFUL) {                                       
40003324:	a0 92 20 00 	orcc  %o0, 0, %l0                              
40003328:	02 80 00 04 	be  40003338 <rtems_disk_create_log+0x24>      <== ALWAYS TAKEN
4000332c:	92 10 00 1b 	mov  %i3, %o1                                  
  }                                                                   
                                                                      
  disk_unlock();                                                      
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
40003330:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40003334:	91 e8 00 10 	restore  %g0, %l0, %o0                         <== NOT EXECUTED
  sc = disk_lock();                                                   
  if (sc != RTEMS_SUCCESSFUL) {                                       
    return sc;                                                        
  }                                                                   
                                                                      
  phys_dd = get_disk_entry(phys, true);                               
40003338:	90 10 00 1a 	mov  %i2, %o0                                  
4000333c:	7f ff fe b0 	call  40002dfc <get_disk_entry>                
40003340:	94 10 20 01 	mov  1, %o2                                    
  if (phys_dd == NULL) {                                              
40003344:	b6 92 20 00 	orcc  %o0, 0, %i3                              
40003348:	02 80 00 25 	be  400033dc <rtems_disk_create_log+0xc8>      
4000334c:	d4 07 a0 5c 	ld  [ %fp + 0x5c ], %o2                        
    disk_unlock();                                                    
                                                                      
    return RTEMS_INVALID_ID;                                          
  }                                                                   
                                                                      
  sc = create_disk(dev, name, &dd, &alloc_name);                      
40003350:	90 10 00 18 	mov  %i0, %o0                                  
40003354:	92 10 00 19 	mov  %i1, %o1                                  
40003358:	96 07 bf f8 	add  %fp, -8, %o3                              
4000335c:	7f ff ff 03 	call  40002f68 <create_disk>                   
40003360:	98 07 bf fc 	add  %fp, -4, %o4                              
  if (sc != RTEMS_SUCCESSFUL) {                                       
40003364:	a0 92 20 00 	orcc  %o0, 0, %l0                              
40003368:	12 80 00 19 	bne  400033cc <rtems_disk_create_log+0xb8>     
4000336c:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0                          
    disk_unlock();                                                    
                                                                      
    return sc;                                                        
  }                                                                   
                                                                      
  sc = rtems_disk_init_log(                                           
40003370:	92 10 00 1b 	mov  %i3, %o1                                  
40003374:	94 10 00 1c 	mov  %i4, %o2                                  
40003378:	40 00 30 bc 	call  4000f668 <rtems_disk_init_log>           
4000337c:	96 10 00 1d 	mov  %i5, %o3                                  
    phys_dd,                                                          
    block_begin,                                                      
    block_count                                                       
  );                                                                  
                                                                      
  dd->dev = dev;                                                      
40003380:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
  dd->name = alloc_name;                                              
                                                                      
  ++phys_dd->uses;                                                    
40003384:	c4 06 e0 14 	ld  [ %i3 + 0x14 ], %g2                        
    block_begin,                                                      
    block_count                                                       
  );                                                                  
                                                                      
  dd->dev = dev;                                                      
  dd->name = alloc_name;                                              
40003388:	c6 07 bf fc 	ld  [ %fp + -4 ], %g3                          
                                                                      
  ++phys_dd->uses;                                                    
4000338c:	84 00 a0 01 	inc  %g2                                       
    phys_dd,                                                          
    block_begin,                                                      
    block_count                                                       
  );                                                                  
                                                                      
  dd->dev = dev;                                                      
40003390:	f0 38 40 00 	std  %i0, [ %g1 ]                              
  dd->name = alloc_name;                                              
40003394:	c6 20 60 10 	st  %g3, [ %g1 + 0x10 ]                        
                                                                      
  ++phys_dd->uses;                                                    
40003398:	c4 26 e0 14 	st  %g2, [ %i3 + 0x14 ]                        
                                                                      
  if (sc != RTEMS_SUCCESSFUL) {                                       
4000339c:	80 a2 20 00 	cmp  %o0, 0                                    
400033a0:	02 80 00 0b 	be  400033cc <rtems_disk_create_log+0xb8>      
400033a4:	a0 10 00 08 	mov  %o0, %l0                                  
    dd->ioctl = null_handler;                                         
400033a8:	05 10 00 0b 	sethi  %hi(0x40002c00), %g2                    
400033ac:	84 10 a2 90 	or  %g2, 0x290, %g2	! 40002e90 <null_handler>  
    rtems_disk_delete(dev);                                           
400033b0:	92 10 00 19 	mov  %i1, %o1                                  
  dd->name = alloc_name;                                              
                                                                      
  ++phys_dd->uses;                                                    
                                                                      
  if (sc != RTEMS_SUCCESSFUL) {                                       
    dd->ioctl = null_handler;                                         
400033b4:	c4 20 60 38 	st  %g2, [ %g1 + 0x38 ]                        
    rtems_disk_delete(dev);                                           
400033b8:	7f ff ff 5c 	call  40003128 <rtems_disk_delete>             
400033bc:	90 10 00 18 	mov  %i0, %o0                                  
    disk_unlock();                                                    
400033c0:	7f ff fe db 	call  40002f2c <disk_unlock>                   
400033c4:	b0 10 00 10 	mov  %l0, %i0                                  
400033c8:	30 80 00 03 	b,a   400033d4 <rtems_disk_create_log+0xc0>    
                                                                      
    return sc;                                                        
  }                                                                   
                                                                      
  disk_unlock();                                                      
400033cc:	7f ff fe d8 	call  40002f2c <disk_unlock>                   
400033d0:	b0 10 00 10 	mov  %l0, %i0                                  
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
400033d4:	81 c7 e0 08 	ret                                            
400033d8:	81 e8 00 00 	restore                                        
    return sc;                                                        
  }                                                                   
                                                                      
  phys_dd = get_disk_entry(phys, true);                               
  if (phys_dd == NULL) {                                              
    disk_unlock();                                                    
400033dc:	7f ff fe d4 	call  40002f2c <disk_unlock>                   
400033e0:	a0 10 20 04 	mov  4, %l0                                    
  }                                                                   
                                                                      
  disk_unlock();                                                      
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
400033e4:	81 c7 e0 08 	ret                                            
400033e8:	91 e8 00 10 	restore  %g0, %l0, %o0                         
                                                                      

400033ec <rtems_disk_create_phys>: rtems_blkdev_bnum block_count, rtems_block_device_ioctl handler, void *driver_data, const char *name ) {
400033ec:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_disk_device *dd = NULL;                                       
400033f0:	c0 27 bf f8 	clr  [ %fp + -8 ]                              
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  char *alloc_name = NULL;                                            
400033f4:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
                                                                      
  if (handler == NULL) {                                              
400033f8:	80 a7 20 00 	cmp  %i4, 0                                    
400033fc:	02 80 00 07 	be  40003418 <rtems_disk_create_phys+0x2c>     
40003400:	a0 10 20 09 	mov  9, %l0                                    
    return RTEMS_INVALID_ADDRESS;                                     
  }                                                                   
                                                                      
  sc = disk_lock();                                                   
40003404:	7f ff fe bb 	call  40002ef0 <disk_lock>                     
40003408:	01 00 00 00 	nop                                            
  if (sc != RTEMS_SUCCESSFUL) {                                       
4000340c:	a0 92 20 00 	orcc  %o0, 0, %l0                              
40003410:	02 80 00 04 	be  40003420 <rtems_disk_create_phys+0x34>     <== ALWAYS TAKEN
40003414:	d4 07 a0 5c 	ld  [ %fp + 0x5c ], %o2                        
  }                                                                   
                                                                      
  disk_unlock();                                                      
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
40003418:	81 c7 e0 08 	ret                                            
4000341c:	91 e8 00 10 	restore  %g0, %l0, %o0                         
  sc = disk_lock();                                                   
  if (sc != RTEMS_SUCCESSFUL) {                                       
    return sc;                                                        
  }                                                                   
                                                                      
  sc = create_disk(dev, name, &dd, &alloc_name);                      
40003420:	90 10 00 18 	mov  %i0, %o0                                  
40003424:	92 10 00 19 	mov  %i1, %o1                                  
40003428:	96 07 bf f8 	add  %fp, -8, %o3                              
4000342c:	7f ff fe cf 	call  40002f68 <create_disk>                   
40003430:	98 07 bf fc 	add  %fp, -4, %o4                              
  if (sc != RTEMS_SUCCESSFUL) {                                       
40003434:	a0 92 20 00 	orcc  %o0, 0, %l0                              
40003438:	12 80 00 0e 	bne  40003470 <rtems_disk_create_phys+0x84>    
4000343c:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0                          
    disk_unlock();                                                    
                                                                      
    return sc;                                                        
  }                                                                   
                                                                      
  sc = rtems_disk_init_phys(                                          
40003440:	92 10 00 1a 	mov  %i2, %o1                                  
40003444:	94 10 00 1b 	mov  %i3, %o2                                  
40003448:	96 10 00 1c 	mov  %i4, %o3                                  
4000344c:	40 00 30 6d 	call  4000f600 <rtems_disk_init_phys>          
40003450:	98 10 00 1d 	mov  %i5, %o4                                  
    block_count,                                                      
    handler,                                                          
    driver_data                                                       
  );                                                                  
                                                                      
  dd->dev = dev;                                                      
40003454:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
  dd->name = alloc_name;                                              
40003458:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
    block_count,                                                      
    handler,                                                          
    driver_data                                                       
  );                                                                  
                                                                      
  dd->dev = dev;                                                      
4000345c:	f0 38 40 00 	std  %i0, [ %g1 ]                              
  dd->name = alloc_name;                                              
40003460:	c4 20 60 10 	st  %g2, [ %g1 + 0x10 ]                        
                                                                      
  if (sc != RTEMS_SUCCESSFUL) {                                       
40003464:	80 a2 20 00 	cmp  %o0, 0                                    
40003468:	12 80 00 06 	bne  40003480 <rtems_disk_create_phys+0x94>    
4000346c:	a0 10 00 08 	mov  %o0, %l0                                  
    disk_unlock();                                                    
                                                                      
    return sc;                                                        
  }                                                                   
                                                                      
  disk_unlock();                                                      
40003470:	7f ff fe af 	call  40002f2c <disk_unlock>                   
40003474:	b0 10 00 10 	mov  %l0, %i0                                  
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
40003478:	81 c7 e0 08 	ret                                            
4000347c:	81 e8 00 00 	restore                                        
                                                                      
  dd->dev = dev;                                                      
  dd->name = alloc_name;                                              
                                                                      
  if (sc != RTEMS_SUCCESSFUL) {                                       
    dd->ioctl = null_handler;                                         
40003480:	05 10 00 0b 	sethi  %hi(0x40002c00), %g2                    
40003484:	84 10 a2 90 	or  %g2, 0x290, %g2	! 40002e90 <null_handler>  
    rtems_disk_delete(dev);                                           
40003488:	92 10 00 19 	mov  %i1, %o1                                  
                                                                      
  dd->dev = dev;                                                      
  dd->name = alloc_name;                                              
                                                                      
  if (sc != RTEMS_SUCCESSFUL) {                                       
    dd->ioctl = null_handler;                                         
4000348c:	c4 20 60 38 	st  %g2, [ %g1 + 0x38 ]                        
    rtems_disk_delete(dev);                                           
40003490:	7f ff ff 26 	call  40003128 <rtems_disk_delete>             
40003494:	90 10 00 18 	mov  %i0, %o0                                  
    disk_unlock();                                                    
40003498:	7f ff fe a5 	call  40002f2c <disk_unlock>                   
4000349c:	b0 10 00 10 	mov  %l0, %i0                                  
400034a0:	30 bf ff f6 	b,a   40003478 <rtems_disk_create_phys+0x8c>   
                                                                      

40003128 <rtems_disk_delete>: } } rtems_status_code rtems_disk_delete(dev_t dev) {
40003128:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_disk_device *dd = NULL;                                       
                                                                      
  sc = disk_lock();                                                   
4000312c:	7f ff ff 71 	call  40002ef0 <disk_lock>                     
40003130:	01 00 00 00 	nop                                            
  if (sc != RTEMS_SUCCESSFUL) {                                       
40003134:	a0 92 20 00 	orcc  %o0, 0, %l0                              
40003138:	02 80 00 04 	be  40003148 <rtems_disk_delete+0x20>          <== ALWAYS TAKEN
4000313c:	90 10 00 18 	mov  %i0, %o0                                  
  rtems_disk_cleanup(dd);                                             
                                                                      
  disk_unlock();                                                      
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
40003140:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40003144:	91 e8 00 10 	restore  %g0, %l0, %o0                         <== NOT EXECUTED
  sc = disk_lock();                                                   
  if (sc != RTEMS_SUCCESSFUL) {                                       
    return sc;                                                        
  }                                                                   
                                                                      
  dd = get_disk_entry(dev, true);                                     
40003148:	92 10 00 19 	mov  %i1, %o1                                  
4000314c:	7f ff ff 2c 	call  40002dfc <get_disk_entry>                
40003150:	94 10 20 01 	mov  1, %o2                                    
  if (dd == NULL) {                                                   
40003154:	82 92 20 00 	orcc  %o0, 0, %g1                              
40003158:	02 80 00 5e 	be  400032d0 <rtems_disk_delete+0x1a8>         <== NEVER TAKEN
4000315c:	84 10 20 01 	mov  1, %g2                                    
}                                                                     
                                                                      
static void                                                           
rtems_disk_cleanup(rtems_disk_device *disk_to_remove)                 
{                                                                     
  rtems_disk_device *const physical_disk = disk_to_remove->phys_dev;  
40003160:	e2 00 60 08 	ld  [ %g1 + 8 ], %l1                           
    disk_unlock();                                                    
                                                                      
    return RTEMS_INVALID_ID;                                          
  }                                                                   
                                                                      
  dd->deleted = true;                                                 
40003164:	c4 28 60 40 	stb  %g2, [ %g1 + 0x40 ]                       
{                                                                     
  rtems_disk_device *const physical_disk = disk_to_remove->phys_dev;  
  rtems_device_major_number major = 0;                                
  rtems_device_minor_number minor = 0;                                
                                                                      
  if (physical_disk->deleted) {                                       
40003168:	c4 0c 60 40 	ldub  [ %l1 + 0x40 ], %g2                      
4000316c:	80 a0 a0 00 	cmp  %g2, 0                                    
40003170:	22 80 00 43 	be,a   4000327c <rtems_disk_delete+0x154>      
40003174:	c4 00 60 14 	ld  [ %g1 + 0x14 ], %g2                        
    dev_t dev = physical_disk->dev;                                   
    unsigned deleted_count = 0;                                       
                                                                      
    for (major = 0; major < disktab_size; ++major) {                  
40003178:	2b 10 00 6b 	sethi  %hi(0x4001ac00), %l5                    
4000317c:	c2 05 62 18 	ld  [ %l5 + 0x218 ], %g1	! 4001ae18 <disktab_size>
  rtems_disk_device *const physical_disk = disk_to_remove->phys_dev;  
  rtems_device_major_number major = 0;                                
  rtems_device_minor_number minor = 0;                                
                                                                      
  if (physical_disk->deleted) {                                       
    dev_t dev = physical_disk->dev;                                   
40003180:	f2 04 40 00 	ld  [ %l1 ], %i1                               
40003184:	e4 04 60 04 	ld  [ %l1 + 4 ], %l2                           
    unsigned deleted_count = 0;                                       
                                                                      
    for (major = 0; major < disktab_size; ++major) {                  
40003188:	80 a0 60 00 	cmp  %g1, 0                                    
4000318c:	02 80 00 33 	be  40003258 <rtems_disk_delete+0x130>         <== NEVER TAKEN
40003190:	a8 10 20 00 	clr  %l4                                       
40003194:	2d 10 00 6b 	sethi  %hi(0x4001ac00), %l6                    
40003198:	b0 10 20 00 	clr  %i0                                       
4000319c:	ac 15 a2 1c 	or  %l6, 0x21c, %l6                            
400031a0:	aa 15 62 18 	or  %l5, 0x218, %l5                            
          if (dd->uses == 0) {                                        
            ++deleted_count;                                          
            dtab->minor [minor] = NULL;                               
            free_disk_device(dd);                                     
          } else {                                                    
            dd->deleted = true;                                       
400031a4:	a6 10 20 01 	mov  1, %l3                                    
  if (physical_disk->deleted) {                                       
    dev_t dev = physical_disk->dev;                                   
    unsigned deleted_count = 0;                                       
                                                                      
    for (major = 0; major < disktab_size; ++major) {                  
      rtems_disk_device_table *dtab = disktab + major;                
400031a8:	f6 05 80 00 	ld  [ %l6 ], %i3                               
    }                                                                 
  }                                                                   
}                                                                     
                                                                      
rtems_status_code                                                     
rtems_disk_delete(dev_t dev)                                          
400031ac:	83 2e 20 03 	sll  %i0, 3, %g1                               
  if (physical_disk->deleted) {                                       
    dev_t dev = physical_disk->dev;                                   
    unsigned deleted_count = 0;                                       
                                                                      
    for (major = 0; major < disktab_size; ++major) {                  
      rtems_disk_device_table *dtab = disktab + major;                
400031b0:	b6 06 c0 01 	add  %i3, %g1, %i3                             
                                                                      
      for (minor = 0; minor < dtab->size; ++minor) {                  
400031b4:	f4 06 e0 04 	ld  [ %i3 + 4 ], %i2                           
400031b8:	80 a6 a0 00 	cmp  %i2, 0                                    
400031bc:	22 80 00 23 	be,a   40003248 <rtems_disk_delete+0x120>      
400031c0:	c2 05 40 00 	ld  [ %l5 ], %g1                               
400031c4:	10 80 00 06 	b  400031dc <rtems_disk_delete+0xb4>           
400031c8:	ba 10 20 00 	clr  %i5                                       
400031cc:	ba 07 60 01 	inc  %i5                                       
400031d0:	80 a7 40 1a 	cmp  %i5, %i2                                  
400031d4:	3a 80 00 1d 	bcc,a   40003248 <rtems_disk_delete+0x120>     
400031d8:	c2 05 40 00 	ld  [ %l5 ], %g1                               
        rtems_disk_device *dd = dtab->minor [minor];                  
400031dc:	c6 06 c0 00 	ld  [ %i3 ], %g3                               
    }                                                                 
  }                                                                   
}                                                                     
                                                                      
rtems_status_code                                                     
rtems_disk_delete(dev_t dev)                                          
400031e0:	85 2f 60 02 	sll  %i5, 2, %g2                               
                                                                      
    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];                  
400031e4:	d0 00 c0 02 	ld  [ %g3 + %g2 ], %o0                         
                                                                      
        if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
400031e8:	80 a2 20 00 	cmp  %o0, 0                                    
400031ec:	22 bf ff f9 	be,a   400031d0 <rtems_disk_delete+0xa8>       
400031f0:	ba 07 60 01 	inc  %i5                                       
400031f4:	c8 02 20 08 	ld  [ %o0 + 8 ], %g4                           
400031f8:	f8 01 00 00 	ld  [ %g4 ], %i4                               
400031fc:	80 a7 00 19 	cmp  %i4, %i1                                  
40003200:	32 bf ff f4 	bne,a   400031d0 <rtems_disk_delete+0xa8>      <== NEVER TAKEN
40003204:	ba 07 60 01 	inc  %i5                                       <== NOT EXECUTED
40003208:	c8 01 20 04 	ld  [ %g4 + 4 ], %g4                           
4000320c:	80 a1 00 12 	cmp  %g4, %l2                                  
40003210:	32 bf ff f0 	bne,a   400031d0 <rtems_disk_delete+0xa8>      <== NEVER TAKEN
40003214:	ba 07 60 01 	inc  %i5                                       <== NOT EXECUTED
40003218:	80 a4 40 08 	cmp  %l1, %o0                                  
4000321c:	22 bf ff ed 	be,a   400031d0 <rtems_disk_delete+0xa8>       
40003220:	ba 07 60 01 	inc  %i5                                       
          if (dd->uses == 0) {                                        
40003224:	c8 02 20 14 	ld  [ %o0 + 0x14 ], %g4                        
40003228:	80 a1 20 00 	cmp  %g4, 0                                    
4000322c:	22 80 00 25 	be,a   400032c0 <rtems_disk_delete+0x198>      
40003230:	c0 20 c0 02 	clr  [ %g3 + %g2 ]                             
    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) {                  
40003234:	ba 07 60 01 	inc  %i5                                       
40003238:	80 a7 40 1a 	cmp  %i5, %i2                                  
4000323c:	0a bf ff e8 	bcs  400031dc <rtems_disk_delete+0xb4>         <== ALWAYS TAKEN
40003240:	e6 2a 20 40 	stb  %l3, [ %o0 + 0x40 ]                       
                                                                      
  if (physical_disk->deleted) {                                       
    dev_t dev = physical_disk->dev;                                   
    unsigned deleted_count = 0;                                       
                                                                      
    for (major = 0; major < disktab_size; ++major) {                  
40003244:	c2 05 40 00 	ld  [ %l5 ], %g1                               <== NOT EXECUTED
40003248:	b0 06 20 01 	inc  %i0                                       
4000324c:	80 a6 00 01 	cmp  %i0, %g1                                  
40003250:	2a bf ff d7 	bcs,a   400031ac <rtems_disk_delete+0x84>      
40003254:	f6 05 80 00 	ld  [ %l6 ], %i3                               
          }                                                           
        }                                                             
      }                                                               
    }                                                                 
                                                                      
    physical_disk->uses -= deleted_count;                             
40003258:	c2 04 60 14 	ld  [ %l1 + 0x14 ], %g1                        
4000325c:	a8 20 40 14 	sub  %g1, %l4, %l4                             
    if (physical_disk->uses == 0) {                                   
40003260:	80 a5 20 00 	cmp  %l4, 0                                    
40003264:	02 80 00 1f 	be  400032e0 <rtems_disk_delete+0x1b8>         
40003268:	e8 24 60 14 	st  %l4, [ %l1 + 0x14 ]                        
  }                                                                   
                                                                      
  dd->deleted = true;                                                 
  rtems_disk_cleanup(dd);                                             
                                                                      
  disk_unlock();                                                      
4000326c:	7f ff ff 30 	call  40002f2c <disk_unlock>                   
40003270:	b0 10 00 10 	mov  %l0, %i0                                  
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
40003274:	81 c7 e0 08 	ret                                            
40003278:	81 e8 00 00 	restore                                        
      rtems_filesystem_split_dev_t(physical_disk->dev, major, minor); 
      disktab [major].minor [minor] = NULL;                           
      free_disk_device(physical_disk);                                
    }                                                                 
  } else {                                                            
    if (disk_to_remove->uses == 0) {                                  
4000327c:	80 a0 a0 00 	cmp  %g2, 0                                    
40003280:	12 bf ff fb 	bne  4000326c <rtems_disk_delete+0x144>        <== NEVER TAKEN
40003284:	07 10 00 6b 	sethi  %hi(0x4001ac00), %g3                    
      --physical_disk->uses;                                          
      rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
40003288:	c4 00 40 00 	ld  [ %g1 ], %g2                               
      disktab [major].minor [minor] = NULL;                           
4000328c:	c8 00 e2 1c 	ld  [ %g3 + 0x21c ], %g4                       
      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);
40003290:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
      disktab [major].minor [minor] = NULL;                           
      free_disk_device(physical_disk);                                
    }                                                                 
  } else {                                                            
    if (disk_to_remove->uses == 0) {                                  
      --physical_disk->uses;                                          
40003294:	c6 04 60 14 	ld  [ %l1 + 0x14 ], %g3                        
      rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
      disktab [major].minor [minor] = NULL;                           
40003298:	85 28 a0 03 	sll  %g2, 3, %g2                               
4000329c:	c4 01 00 02 	ld  [ %g4 + %g2 ], %g2                         
      disktab [major].minor [minor] = NULL;                           
      free_disk_device(physical_disk);                                
    }                                                                 
  } else {                                                            
    if (disk_to_remove->uses == 0) {                                  
      --physical_disk->uses;                                          
400032a0:	86 00 ff ff 	add  %g3, -1, %g3                              
      rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
      disktab [major].minor [minor] = NULL;                           
400032a4:	83 28 60 02 	sll  %g1, 2, %g1                               
      disktab [major].minor [minor] = NULL;                           
      free_disk_device(physical_disk);                                
    }                                                                 
  } else {                                                            
    if (disk_to_remove->uses == 0) {                                  
      --physical_disk->uses;                                          
400032a8:	c6 24 60 14 	st  %g3, [ %l1 + 0x14 ]                        
      rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
      disktab [major].minor [minor] = NULL;                           
      free_disk_device(disk_to_remove);                               
400032ac:	7f ff fe fb 	call  40002e98 <free_disk_device>              
400032b0:	c0 20 80 01 	clr  [ %g2 + %g1 ]                             
  }                                                                   
                                                                      
  dd->deleted = true;                                                 
  rtems_disk_cleanup(dd);                                             
                                                                      
  disk_unlock();                                                      
400032b4:	7f ff ff 1e 	call  40002f2c <disk_unlock>                   
400032b8:	b0 10 00 10 	mov  %l0, %i0                                  
400032bc:	30 bf ff ee 	b,a   40003274 <rtems_disk_delete+0x14c>       
                                                                      
        if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
          if (dd->uses == 0) {                                        
            ++deleted_count;                                          
            dtab->minor [minor] = NULL;                               
            free_disk_device(dd);                                     
400032c0:	7f ff fe f6 	call  40002e98 <free_disk_device>              
400032c4:	a8 05 20 01 	inc  %l4                                       
400032c8:	10 bf ff c1 	b  400031cc <rtems_disk_delete+0xa4>           
400032cc:	f4 06 e0 04 	ld  [ %i3 + 4 ], %i2                           
    return sc;                                                        
  }                                                                   
                                                                      
  dd = get_disk_entry(dev, true);                                     
  if (dd == NULL) {                                                   
    disk_unlock();                                                    
400032d0:	7f ff ff 17 	call  40002f2c <disk_unlock>                   <== NOT EXECUTED
400032d4:	a0 10 20 04 	mov  4, %l0                                    <== NOT EXECUTED
  rtems_disk_cleanup(dd);                                             
                                                                      
  disk_unlock();                                                      
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
400032d8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400032dc:	91 e8 00 10 	restore  %g0, %l0, %o0                         <== NOT EXECUTED
      }                                                               
    }                                                                 
                                                                      
    physical_disk->uses -= deleted_count;                             
    if (physical_disk->uses == 0) {                                   
      rtems_filesystem_split_dev_t(physical_disk->dev, major, minor); 
400032e0:	c4 04 40 00 	ld  [ %l1 ], %g2                               
      disktab [major].minor [minor] = NULL;                           
400032e4:	03 10 00 6b 	sethi  %hi(0x4001ac00), %g1                    
400032e8:	c6 00 62 1c 	ld  [ %g1 + 0x21c ], %g3	! 4001ae1c <disktab>  
      }                                                               
    }                                                                 
                                                                      
    physical_disk->uses -= deleted_count;                             
    if (physical_disk->uses == 0) {                                   
      rtems_filesystem_split_dev_t(physical_disk->dev, major, minor); 
400032ec:	c2 04 60 04 	ld  [ %l1 + 4 ], %g1                           
      disktab [major].minor [minor] = NULL;                           
400032f0:	85 28 a0 03 	sll  %g2, 3, %g2                               
400032f4:	c4 00 c0 02 	ld  [ %g3 + %g2 ], %g2                         
400032f8:	83 28 60 02 	sll  %g1, 2, %g1                               
      free_disk_device(physical_disk);                                
400032fc:	90 10 00 11 	mov  %l1, %o0                                  
40003300:	7f ff fe e6 	call  40002e98 <free_disk_device>              
40003304:	c0 20 80 01 	clr  [ %g2 + %g1 ]                             
  }                                                                   
                                                                      
  dd->deleted = true;                                                 
  rtems_disk_cleanup(dd);                                             
                                                                      
  disk_unlock();                                                      
40003308:	7f ff ff 09 	call  40002f2c <disk_unlock>                   
4000330c:	b0 10 00 10 	mov  %l0, %i0                                  
40003310:	30 bf ff d9 	b,a   40003274 <rtems_disk_delete+0x14c>       
                                                                      

40003718 <rtems_disk_io_done>: return RTEMS_SUCCESSFUL; } rtems_status_code rtems_disk_io_done(void) {
40003718:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_device_major_number major = 0;                                
  rtems_device_minor_number minor = 0;                                
                                                                      
  for (major = 0; major < disktab_size; ++major) {                    
4000371c:	21 10 00 6b 	sethi  %hi(0x4001ac00), %l0                    
40003720:	c2 04 22 18 	ld  [ %l0 + 0x218 ], %g1	! 4001ae18 <disktab_size>
40003724:	35 10 00 6b 	sethi  %hi(0x4001ac00), %i2                    
40003728:	b6 10 20 00 	clr  %i3                                       
4000372c:	fa 06 a2 1c 	ld  [ %i2 + 0x21c ], %i5                       
40003730:	80 a0 60 00 	cmp  %g1, 0                                    
40003734:	02 80 00 1d 	be  400037a8 <rtems_disk_io_done+0x90>         <== NEVER TAKEN
40003738:	b2 14 22 18 	or  %l0, 0x218, %i1                            
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
                                                                      
rtems_status_code                                                     
rtems_disk_io_done(void)                                              
4000373c:	83 2e e0 03 	sll  %i3, 3, %g1                               
{                                                                     
  rtems_device_major_number major = 0;                                
  rtems_device_minor_number minor = 0;                                
                                                                      
  for (major = 0; major < disktab_size; ++major) {                    
    rtems_disk_device_table *dtab = disktab + major;                  
40003740:	b8 07 40 01 	add  %i5, %g1, %i4                             
                                                                      
    for (minor = 0; minor < dtab->size; ++minor) {                    
40003744:	c4 07 20 04 	ld  [ %i4 + 4 ], %g2                           
40003748:	80 a0 a0 00 	cmp  %g2, 0                                    
4000374c:	02 80 00 10 	be  4000378c <rtems_disk_io_done+0x74>         
40003750:	c6 07 40 01 	ld  [ %i5 + %g1 ], %g3                         
40003754:	ba 10 20 00 	clr  %i5                                       
      rtems_disk_device *dd = dtab->minor [minor];                    
40003758:	83 2f 60 02 	sll  %i5, 2, %g1                               
4000375c:	c2 00 c0 01 	ld  [ %g3 + %g1 ], %g1                         
                                                                      
      if (dd != NULL) {                                               
40003760:	90 90 60 00 	orcc  %g1, 0, %o0                              
40003764:	02 80 00 06 	be  4000377c <rtems_disk_io_done+0x64>         
40003768:	ba 07 60 01 	inc  %i5                                       
        free_disk_device(dd);                                         
4000376c:	7f ff fd cb 	call  40002e98 <free_disk_device>              
40003770:	01 00 00 00 	nop                                            
40003774:	c4 07 20 04 	ld  [ %i4 + 4 ], %g2                           
40003778:	c6 07 00 00 	ld  [ %i4 ], %g3                               
  rtems_device_minor_number minor = 0;                                
                                                                      
  for (major = 0; major < disktab_size; ++major) {                    
    rtems_disk_device_table *dtab = disktab + major;                  
                                                                      
    for (minor = 0; minor < dtab->size; ++minor) {                    
4000377c:	80 a0 80 1d 	cmp  %g2, %i5                                  
40003780:	18 bf ff f7 	bgu  4000375c <rtems_disk_io_done+0x44>        
40003784:	83 2f 60 02 	sll  %i5, 2, %g1                               
40003788:	fa 06 a2 1c 	ld  [ %i2 + 0x21c ], %i5                       
                                                                      
      if (dd != NULL) {                                               
        free_disk_device(dd);                                         
      }                                                               
    }                                                                 
    free(dtab->minor);                                                
4000378c:	40 00 02 31 	call  40004050 <free>                          
40003790:	90 10 00 03 	mov  %g3, %o0                                  
rtems_disk_io_done(void)                                              
{                                                                     
  rtems_device_major_number major = 0;                                
  rtems_device_minor_number minor = 0;                                
                                                                      
  for (major = 0; major < disktab_size; ++major) {                    
40003794:	c2 06 40 00 	ld  [ %i1 ], %g1                               
40003798:	b6 06 e0 01 	inc  %i3                                       
4000379c:	80 a0 40 1b 	cmp  %g1, %i3                                  
400037a0:	18 bf ff e8 	bgu  40003740 <rtems_disk_io_done+0x28>        
400037a4:	83 2e e0 03 	sll  %i3, 3, %g1                               
        free_disk_device(dd);                                         
      }                                                               
    }                                                                 
    free(dtab->minor);                                                
  }                                                                   
  free(disktab);                                                      
400037a8:	40 00 02 2a 	call  40004050 <free>                          
400037ac:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  rtems_semaphore_delete(diskdevs_mutex);                             
400037b0:	3b 10 00 6b 	sethi  %hi(0x4001ac00), %i5                    
400037b4:	d0 07 62 14 	ld  [ %i5 + 0x214 ], %o0	! 4001ae14 <diskdevs_mutex>
400037b8:	40 00 13 6d 	call  4000856c <rtems_semaphore_delete>        
400037bc:	b0 10 20 00 	clr  %i0                                       
                                                                      
  diskdevs_mutex = RTEMS_ID_NONE;                                     
400037c0:	c0 27 62 14 	clr  [ %i5 + 0x214 ]                           
  disktab = NULL;                                                     
400037c4:	c0 26 a2 1c 	clr  [ %i2 + 0x21c ]                           
  disktab_size = 0;                                                   
400037c8:	c0 24 22 18 	clr  [ %l0 + 0x218 ]                           
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
400037cc:	81 c7 e0 08 	ret                                            
400037d0:	81 e8 00 00 	restore                                        
                                                                      

4000366c <rtems_disk_io_initialize>: } } rtems_status_code rtems_disk_io_initialize(void) {
4000366c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_device_major_number size = DISKTAB_INITIAL_SIZE;              
                                                                      
  if (disktab_size > 0) {                                             
40003670:	3b 10 00 6b 	sethi  %hi(0x4001ac00), %i5                    
40003674:	c2 07 62 18 	ld  [ %i5 + 0x218 ], %g1	! 4001ae18 <disktab_size>
40003678:	80 a0 60 00 	cmp  %g1, 0                                    
4000367c:	12 80 00 19 	bne  400036e0 <rtems_disk_io_initialize+0x74>  
40003680:	b0 10 20 00 	clr  %i0                                       
    return RTEMS_SUCCESSFUL;                                          
  }                                                                   
                                                                      
  disktab = calloc(size, sizeof(rtems_disk_device_table));            
40003684:	90 10 20 08 	mov  8, %o0                                    
40003688:	92 10 20 08 	mov  8, %o1                                    
4000368c:	40 00 02 3a 	call  40003f74 <calloc>                        
40003690:	39 10 00 6b 	sethi  %hi(0x4001ac00), %i4                    
40003694:	d0 27 22 1c 	st  %o0, [ %i4 + 0x21c ]	! 4001ae1c <disktab>  
  if (disktab == NULL) {                                              
40003698:	80 a2 20 00 	cmp  %o0, 0                                    
4000369c:	02 80 00 11 	be  400036e0 <rtems_disk_io_initialize+0x74>   <== NEVER TAKEN
400036a0:	b0 10 20 1a 	mov  0x1a, %i0                                 
    return RTEMS_NO_MEMORY;                                           
  }                                                                   
                                                                      
  diskdevs_protected = false;                                         
400036a4:	03 10 00 6b 	sethi  %hi(0x4001ac00), %g1                    
  sc = rtems_semaphore_create(                                        
400036a8:	11 11 11 11 	sethi  %hi(0x44444400), %o0                    
  disktab = calloc(size, sizeof(rtems_disk_device_table));            
  if (disktab == NULL) {                                              
    return RTEMS_NO_MEMORY;                                           
  }                                                                   
                                                                      
  diskdevs_protected = false;                                         
400036ac:	c0 28 62 10 	clrb  [ %g1 + 0x210 ]                          
  sc = rtems_semaphore_create(                                        
400036b0:	90 12 21 56 	or  %o0, 0x156, %o0                            
400036b4:	92 10 20 01 	mov  1, %o1                                    
400036b8:	94 10 20 10 	mov  0x10, %o2                                 
400036bc:	96 10 20 00 	clr  %o3                                       
400036c0:	37 10 00 6b 	sethi  %hi(0x4001ac00), %i3                    
400036c4:	40 00 13 39 	call  400083a8 <rtems_semaphore_create>        
400036c8:	98 16 e2 14 	or  %i3, 0x214, %o4	! 4001ae14 <diskdevs_mutex>
    RTEMS_FIFO | RTEMS_BINARY_SEMAPHORE | RTEMS_NO_INHERIT_PRIORITY   
      | RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL,                      
    0,                                                                
    &diskdevs_mutex                                                   
  );                                                                  
  if (sc != RTEMS_SUCCESSFUL) {                                       
400036cc:	80 a2 20 00 	cmp  %o0, 0                                    
400036d0:	02 80 00 06 	be  400036e8 <rtems_disk_io_initialize+0x7c>   <== ALWAYS TAKEN
400036d4:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  sc = rtems_bdbuf_init();                                            
  if (sc != RTEMS_SUCCESSFUL) {                                       
    rtems_semaphore_delete(diskdevs_mutex);                           
    free(disktab);                                                    
400036d8:	40 00 02 5e 	call  40004050 <free>                          <== NOT EXECUTED
400036dc:	d0 07 22 1c 	ld  [ %i4 + 0x21c ], %o0                       <== NOT EXECUTED
                                                                      
    return RTEMS_UNSATISFIED;                                         
400036e0:	81 c7 e0 08 	ret                                            
400036e4:	81 e8 00 00 	restore                                        
    free(disktab);                                                    
                                                                      
    return RTEMS_NO_MEMORY;                                           
  }                                                                   
                                                                      
  sc = rtems_bdbuf_init();                                            
400036e8:	40 00 2b 0a 	call  4000e310 <rtems_bdbuf_init>              
400036ec:	01 00 00 00 	nop                                            
  if (sc != RTEMS_SUCCESSFUL) {                                       
400036f0:	80 a2 20 00 	cmp  %o0, 0                                    
400036f4:	12 80 00 05 	bne  40003708 <rtems_disk_io_initialize+0x9c>  <== NEVER TAKEN
400036f8:	82 10 20 08 	mov  8, %g1                                    
    free(disktab);                                                    
                                                                      
    return RTEMS_UNSATISFIED;                                         
  }                                                                   
                                                                      
  disktab_size = size;                                                
400036fc:	c2 27 62 18 	st  %g1, [ %i5 + 0x218 ]                       
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
40003700:	81 c7 e0 08 	ret                                            
40003704:	91 e8 20 00 	restore  %g0, 0, %o0                           
    return RTEMS_NO_MEMORY;                                           
  }                                                                   
                                                                      
  sc = rtems_bdbuf_init();                                            
  if (sc != RTEMS_SUCCESSFUL) {                                       
    rtems_semaphore_delete(diskdevs_mutex);                           
40003708:	d0 06 e2 14 	ld  [ %i3 + 0x214 ], %o0                       <== NOT EXECUTED
4000370c:	40 00 13 98 	call  4000856c <rtems_semaphore_delete>        <== NOT EXECUTED
40003710:	b0 10 20 0d 	mov  0xd, %i0                                  <== NOT EXECUTED
40003714:	30 bf ff f1 	b,a   400036d8 <rtems_disk_io_initialize+0x6c> <== NOT EXECUTED
                                                                      

40003574 <rtems_disk_next>: rtems_disk_device * rtems_disk_next(dev_t dev) {
40003574:	9d e3 bf a0 	save  %sp, -96, %sp                            
  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) {                                            
40003578:	80 a6 3f ff 	cmp  %i0, -1                                   
4000357c:	02 80 00 37 	be  40003658 <rtems_disk_next+0xe4>            
40003580:	80 a6 7f ff 	cmp  %i1, -1                                   
    rtems_filesystem_split_dev_t(dev, major, minor);                  
                                                                      
    /* If minor wraps around */                                       
    if ((minor + 1) < minor) {                                        
40003584:	ba 06 60 01 	add  %i1, 1, %i5                               
40003588:	80 a7 40 19 	cmp  %i5, %i1                                  
4000358c:	0a 80 00 2e 	bcs  40003644 <rtems_disk_next+0xd0>           <== NEVER TAKEN
40003590:	b8 10 00 18 	mov  %i0, %i4                                  
    } else {                                                          
      ++minor;                                                        
    }                                                                 
  }                                                                   
                                                                      
  sc = disk_lock();                                                   
40003594:	7f ff fe 57 	call  40002ef0 <disk_lock>                     
40003598:	01 00 00 00 	nop                                            
  if (sc != RTEMS_SUCCESSFUL) {                                       
4000359c:	80 a2 20 00 	cmp  %o0, 0                                    
400035a0:	12 80 00 27 	bne  4000363c <rtems_disk_next+0xc8>           <== NEVER TAKEN
400035a4:	03 10 00 6b 	sethi  %hi(0x4001ac00), %g1                    
    return NULL;                                                      
  }                                                                   
                                                                      
  if (major >= disktab_size) {                                        
400035a8:	c8 00 62 18 	ld  [ %g1 + 0x218 ], %g4	! 4001ae18 <disktab_size>
400035ac:	80 a7 00 04 	cmp  %i4, %g4                                  
400035b0:	1a 80 00 21 	bcc  40003634 <rtems_disk_next+0xc0>           <== NEVER TAKEN
400035b4:	03 10 00 6b 	sethi  %hi(0x4001ac00), %g1                    
    disk_unlock();                                                    
                                                                      
    return NULL;                                                      
  }                                                                   
                                                                      
  dtab = disktab + major;                                             
400035b8:	c6 00 62 1c 	ld  [ %g1 + 0x21c ], %g3	! 4001ae1c <disktab>  
400035bc:	b7 2f 20 03 	sll  %i4, 3, %i3                               
400035c0:	c2 00 c0 1b 	ld  [ %g3 + %i3 ], %g1                         
400035c4:	b6 00 c0 1b 	add  %g3, %i3, %i3                             
  while (true) {                                                      
    if (dtab->minor == NULL || minor >= dtab->size) {                 
400035c8:	80 a0 60 00 	cmp  %g1, 0                                    
400035cc:	02 80 00 12 	be  40003614 <rtems_disk_next+0xa0>            
400035d0:	b5 2f 60 02 	sll  %i5, 2, %i2                               
400035d4:	c4 06 e0 04 	ld  [ %i3 + 4 ], %g2                           
400035d8:	80 a7 40 02 	cmp  %i5, %g2                                  
400035dc:	3a 80 00 0f 	bcc,a   40003618 <rtems_disk_next+0xa4>        
400035e0:	b8 07 20 01 	inc  %i4                                       
         disk_unlock();                                               
                                                                      
         return NULL;                                                 
       }                                                              
       dtab = disktab + major;                                        
    } else if (dtab->minor [minor] == NULL) {                         
400035e4:	c4 00 40 1a 	ld  [ %g1 + %i2 ], %g2                         
400035e8:	80 a0 a0 00 	cmp  %g2, 0                                    
400035ec:	02 bf ff f7 	be  400035c8 <rtems_disk_next+0x54>            
400035f0:	ba 07 60 01 	inc  %i5                                       
      ++minor;                                                        
    } else {                                                          
      ++dtab->minor [minor]->uses;                                    
400035f4:	c2 00 a0 14 	ld  [ %g2 + 0x14 ], %g1                        
400035f8:	82 00 60 01 	inc  %g1                                       
      disk_unlock();                                                  
400035fc:	7f ff fe 4c 	call  40002f2c <disk_unlock>                   
40003600:	c2 20 a0 14 	st  %g1, [ %g2 + 0x14 ]                        
                                                                      
      return dtab->minor [minor];                                     
40003604:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
40003608:	f0 00 40 1a 	ld  [ %g1 + %i2 ], %i0                         
    }                                                                 
  }                                                                   
}                                                                     
4000360c:	81 c7 e0 08 	ret                                            
40003610:	81 e8 00 00 	restore                                        
                                                                      
  dtab = disktab + major;                                             
  while (true) {                                                      
    if (dtab->minor == NULL || minor >= dtab->size) {                 
       minor = 0;                                                     
       ++major;                                                       
40003614:	b8 07 20 01 	inc  %i4                                       
       if (major >= disktab_size) {                                   
40003618:	80 a1 00 1c 	cmp  %g4, %i4                                  
4000361c:	08 80 00 06 	bleu  40003634 <rtems_disk_next+0xc0>          
40003620:	83 2f 20 03 	sll  %i4, 3, %g1                               
  }                                                                   
                                                                      
  dtab = disktab + major;                                             
  while (true) {                                                      
    if (dtab->minor == NULL || minor >= dtab->size) {                 
       minor = 0;                                                     
40003624:	ba 10 20 00 	clr  %i5                                       
       if (major >= disktab_size) {                                   
         disk_unlock();                                               
                                                                      
         return NULL;                                                 
       }                                                              
       dtab = disktab + major;                                        
40003628:	b6 00 c0 01 	add  %g3, %g1, %i3                             
4000362c:	10 bf ff e7 	b  400035c8 <rtems_disk_next+0x54>             
40003630:	c2 00 c0 01 	ld  [ %g3 + %g1 ], %g1                         
  if (sc != RTEMS_SUCCESSFUL) {                                       
    return NULL;                                                      
  }                                                                   
                                                                      
  if (major >= disktab_size) {                                        
    disk_unlock();                                                    
40003634:	7f ff fe 3e 	call  40002f2c <disk_unlock>                   
40003638:	01 00 00 00 	nop                                            
                                                                      
    return NULL;                                                      
4000363c:	81 c7 e0 08 	ret                                            
40003640:	91 e8 20 00 	restore  %g0, 0, %o0                           
    rtems_filesystem_split_dev_t(dev, major, minor);                  
                                                                      
    /* If minor wraps around */                                       
    if ((minor + 1) < minor) {                                        
      /* If major wraps around */                                     
      if ((major + 1) < major) {                                      
40003644:	b8 06 20 01 	add  %i0, 1, %i4                               <== NOT EXECUTED
40003648:	80 a7 00 18 	cmp  %i4, %i0                                  <== NOT EXECUTED
4000364c:	1a bf ff d2 	bcc  40003594 <rtems_disk_next+0x20>           <== NOT EXECUTED
40003650:	ba 10 20 00 	clr  %i5                                       <== NOT EXECUTED
40003654:	30 bf ff fa 	b,a   4000363c <rtems_disk_next+0xc8>          <== NOT EXECUTED
  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) {                                            
40003658:	32 bf ff cc 	bne,a   40003588 <rtems_disk_next+0x14>        <== NEVER TAKEN
4000365c:	ba 06 60 01 	add  %i1, 1, %i5                               <== NOT EXECUTED
rtems_disk_next(dev_t dev)                                            
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_disk_device_table *dtab = NULL;                               
  rtems_device_major_number major = 0;                                
  rtems_device_minor_number minor = 0;                                
40003660:	ba 10 20 00 	clr  %i5                                       
rtems_disk_device *                                                   
rtems_disk_next(dev_t dev)                                            
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_disk_device_table *dtab = NULL;                               
  rtems_device_major_number major = 0;                                
40003664:	10 bf ff cc 	b  40003594 <rtems_disk_next+0x20>             
40003668:	b8 10 20 00 	clr  %i4                                       
                                                                      

400034a4 <rtems_disk_obtain>: return RTEMS_SUCCESSFUL; } rtems_disk_device * rtems_disk_obtain(dev_t dev) {
400034a4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_disk_device *dd = NULL;                                       
  rtems_interrupt_level level;                                        
                                                                      
  rtems_interrupt_disable(level);                                     
400034a8:	7f ff fc e9 	call  4000284c <sparc_disable_interrupts>      
400034ac:	b8 10 00 18 	mov  %i0, %i4                                  
400034b0:	b6 10 00 08 	mov  %o0, %i3                                  
  if (!diskdevs_protected) {                                          
400034b4:	03 10 00 6b 	sethi  %hi(0x4001ac00), %g1                    
400034b8:	c2 08 62 10 	ldub  [ %g1 + 0x210 ], %g1	! 4001ae10 <diskdevs_protected>
400034bc:	80 a0 60 00 	cmp  %g1, 0                                    
400034c0:	22 80 00 10 	be,a   40003500 <rtems_disk_obtain+0x5c>       <== ALWAYS TAKEN
400034c4:	90 10 00 18 	mov  %i0, %o0                                  
    /* Frequent and quickest case */                                  
    dd = get_disk_entry(dev, false);                                  
    rtems_interrupt_enable(level);                                    
  } else {                                                            
    rtems_interrupt_enable(level);                                    
400034c8:	7f ff fc e5 	call  4000285c <sparc_enable_interrupts>       <== NOT EXECUTED
400034cc:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
                                                                      
    sc = disk_lock();                                                 
400034d0:	7f ff fe 88 	call  40002ef0 <disk_lock>                     <== NOT EXECUTED
400034d4:	01 00 00 00 	nop                                            <== NOT EXECUTED
    if (sc == RTEMS_SUCCESSFUL) {                                     
400034d8:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
400034dc:	12 80 00 07 	bne  400034f8 <rtems_disk_obtain+0x54>         <== NOT EXECUTED
400034e0:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
      dd = get_disk_entry(dev, false);                                
400034e4:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
400034e8:	7f ff fe 45 	call  40002dfc <get_disk_entry>                <== NOT EXECUTED
400034ec:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
      disk_unlock();                                                  
400034f0:	7f ff fe 8f 	call  40002f2c <disk_unlock>                   <== NOT EXECUTED
400034f4:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  return dd;                                                          
}                                                                     
400034f8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400034fc:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  rtems_interrupt_level level;                                        
                                                                      
  rtems_interrupt_disable(level);                                     
  if (!diskdevs_protected) {                                          
    /* Frequent and quickest case */                                  
    dd = get_disk_entry(dev, false);                                  
40003500:	92 10 00 19 	mov  %i1, %o1                                  
40003504:	7f ff fe 3e 	call  40002dfc <get_disk_entry>                
40003508:	94 10 20 00 	clr  %o2                                       
4000350c:	b0 10 00 08 	mov  %o0, %i0                                  
    rtems_interrupt_enable(level);                                    
40003510:	7f ff fc d3 	call  4000285c <sparc_enable_interrupts>       
40003514:	90 10 00 1b 	mov  %i3, %o0                                  
40003518:	81 c7 e0 08 	ret                                            
4000351c:	81 e8 00 00 	restore                                        
                                                                      

400112b0 <rtems_event_system_receive>: rtems_event_set event_in, rtems_option option_set, rtems_interval ticks, rtems_event_set *event_out ) {
400112b0:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_status_code sc;                                               
                                                                      
  if ( event_out != NULL ) {                                          
400112b4:	80 a6 e0 00 	cmp  %i3, 0                                    
400112b8:	02 80 00 0a 	be  400112e0 <rtems_event_system_receive+0x30> <== NEVER TAKEN
400112bc:	82 10 20 09 	mov  9, %g1                                    
    Thread_Control    *executing = _Thread_Executing;                 
400112c0:	03 10 00 6d 	sethi  %hi(0x4001b400), %g1                    
400112c4:	fa 00 63 f0 	ld  [ %g1 + 0x3f0 ], %i5	! 4001b7f0 <_Per_CPU_Information+0x10>
    RTEMS_API_Control *api = executing->API_Extensions[ THREAD_API_RTEMS ];
    Event_Control     *event = &api->System_event;                    
                                                                      
    if ( !_Event_sets_Is_empty( event_in ) ) {                        
400112c8:	80 a6 20 00 	cmp  %i0, 0                                    
400112cc:	12 80 00 07 	bne  400112e8 <rtems_event_system_receive+0x38><== ALWAYS TAKEN
400112d0:	da 07 61 4c 	ld  [ %i5 + 0x14c ], %o5                       
      );                                                              
      _Thread_Enable_dispatch();                                      
                                                                      
      sc = executing->Wait.return_code;                               
    } else {                                                          
      *event_out = event->pending_events;                             
400112d4:	c4 03 60 04 	ld  [ %o5 + 4 ], %g2                           <== NOT EXECUTED
      sc = RTEMS_SUCCESSFUL;                                          
400112d8:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
      );                                                              
      _Thread_Enable_dispatch();                                      
                                                                      
      sc = executing->Wait.return_code;                               
    } else {                                                          
      *event_out = event->pending_events;                             
400112dc:	c4 26 c0 00 	st  %g2, [ %i3 ]                               <== NOT EXECUTED
  } else {                                                            
    sc = RTEMS_INVALID_ADDRESS;                                       
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
400112e0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400112e4:	91 e8 00 01 	restore  %g0, %g1, %o0                         <== NOT EXECUTED
   *                                                                  
   * This rountine increments the thread dispatch level               
   */                                                                 
  RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
  {                                                                   
    uint32_t level = _Thread_Dispatch_disable_level;                  
400112e8:	03 10 00 6c 	sethi  %hi(0x4001b000), %g1                    
400112ec:	c4 00 62 d0 	ld  [ %g1 + 0x2d0 ], %g2	! 4001b2d0 <_Thread_Dispatch_disable_level>
                                                                      
    ++level;                                                          
400112f0:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
400112f4:	c4 20 62 d0 	st  %g2, [ %g1 + 0x2d0 ]                       
    RTEMS_API_Control *api = executing->API_Extensions[ THREAD_API_RTEMS ];
    Event_Control     *event = &api->System_event;                    
                                                                      
    if ( !_Event_sets_Is_empty( event_in ) ) {                        
      _Thread_Disable_dispatch();                                     
      _Event_Seize(                                                   
400112f8:	03 00 01 00 	sethi  %hi(0x40000), %g1                       
400112fc:	90 10 00 18 	mov  %i0, %o0                                  
40011300:	92 10 00 19 	mov  %i1, %o1                                  
40011304:	94 10 00 1a 	mov  %i2, %o2                                  
40011308:	96 10 00 1b 	mov  %i3, %o3                                  
4001130c:	98 10 00 1d 	mov  %i5, %o4                                  
40011310:	9a 03 60 04 	add  %o5, 4, %o5                               
40011314:	c2 23 a0 60 	st  %g1, [ %sp + 0x60 ]                        
40011318:	03 10 00 6e 	sethi  %hi(0x4001b800), %g1                    
4001131c:	82 10 63 e0 	or  %g1, 0x3e0, %g1	! 4001bbe0 <_System_event_Sync_state>
40011320:	7f ff db 4f 	call  4000805c <_Event_Seize>                  
40011324:	c2 23 a0 5c 	st  %g1, [ %sp + 0x5c ]                        
        executing,                                                    
        event,                                                        
        &_System_event_Sync_state,                                    
        STATES_WAITING_FOR_SYSTEM_EVENT                               
      );                                                              
      _Thread_Enable_dispatch();                                      
40011328:	7f ff e7 5e 	call  4000b0a0 <_Thread_Enable_dispatch>       
4001132c:	01 00 00 00 	nop                                            
                                                                      
      sc = executing->Wait.return_code;                               
40011330:	c2 07 60 34 	ld  [ %i5 + 0x34 ], %g1                        
  } else {                                                            
    sc = RTEMS_INVALID_ADDRESS;                                       
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
40011334:	81 c7 e0 08 	ret                                            
40011338:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      

40007574 <rtems_event_system_send>: rtems_status_code rtems_event_system_send( rtems_id id, rtems_event_set event_in ) {
40007574:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_status_code  sc;                                              
  Thread_Control    *thread;                                          
  Objects_Locations  location;                                        
  RTEMS_API_Control *api;                                             
                                                                      
  thread = _Thread_Get( id, &location );                              
40007578:	90 10 00 18 	mov  %i0, %o0                                  
4000757c:	40 00 0a 5f 	call  40009ef8 <_Thread_Get>                   
40007580:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
40007584:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40007588:	80 a0 60 00 	cmp  %g1, 0                                    
4000758c:	12 80 00 0d 	bne  400075c0 <rtems_event_system_send+0x4c>   <== NEVER TAKEN
40007590:	92 10 00 19 	mov  %i1, %o1                                  
    case OBJECTS_LOCAL:                                               
      api = thread->API_Extensions[ THREAD_API_RTEMS ];               
      _Event_Surrender(                                               
40007594:	d4 02 21 4c 	ld  [ %o0 + 0x14c ], %o2                       
40007598:	94 02 a0 04 	add  %o2, 4, %o2                               
4000759c:	19 00 01 00 	sethi  %hi(0x40000), %o4                       
400075a0:	17 10 00 7d 	sethi  %hi(0x4001f400), %o3                    
400075a4:	96 12 e3 d0 	or  %o3, 0x3d0, %o3	! 4001f7d0 <_System_event_Sync_state>
400075a8:	7f ff fe 54 	call  40006ef8 <_Event_Surrender>              
400075ac:	b0 10 20 00 	clr  %i0                                       
        event_in,                                                     
        &api->System_event,                                           
        &_System_event_Sync_state,                                    
        STATES_WAITING_FOR_SYSTEM_EVENT                               
      );                                                              
      _Thread_Enable_dispatch();                                      
400075b0:	40 00 0a 46 	call  40009ec8 <_Thread_Enable_dispatch>       
400075b4:	01 00 00 00 	nop                                            
      sc = RTEMS_SUCCESSFUL;                                          
      break;                                                          
400075b8:	81 c7 e0 08 	ret                                            
400075bc:	81 e8 00 00 	restore                                        
      sc = RTEMS_INVALID_ID;                                          
      break;                                                          
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
400075c0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400075c4:	91 e8 20 04 	restore  %g0, 4, %o0                           <== NOT EXECUTED
                                                                      

400075a0 <rtems_fdisk_abort.constprop.1>: * * @param format The format string. See printf for details. * @param ... The arguments for the format text. */ static void rtems_fdisk_abort (const char *format, ...)
400075a0:	9d e3 bf 98 	save  %sp, -104, %sp                           <== NOT EXECUTED
{                                                                     
  va_list args;                                                       
  va_start (args, format);                                            
  fprintf (stderr, "fdisk:abort:");                                   
400075a4:	31 10 00 e4 	sethi  %hi(0x40039000), %i0                    <== NOT EXECUTED
400075a8:	c2 06 23 70 	ld  [ %i0 + 0x370 ], %g1	! 40039370 <_impure_ptr><== NOT EXECUTED
 */                                                                   
static void                                                           
rtems_fdisk_abort (const char *format, ...)                           
{                                                                     
  va_list args;                                                       
  va_start (args, format);                                            
400075ac:	f2 27 a0 48 	st  %i1, [ %fp + 0x48 ]                        <== NOT EXECUTED
400075b0:	f4 27 a0 4c 	st  %i2, [ %fp + 0x4c ]                        <== NOT EXECUTED
400075b4:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]                        <== NOT EXECUTED
400075b8:	f8 27 a0 54 	st  %i4, [ %fp + 0x54 ]                        <== NOT EXECUTED
400075bc:	fa 27 a0 58 	st  %i5, [ %fp + 0x58 ]                        <== NOT EXECUTED
  fprintf (stderr, "fdisk:abort:");                                   
400075c0:	d6 00 60 0c 	ld  [ %g1 + 0xc ], %o3                         <== NOT EXECUTED
 */                                                                   
static void                                                           
rtems_fdisk_abort (const char *format, ...)                           
{                                                                     
  va_list args;                                                       
  va_start (args, format);                                            
400075c4:	82 07 a0 48 	add  %fp, 0x48, %g1                            <== NOT EXECUTED
  fprintf (stderr, "fdisk:abort:");                                   
400075c8:	94 10 20 0c 	mov  0xc, %o2                                  <== NOT EXECUTED
400075cc:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
 */                                                                   
static void                                                           
rtems_fdisk_abort (const char *format, ...)                           
{                                                                     
  va_list args;                                                       
  va_start (args, format);                                            
400075d0:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          <== NOT EXECUTED
  fprintf (stderr, "fdisk:abort:");                                   
400075d4:	11 10 00 d1 	sethi  %hi(0x40034400), %o0                    <== NOT EXECUTED
400075d8:	40 00 70 d4 	call  40023928 <fwrite>                        <== NOT EXECUTED
400075dc:	90 12 22 d0 	or  %o0, 0x2d0, %o0	! 400346d0 <__FUNCTION__.6193+0x608><== NOT EXECUTED
  vfprintf (stderr, format, args);                                    
400075e0:	c2 06 23 70 	ld  [ %i0 + 0x370 ], %g1                       <== NOT EXECUTED
400075e4:	11 10 00 d1 	sethi  %hi(0x40034400), %o0                    <== NOT EXECUTED
400075e8:	d2 00 60 0c 	ld  [ %g1 + 0xc ], %o1                         <== NOT EXECUTED
400075ec:	40 00 6f 22 	call  40023274 <fputs>                         <== NOT EXECUTED
400075f0:	90 12 22 e0 	or  %o0, 0x2e0, %o0                            <== NOT EXECUTED
  fprintf (stderr, "\n");                                             
400075f4:	c2 06 23 70 	ld  [ %i0 + 0x370 ], %g1                       <== NOT EXECUTED
400075f8:	90 10 20 0a 	mov  0xa, %o0                                  <== NOT EXECUTED
400075fc:	40 00 6e ea 	call  400231a4 <fputc>                         <== NOT EXECUTED
40007600:	d2 00 60 0c 	ld  [ %g1 + 0xc ], %o1                         <== NOT EXECUTED
  fflush (stderr);                                                    
40007604:	c2 06 23 70 	ld  [ %i0 + 0x370 ], %g1                       <== NOT EXECUTED
40007608:	40 00 6d cf 	call  40022d44 <fflush>                        <== NOT EXECUTED
4000760c:	d0 00 60 0c 	ld  [ %g1 + 0xc ], %o0                         <== NOT EXECUTED
  va_end (args);                                                      
  exit (1);                                                           
40007610:	40 00 6c cd 	call  40022944 <exit>                          <== NOT EXECUTED
40007614:	90 10 20 01 	mov  1, %o0                                    <== NOT EXECUTED
                                                                      

400055a8 <rtems_fdisk_compact>: * used segments that will fit. The used queue is sorted on the least * number of active pages. */ static int rtems_fdisk_compact (rtems_flashdisk* fd) {
400055a8:	9d e3 bf 98 	save  %sp, -104, %sp                           
static bool                                                           
rtems_fdisk_is_erased_blocks_starvation (rtems_flashdisk* fd)         
{                                                                     
  bool starvation = fd->erased_blocks < fd->starvation_threshold;     
                                                                      
  if (starvation)                                                     
400055ac:	c4 06 20 28 	ld  [ %i0 + 0x28 ], %g2                        
400055b0:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
400055b4:	80 a0 80 01 	cmp  %g2, %g1                                  
400055b8:	1a 80 00 20 	bcc  40005638 <rtems_fdisk_compact+0x90>       
400055bc:	a6 10 00 18 	mov  %i0, %l3                                  
    fd->starvations++;                                                
400055c0:	c2 06 20 70 	ld  [ %i0 + 0x70 ], %g1                        
  uint32_t pages;                                                     
                                                                      
  if (rtems_fdisk_is_erased_blocks_starvation (fd))                   
  {                                                                   
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_printf (fd, " resolve starvation");                   
400055c4:	90 10 00 18 	mov  %i0, %o0                                  
rtems_fdisk_is_erased_blocks_starvation (rtems_flashdisk* fd)         
{                                                                     
  bool starvation = fd->erased_blocks < fd->starvation_threshold;     
                                                                      
  if (starvation)                                                     
    fd->starvations++;                                                
400055c8:	82 00 60 01 	inc  %g1                                       
  uint32_t pages;                                                     
                                                                      
  if (rtems_fdisk_is_erased_blocks_starvation (fd))                   
  {                                                                   
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_printf (fd, " resolve starvation");                   
400055cc:	13 10 00 d1 	sethi  %hi(0x40034400), %o1                    
rtems_fdisk_is_erased_blocks_starvation (rtems_flashdisk* fd)         
{                                                                     
  bool starvation = fd->erased_blocks < fd->starvation_threshold;     
                                                                      
  if (starvation)                                                     
    fd->starvations++;                                                
400055d0:	c2 26 20 70 	st  %g1, [ %i0 + 0x70 ]                        
  uint32_t pages;                                                     
                                                                      
  if (rtems_fdisk_is_erased_blocks_starvation (fd))                   
  {                                                                   
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_printf (fd, " resolve starvation");                   
400055d4:	7f ff fc a7 	call  40004870 <rtems_fdisk_printf>            
400055d8:	92 12 61 d8 	or  %o1, 0x1d8, %o1                            
 * Pop the head of the segment control queue.                         
 */                                                                   
static rtems_fdisk_segment_ctl*                                       
rtems_fdisk_segment_queue_pop_head (rtems_fdisk_segment_ctl_queue* queue)
{                                                                     
  if (queue->head)                                                    
400055dc:	fa 06 20 40 	ld  [ %i0 + 0x40 ], %i5                        
400055e0:	80 a7 60 00 	cmp  %i5, 0                                    
400055e4:	22 80 00 83 	be,a   400057f0 <rtems_fdisk_compact+0x248>    <== NEVER TAKEN
400055e8:	fa 06 20 34 	ld  [ %i0 + 0x34 ], %i5                        <== NOT EXECUTED
  {                                                                   
    rtems_fdisk_segment_ctl* sc = queue->head;                        
                                                                      
    queue->head = sc->next;                                           
400055ec:	c2 07 40 00 	ld  [ %i5 ], %g1                               
    if (!queue->head)                                                 
400055f0:	80 a0 60 00 	cmp  %g1, 0                                    
400055f4:	02 80 00 9f 	be  40005870 <rtems_fdisk_compact+0x2c8>       <== NEVER TAKEN
400055f8:	c2 26 20 40 	st  %g1, [ %i0 + 0x40 ]                        
      queue->tail = 0;                                                
                                                                      
    queue->count--;                                                   
400055fc:	c2 04 e0 48 	ld  [ %l3 + 0x48 ], %g1                        
40005600:	82 00 7f ff 	add  %g1, -1, %g1                              
40005604:	c2 24 e0 48 	st  %g1, [ %l3 + 0x48 ]                        
                                                                      
    sc->next = 0;                                                     
40005608:	c0 27 40 00 	clr  [ %i5 ]                                   
    if (!ssc)                                                         
      ssc = rtems_fdisk_segment_queue_pop_head (&fd->available);      
                                                                      
    if (ssc)                                                          
    {                                                                 
      dsc = rtems_fdisk_seg_most_available (&fd->available);          
4000560c:	7f ff fc 59 	call  40004770 <rtems_fdisk_seg_most_available>
40005610:	90 04 e0 34 	add  %l3, 0x34, %o0                            
      if (dsc)                                                        
40005614:	94 92 20 00 	orcc  %o0, 0, %o2                              
40005618:	02 80 00 8b 	be  40005844 <rtems_fdisk_compact+0x29c>       <== NEVER TAKEN
4000561c:	92 10 00 1d 	mov  %i5, %o1                                  
      {                                                               
        ret = rtems_fdisk_recycle_segment (fd, ssc, dsc, &pages);     
40005620:	90 10 00 13 	mov  %l3, %o0                                  
40005624:	7f ff fe d1 	call  40005168 <rtems_fdisk_recycle_segment>   
40005628:	96 07 bf fc 	add  %fp, -4, %o3                              
        if (ret)                                                      
4000562c:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40005630:	12 80 00 8e 	bne  40005868 <rtems_fdisk_compact+0x2c0>      <== NEVER TAKEN
40005634:	01 00 00 00 	nop                                            
40005638:	d2 04 e0 40 	ld  [ %l3 + 0x40 ], %o1                        
  {                                                                   
    uint32_t                 dst_pages;                               
    uint32_t                 segments;                                
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_printf (fd, " compacting");                           
4000563c:	21 10 00 d1 	sethi  %hi(0x40034400), %l0                    
    dst_pages = rtems_fdisk_seg_pages_available (dsc);                
    segments = 0;                                                     
    pages = 0;                                                        
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_printf (fd, " dsc:%02d-%03d: most available",         
40005640:	23 10 00 d1 	sethi  %hi(0x40034400), %l1                    
#endif                                                                
      break;                                                          
    }                                                                 
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_printf (fd, " ssc scan: %d-%d: p=%ld, seg=%ld",       
40005644:	25 10 00 d1 	sethi  %hi(0x40034400), %l2                    
                                                                      
    while (ssc &&                                                     
           ((pages + ssc->pages_active) < dst_pages) &&               
           ((compacted_segs + segments) < fd->compact_segs))          
    {                                                                 
      pages += ssc->pages_active;                                     
40005648:	b8 10 20 00 	clr  %i4                                       
  {                                                                   
    uint32_t                 dst_pages;                               
    uint32_t                 segments;                                
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_printf (fd, " compacting");                           
4000564c:	a0 14 22 08 	or  %l0, 0x208, %l0                            
#endif                                                                
                                                                      
    dsc = rtems_fdisk_seg_most_available (&fd->available);            
40005650:	b2 04 e0 34 	add  %l3, 0x34, %i1                            
    dst_pages = rtems_fdisk_seg_pages_available (dsc);                
    segments = 0;                                                     
    pages = 0;                                                        
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_printf (fd, " dsc:%02d-%03d: most available",         
40005654:	a2 14 62 50 	or  %l1, 0x250, %l1                            
#endif                                                                
      break;                                                          
    }                                                                 
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_printf (fd, " ssc scan: %d-%d: p=%ld, seg=%ld",       
40005658:	a4 14 a2 88 	or  %l2, 0x288, %l2                            
      rtems_fdisk_error ("compacting: nothing to recycle");           
      return EIO;                                                     
    }                                                                 
  }                                                                   
                                                                      
  while (fd->used.head)                                               
4000565c:	80 a2 60 00 	cmp  %o1, 0                                    
40005660:	02 80 00 70 	be  40005820 <rtems_fdisk_compact+0x278>       
40005664:	92 10 00 10 	mov  %l0, %o1                                  
  {                                                                   
    uint32_t                 dst_pages;                               
    uint32_t                 segments;                                
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_printf (fd, " compacting");                           
40005668:	7f ff fc 82 	call  40004870 <rtems_fdisk_printf>            
4000566c:	90 10 00 13 	mov  %l3, %o0                                  
#endif                                                                
                                                                      
    dsc = rtems_fdisk_seg_most_available (&fd->available);            
40005670:	7f ff fc 40 	call  40004770 <rtems_fdisk_seg_most_available>
40005674:	90 10 00 19 	mov  %i1, %o0                                  
                                                                      
    if (dsc == 0)                                                     
40005678:	b4 92 20 00 	orcc  %o0, 0, %i2                              
4000567c:	02 80 00 6b 	be  40005828 <rtems_fdisk_compact+0x280>       <== NEVER TAKEN
40005680:	11 10 00 d1 	sethi  %hi(0x40034400), %o0                    
 * with the most available number of pages and see if we have         
 * used segments that will fit. The used queue is sorted on the least 
 * number of active pages.                                            
 */                                                                   
static int                                                            
rtems_fdisk_compact (rtems_flashdisk* fd)                             
40005684:	f6 06 a0 24 	ld  [ %i2 + 0x24 ], %i3                        
40005688:	c6 06 a0 20 	ld  [ %i2 + 0x20 ], %g3                        
 * active, used and bad pages.                                        
 */                                                                   
static uint32_t                                                       
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)   
{                                                                     
  return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
4000568c:	c4 06 a0 14 	ld  [ %i2 + 0x14 ], %g2                        
40005690:	c2 06 a0 1c 	ld  [ %i2 + 0x1c ], %g1                        
    dst_pages = rtems_fdisk_seg_pages_available (dsc);                
    segments = 0;                                                     
    pages = 0;                                                        
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_printf (fd, " dsc:%02d-%03d: most available",         
40005694:	d4 06 a0 08 	ld  [ %i2 + 8 ], %o2                           
40005698:	d6 06 a0 0c 	ld  [ %i2 + 0xc ], %o3                         
    {                                                                 
      rtems_fdisk_error ("compacting: no available segments to compact too");
      return EIO;                                                     
    }                                                                 
                                                                      
    ssc = fd->used.head;                                              
4000569c:	fa 04 e0 40 	ld  [ %l3 + 0x40 ], %i5                        
 * with the most available number of pages and see if we have         
 * used segments that will fit. The used queue is sorted on the least 
 * number of active pages.                                            
 */                                                                   
static int                                                            
rtems_fdisk_compact (rtems_flashdisk* fd)                             
400056a0:	b6 06 c0 03 	add  %i3, %g3, %i3                             
    }                                                                 
                                                                      
    ssc = fd->used.head;                                              
    dst_pages = rtems_fdisk_seg_pages_available (dsc);                
    segments = 0;                                                     
    pages = 0;                                                        
400056a4:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
 * active, used and bad pages.                                        
 */                                                                   
static uint32_t                                                       
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)   
{                                                                     
  return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
400056a8:	b6 20 80 1b 	sub  %g2, %i3, %i3                             
    dst_pages = rtems_fdisk_seg_pages_available (dsc);                
    segments = 0;                                                     
    pages = 0;                                                        
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_printf (fd, " dsc:%02d-%03d: most available",         
400056ac:	90 10 00 13 	mov  %l3, %o0                                  
 * active, used and bad pages.                                        
 */                                                                   
static uint32_t                                                       
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)   
{                                                                     
  return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
400056b0:	b6 26 c0 01 	sub  %i3, %g1, %i3                             
    dst_pages = rtems_fdisk_seg_pages_available (dsc);                
    segments = 0;                                                     
    pages = 0;                                                        
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_printf (fd, " dsc:%02d-%03d: most available",         
400056b4:	7f ff fc 6f 	call  40004870 <rtems_fdisk_printf>            
400056b8:	92 10 00 11 	mov  %l1, %o1                                  
     * we handle during one compaction. A lower number means less aggressive
     * compaction or less delay when compacting but it may mean the disk
     * will fill.                                                     
     */                                                               
                                                                      
    while (ssc &&                                                     
400056bc:	80 a7 60 00 	cmp  %i5, 0                                    
400056c0:	02 80 00 1b 	be  4000572c <rtems_fdisk_compact+0x184>       <== NEVER TAKEN
400056c4:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
           ((pages + ssc->pages_active) < dst_pages) &&               
400056c8:	d8 07 60 1c 	ld  [ %i5 + 0x1c ], %o4                        
400056cc:	98 00 40 0c 	add  %g1, %o4, %o4                             
     * we handle during one compaction. A lower number means less aggressive
     * compaction or less delay when compacting but it may mean the disk
     * will fill.                                                     
     */                                                               
                                                                      
    while (ssc &&                                                     
400056d0:	80 a6 c0 0c 	cmp  %i3, %o4                                  
400056d4:	28 80 00 45 	bleu,a   400057e8 <rtems_fdisk_compact+0x240>  
400056d8:	98 10 00 01 	mov  %g1, %o4                                  
           ((pages + ssc->pages_active) < dst_pages) &&               
           ((compacted_segs + segments) < fd->compact_segs))          
400056dc:	c6 04 e0 0c 	ld  [ %l3 + 0xc ], %g3                         
     * compaction or less delay when compacting but it may mean the disk
     * will fill.                                                     
     */                                                               
                                                                      
    while (ssc &&                                                     
           ((pages + ssc->pages_active) < dst_pages) &&               
400056e0:	80 a7 00 03 	cmp  %i4, %g3                                  
400056e4:	3a 80 00 41 	bcc,a   400057e8 <rtems_fdisk_compact+0x240>   <== NEVER TAKEN
400056e8:	98 10 00 01 	mov  %g1, %o4                                  <== NOT EXECUTED
400056ec:	10 80 00 0b 	b  40005718 <rtems_fdisk_compact+0x170>        
400056f0:	9a 10 20 00 	clr  %o5                                       
400056f4:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
400056f8:	82 03 00 01 	add  %o4, %g1, %g1                             
     * we handle during one compaction. A lower number means less aggressive
     * compaction or less delay when compacting but it may mean the disk
     * will fill.                                                     
     */                                                               
                                                                      
    while (ssc &&                                                     
400056fc:	80 a0 40 1b 	cmp  %g1, %i3                                  
40005700:	1a 80 00 12 	bcc  40005748 <rtems_fdisk_compact+0x1a0>      
40005704:	84 07 00 0d 	add  %i4, %o5, %g2                             
           ((pages + ssc->pages_active) < dst_pages) &&               
40005708:	80 a0 80 03 	cmp  %g2, %g3                                  
4000570c:	3a 80 00 10 	bcc,a   4000574c <rtems_fdisk_compact+0x1a4>   <== NEVER TAKEN
40005710:	d8 27 bf fc 	st  %o4, [ %fp + -4 ]                          <== NOT EXECUTED
40005714:	98 10 00 01 	mov  %g1, %o4                                  
           ((compacted_segs + segments) < fd->compact_segs))          
    {                                                                 
      pages += ssc->pages_active;                                     
      segments++;                                                     
      ssc = ssc->next;                                                
40005718:	fa 07 40 00 	ld  [ %i5 ], %i5                               
     * we handle during one compaction. A lower number means less aggressive
     * compaction or less delay when compacting but it may mean the disk
     * will fill.                                                     
     */                                                               
                                                                      
    while (ssc &&                                                     
4000571c:	80 a7 60 00 	cmp  %i5, 0                                    
40005720:	12 bf ff f5 	bne  400056f4 <rtems_fdisk_compact+0x14c>      
40005724:	9a 03 60 01 	inc  %o5                                       
40005728:	d8 27 bf fc 	st  %o4, [ %fp + -4 ]                          
     */                                                               
                                                                      
    if (!ssc || (pages == 0) || ((compacted_segs + segments) == 1))   
    {                                                                 
#if RTEMS_FDISK_TRACE                                                 
      rtems_fdisk_printf (fd, " nothing to compact");                 
4000572c:	90 10 00 13 	mov  %l3, %o0                                  
40005730:	13 10 00 d1 	sethi  %hi(0x40034400), %o1                    
    }                                                                 
                                                                      
    compacted_segs += segments;                                       
  }                                                                   
                                                                      
  return 0;                                                           
40005734:	b0 10 20 00 	clr  %i0                                       
     */                                                               
                                                                      
    if (!ssc || (pages == 0) || ((compacted_segs + segments) == 1))   
    {                                                                 
#if RTEMS_FDISK_TRACE                                                 
      rtems_fdisk_printf (fd, " nothing to compact");                 
40005738:	7f ff fc 4e 	call  40004870 <rtems_fdisk_printf>            
4000573c:	92 12 62 70 	or  %o1, 0x270, %o1                            
#endif                                                                
      break;                                                          
40005740:	81 c7 e0 08 	ret                                            
40005744:	81 e8 00 00 	restore                                        
40005748:	d8 27 bf fc 	st  %o4, [ %fp + -4 ]                          
     * We need a source segment and have pages to copy and            
     * compacting one segment to another is silly. Compaction needs   
     * to free at least one more segment.                             
     */                                                               
                                                                      
    if (!ssc || (pages == 0) || ((compacted_segs + segments) == 1))   
4000574c:	80 a3 20 00 	cmp  %o4, 0                                    
40005750:	02 bf ff f8 	be  40005730 <rtems_fdisk_compact+0x188>       
40005754:	90 10 00 13 	mov  %l3, %o0                                  
40005758:	b8 07 00 0d 	add  %i4, %o5, %i4                             
4000575c:	80 a7 20 01 	cmp  %i4, 1                                    
40005760:	22 bf ff f5 	be,a   40005734 <rtems_fdisk_compact+0x18c>    
40005764:	13 10 00 d1 	sethi  %hi(0x40034400), %o1                    
#endif                                                                
      break;                                                          
    }                                                                 
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_printf (fd, " ssc scan: %d-%d: p=%ld, seg=%ld",       
40005768:	d4 07 60 08 	ld  [ %i5 + 8 ], %o2                           
4000576c:	d6 07 60 0c 	ld  [ %i5 + 0xc ], %o3                         
40005770:	92 10 00 12 	mov  %l2, %o1                                  
40005774:	7f ff fc 3f 	call  40004870 <rtems_fdisk_printf>            
40005778:	90 10 00 13 	mov  %l3, %o0                                  
                        ssc->device, ssc->segment,                    
                        pages, segments);                             
#endif                                                                
                                                                      
    rtems_fdisk_segment_queue_remove (&fd->available, dsc);           
4000577c:	90 10 00 19 	mov  %i1, %o0                                  
40005780:	7f ff fb 9b 	call  400045ec <rtems_fdisk_segment_queue_remove>
40005784:	92 10 00 1a 	mov  %i2, %o1                                  
40005788:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4000578c:	d2 04 e0 40 	ld  [ %l3 + 0x40 ], %o1                        
                                                                      
    /*                                                                
     * We now copy the pages to the new segment.                      
     */                                                               
                                                                      
    while (pages)                                                     
40005790:	80 a0 60 00 	cmp  %g1, 0                                    
40005794:	02 bf ff b3 	be  40005660 <rtems_fdisk_compact+0xb8>        
40005798:	80 a2 60 00 	cmp  %o1, 0                                    
 * Pop the head of the segment control queue.                         
 */                                                                   
static rtems_fdisk_segment_ctl*                                       
rtems_fdisk_segment_queue_pop_head (rtems_fdisk_segment_ctl_queue* queue)
{                                                                     
  if (queue->head)                                                    
4000579c:	02 bf ff fe 	be  40005794 <rtems_fdisk_compact+0x1ec>       <== NEVER TAKEN
400057a0:	80 a0 60 00 	cmp  %g1, 0                                    
  {                                                                   
    rtems_fdisk_segment_ctl* sc = queue->head;                        
                                                                      
    queue->head = sc->next;                                           
400057a4:	c2 02 40 00 	ld  [ %o1 ], %g1                               
    if (!queue->head)                                                 
400057a8:	80 a0 60 00 	cmp  %g1, 0                                    
400057ac:	02 80 00 24 	be  4000583c <rtems_fdisk_compact+0x294>       <== NEVER TAKEN
400057b0:	c2 24 e0 40 	st  %g1, [ %l3 + 0x40 ]                        
      queue->tail = 0;                                                
                                                                      
    queue->count--;                                                   
400057b4:	c2 04 e0 48 	ld  [ %l3 + 0x48 ], %g1                        
    {                                                                 
      ssc = rtems_fdisk_segment_queue_pop_head (&fd->used);           
                                                                      
      if (ssc)                                                        
      {                                                               
        ret = rtems_fdisk_recycle_segment (fd, ssc, dsc, &pages);     
400057b8:	90 10 00 13 	mov  %l3, %o0                                  
                                                                      
    queue->head = sc->next;                                           
    if (!queue->head)                                                 
      queue->tail = 0;                                                
                                                                      
    queue->count--;                                                   
400057bc:	82 00 7f ff 	add  %g1, -1, %g1                              
400057c0:	c2 24 e0 48 	st  %g1, [ %l3 + 0x48 ]                        
                                                                      
    sc->next = 0;                                                     
400057c4:	c0 22 40 00 	clr  [ %o1 ]                                   
    {                                                                 
      ssc = rtems_fdisk_segment_queue_pop_head (&fd->used);           
                                                                      
      if (ssc)                                                        
      {                                                               
        ret = rtems_fdisk_recycle_segment (fd, ssc, dsc, &pages);     
400057c8:	94 10 00 1a 	mov  %i2, %o2                                  
400057cc:	7f ff fe 67 	call  40005168 <rtems_fdisk_recycle_segment>   
400057d0:	96 07 bf fc 	add  %fp, -4, %o3                              
        if (ret)                                                      
400057d4:	b0 92 20 00 	orcc  %o0, 0, %i0                              
400057d8:	02 bf ff ed 	be  4000578c <rtems_fdisk_compact+0x1e4>       <== ALWAYS TAKEN
400057dc:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
                                                                      
    compacted_segs += segments;                                       
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
400057e0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400057e4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
      return EIO;                                                     
    }                                                                 
                                                                      
    ssc = fd->used.head;                                              
    dst_pages = rtems_fdisk_seg_pages_available (dsc);                
    segments = 0;                                                     
400057e8:	10 bf ff d9 	b  4000574c <rtems_fdisk_compact+0x1a4>        
400057ec:	9a 10 20 00 	clr  %o5                                       
 * Pop the head of the segment control queue.                         
 */                                                                   
static rtems_fdisk_segment_ctl*                                       
rtems_fdisk_segment_queue_pop_head (rtems_fdisk_segment_ctl_queue* queue)
{                                                                     
  if (queue->head)                                                    
400057f0:	80 a7 60 00 	cmp  %i5, 0                                    <== NOT EXECUTED
400057f4:	02 80 00 1a 	be  4000585c <rtems_fdisk_compact+0x2b4>       <== NOT EXECUTED
400057f8:	11 10 00 d1 	sethi  %hi(0x40034400), %o0                    <== NOT EXECUTED
  {                                                                   
    rtems_fdisk_segment_ctl* sc = queue->head;                        
                                                                      
    queue->head = sc->next;                                           
400057fc:	c2 07 40 00 	ld  [ %i5 ], %g1                               <== NOT EXECUTED
    if (!queue->head)                                                 
40005800:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40005804:	02 80 00 1d 	be  40005878 <rtems_fdisk_compact+0x2d0>       <== NOT EXECUTED
40005808:	c2 24 e0 34 	st  %g1, [ %l3 + 0x34 ]                        <== NOT EXECUTED
      queue->tail = 0;                                                
                                                                      
    queue->count--;                                                   
4000580c:	c2 04 e0 3c 	ld  [ %l3 + 0x3c ], %g1                        <== NOT EXECUTED
40005810:	82 00 7f ff 	add  %g1, -1, %g1                              <== NOT EXECUTED
40005814:	c2 24 e0 3c 	st  %g1, [ %l3 + 0x3c ]                        <== NOT EXECUTED
                                                                      
    sc->next = 0;                                                     
40005818:	10 bf ff 7d 	b  4000560c <rtems_fdisk_compact+0x64>         <== NOT EXECUTED
4000581c:	c0 27 40 00 	clr  [ %i5 ]                                   <== NOT EXECUTED
    }                                                                 
                                                                      
    compacted_segs += segments;                                       
  }                                                                   
                                                                      
  return 0;                                                           
40005820:	81 c7 e0 08 	ret                                            
40005824:	91 e8 20 00 	restore  %g0, 0, %o0                           
    dsc = rtems_fdisk_seg_most_available (&fd->available);            
                                                                      
    if (dsc == 0)                                                     
    {                                                                 
      rtems_fdisk_error ("compacting: no available segments to compact too");
      return EIO;                                                     
40005828:	b0 10 20 05 	mov  5, %i0                                    <== NOT EXECUTED
                                                                      
    dsc = rtems_fdisk_seg_most_available (&fd->available);            
                                                                      
    if (dsc == 0)                                                     
    {                                                                 
      rtems_fdisk_error ("compacting: no available segments to compact too");
4000582c:	7f ff fc eb 	call  40004bd8 <rtems_fdisk_error>             <== NOT EXECUTED
40005830:	90 12 22 18 	or  %o0, 0x218, %o0                            <== NOT EXECUTED
40005834:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40005838:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  {                                                                   
    rtems_fdisk_segment_ctl* sc = queue->head;                        
                                                                      
    queue->head = sc->next;                                           
    if (!queue->head)                                                 
      queue->tail = 0;                                                
4000583c:	10 bf ff de 	b  400057b4 <rtems_fdisk_compact+0x20c>        <== NOT EXECUTED
40005840:	c0 24 e0 44 	clr  [ %l3 + 0x44 ]                            <== NOT EXECUTED
        if (ret)                                                      
          return ret;                                                 
      }                                                               
      else                                                            
      {                                                               
        rtems_fdisk_error ("compacting: starvation");                 
40005844:	11 10 00 d1 	sethi  %hi(0x40034400), %o0                    <== NOT EXECUTED
        return EIO;                                                   
40005848:	b0 10 20 05 	mov  5, %i0                                    <== NOT EXECUTED
        if (ret)                                                      
          return ret;                                                 
      }                                                               
      else                                                            
      {                                                               
        rtems_fdisk_error ("compacting: starvation");                 
4000584c:	7f ff fc e3 	call  40004bd8 <rtems_fdisk_error>             <== NOT EXECUTED
40005850:	90 12 21 f0 	or  %o0, 0x1f0, %o0                            <== NOT EXECUTED
40005854:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40005858:	81 e8 00 00 	restore                                        <== NOT EXECUTED
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      rtems_fdisk_error ("compacting: nothing to recycle");           
      return EIO;                                                     
4000585c:	b0 10 20 05 	mov  5, %i0                                    <== NOT EXECUTED
        return EIO;                                                   
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      rtems_fdisk_error ("compacting: nothing to recycle");           
40005860:	7f ff fc de 	call  40004bd8 <rtems_fdisk_error>             <== NOT EXECUTED
40005864:	90 12 22 b0 	or  %o0, 0x2b0, %o0                            <== NOT EXECUTED
40005868:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000586c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  {                                                                   
    rtems_fdisk_segment_ctl* sc = queue->head;                        
                                                                      
    queue->head = sc->next;                                           
    if (!queue->head)                                                 
      queue->tail = 0;                                                
40005870:	10 bf ff 63 	b  400055fc <rtems_fdisk_compact+0x54>         <== NOT EXECUTED
40005874:	c0 26 20 44 	clr  [ %i0 + 0x44 ]                            <== NOT EXECUTED
40005878:	10 bf ff e5 	b  4000580c <rtems_fdisk_compact+0x264>        <== NOT EXECUTED
4000587c:	c0 24 e0 38 	clr  [ %l3 + 0x38 ]                            <== NOT EXECUTED
                                                                      

40004c54 <rtems_fdisk_erase_segment>: /** * Erase the segment. */ static int rtems_fdisk_erase_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc) {
40004c54:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int                                ret;                             
  uint32_t                           device;                          
  uint32_t                           segment;                         
  const rtems_fdisk_segment_desc*    sd;                              
  const rtems_fdisk_driver_handlers* ops;                             
  device = sc->device;                                                
40004c58:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           
static const rtems_fdisk_segment_desc*                                
rtems_fdisk_seg_descriptor (const rtems_flashdisk* fd,                
                            uint32_t               device,            
                            uint32_t               segment)           
{                                                                     
  return fd->devices[device].segments[segment].descriptor;            
40004c5c:	c4 06 20 2c 	ld  [ %i0 + 0x2c ], %g2                        
40004c60:	87 2a 60 04 	sll  %o1, 4, %g3                               
40004c64:	83 2a 60 02 	sll  %o1, 2, %g1                               
40004c68:	82 20 c0 01 	sub  %g3, %g1, %g1                             
40004c6c:	86 00 80 01 	add  %g2, %g1, %g3                             
  const rtems_fdisk_segment_desc*    sd;                              
  const rtems_fdisk_driver_handlers* ops;                             
  device = sc->device;                                                
  segment = sc->segment;                                              
  sd = rtems_fdisk_seg_descriptor (fd, device, segment);              
  ops = fd->devices[device].descriptor->flash_ops;                    
40004c70:	c6 00 e0 08 	ld  [ %g3 + 8 ], %g3                           
  uint32_t                           device;                          
  uint32_t                           segment;                         
  const rtems_fdisk_segment_desc*    sd;                              
  const rtems_fdisk_driver_handlers* ops;                             
  device = sc->device;                                                
  segment = sc->segment;                                              
40004c74:	d4 06 60 0c 	ld  [ %i1 + 0xc ], %o2                         
  sd = rtems_fdisk_seg_descriptor (fd, device, segment);              
  ops = fd->devices[device].descriptor->flash_ops;                    
  ret = ops->erase (sd, device, segment);                             
40004c78:	f8 00 e0 08 	ld  [ %g3 + 8 ], %i4                           
static const rtems_fdisk_segment_desc*                                
rtems_fdisk_seg_descriptor (const rtems_flashdisk* fd,                
                            uint32_t               device,            
                            uint32_t               segment)           
{                                                                     
  return fd->devices[device].segments[segment].descriptor;            
40004c7c:	c6 00 80 01 	ld  [ %g2 + %g1 ], %g3                         
40004c80:	89 2a a0 06 	sll  %o2, 6, %g4                               
40004c84:	85 2a a0 04 	sll  %o2, 4, %g2                               
  const rtems_fdisk_driver_handlers* ops;                             
  device = sc->device;                                                
  segment = sc->segment;                                              
  sd = rtems_fdisk_seg_descriptor (fd, device, segment);              
  ops = fd->devices[device].descriptor->flash_ops;                    
  ret = ops->erase (sd, device, segment);                             
40004c88:	c2 07 20 10 	ld  [ %i4 + 0x10 ], %g1                        
static const rtems_fdisk_segment_desc*                                
rtems_fdisk_seg_descriptor (const rtems_flashdisk* fd,                
                            uint32_t               device,            
                            uint32_t               segment)           
{                                                                     
  return fd->devices[device].segments[segment].descriptor;            
40004c8c:	84 21 00 02 	sub  %g4, %g2, %g2                             
40004c90:	84 00 c0 02 	add  %g3, %g2, %g2                             
  const rtems_fdisk_driver_handlers* ops;                             
  device = sc->device;                                                
  segment = sc->segment;                                              
  sd = rtems_fdisk_seg_descriptor (fd, device, segment);              
  ops = fd->devices[device].descriptor->flash_ops;                    
  ret = ops->erase (sd, device, segment);                             
40004c94:	d0 00 a0 04 	ld  [ %g2 + 4 ], %o0                           
40004c98:	9f c0 40 00 	call  %g1                                      
40004c9c:	ba 10 00 18 	mov  %i0, %i5                                  
  if (ret)                                                            
40004ca0:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40004ca4:	22 80 00 24 	be,a   40004d34 <rtems_fdisk_erase_segment+0xe0><== ALWAYS TAKEN
40004ca8:	c6 07 60 28 	ld  [ %i5 + 0x28 ], %g3                        
  {                                                                   
    rtems_fdisk_error (" erase-segment:%02d-%03d: "      \            
40004cac:	f6 06 60 08 	ld  [ %i1 + 8 ], %i3                           <== NOT EXECUTED
40004cb0:	40 00 80 fd 	call  400250a4 <strerror>                      <== NOT EXECUTED
40004cb4:	f8 06 60 0c 	ld  [ %i1 + 0xc ], %i4                         <== NOT EXECUTED
40004cb8:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
40004cbc:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
40004cc0:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
40004cc4:	11 10 00 d0 	sethi  %hi(0x40034000), %o0                    <== NOT EXECUTED
40004cc8:	98 10 00 18 	mov  %i0, %o4                                  <== NOT EXECUTED
40004ccc:	7f ff ff c3 	call  40004bd8 <rtems_fdisk_error>             <== NOT EXECUTED
40004cd0:	90 12 23 c0 	or  %o0, 0x3c0, %o0                            <== NOT EXECUTED
 */                                                                   
static bool                                                           
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
                                   rtems_fdisk_segment_ctl*       sc) 
{                                                                     
  rtems_fdisk_segment_ctl*  it = queue->head;                         
40004cd4:	c2 07 60 58 	ld  [ %i5 + 0x58 ], %g1                        <== NOT EXECUTED
  if (ret)                                                            
  {                                                                   
    rtems_fdisk_error (" erase-segment:%02d-%03d: "      \            
                       "segment erase failed: %s (%d)",               
                       sc->device, sc->segment, strerror (ret), ret); 
    sc->failed = true;                                                
40004cd8:	84 10 20 01 	mov  1, %g2                                    <== NOT EXECUTED
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
                                   rtems_fdisk_segment_ctl*       sc) 
{                                                                     
  rtems_fdisk_segment_ctl*  it = queue->head;                         
                                                                      
  while (it)                                                          
40004cdc:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40004ce0:	02 80 00 36 	be  40004db8 <rtems_fdisk_erase_segment+0x164> <== NOT EXECUTED
40004ce4:	c4 26 60 28 	st  %g2, [ %i1 + 0x28 ]                        <== NOT EXECUTED
  {                                                                   
    if (it == sc)                                                     
40004ce8:	80 a6 40 01 	cmp  %i1, %g1                                  <== NOT EXECUTED
40004cec:	32 80 00 06 	bne,a   40004d04 <rtems_fdisk_erase_segment+0xb0><== NOT EXECUTED
40004cf0:	c2 00 40 00 	ld  [ %g1 ], %g1                               <== NOT EXECUTED
40004cf4:	30 80 00 35 	b,a   40004dc8 <rtems_fdisk_erase_segment+0x174><== NOT EXECUTED
40004cf8:	02 80 00 34 	be  40004dc8 <rtems_fdisk_erase_segment+0x174> <== NOT EXECUTED
40004cfc:	01 00 00 00 	nop                                            <== NOT EXECUTED
      return true;                                                    
    it = it->next;                                                    
40004d00:	c2 00 40 00 	ld  [ %g1 ], %g1                               <== NOT EXECUTED
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
                                   rtems_fdisk_segment_ctl*       sc) 
{                                                                     
  rtems_fdisk_segment_ctl*  it = queue->head;                         
                                                                      
  while (it)                                                          
40004d04:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40004d08:	12 bf ff fc 	bne  40004cf8 <rtems_fdisk_erase_segment+0xa4> <== NOT EXECUTED
40004d0c:	80 a6 40 01 	cmp  %i1, %g1                                  <== NOT EXECUTED
  {                                                                   
    sc->next = 0;                                                     
                                                                      
    if (queue->head)                                                  
    {                                                                 
      queue->tail->next = sc;                                         
40004d10:	c2 07 60 5c 	ld  [ %i5 + 0x5c ], %g1                        <== NOT EXECUTED
rtems_fdisk_segment_queue_push_tail (rtems_fdisk_segment_ctl_queue* queue,
                                     rtems_fdisk_segment_ctl*       sc)
{                                                                     
  if (sc)                                                             
  {                                                                   
    sc->next = 0;                                                     
40004d14:	c0 26 40 00 	clr  [ %i1 ]                                   <== NOT EXECUTED
                                                                      
    if (queue->head)                                                  
    {                                                                 
      queue->tail->next = sc;                                         
40004d18:	f2 20 40 00 	st  %i1, [ %g1 ]                               <== NOT EXECUTED
      queue->tail       = sc;                                         
40004d1c:	f2 27 60 5c 	st  %i1, [ %i5 + 0x5c ]                        <== NOT EXECUTED
    else                                                              
    {                                                                 
      queue->head = queue->tail = sc;                                 
    }                                                                 
                                                                      
    queue->count++;                                                   
40004d20:	c2 07 60 60 	ld  [ %i5 + 0x60 ], %g1                        <== NOT EXECUTED
40004d24:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
40004d28:	c2 27 60 60 	st  %g1, [ %i5 + 0x60 ]                        <== NOT EXECUTED
40004d2c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40004d30:	81 e8 00 00 	restore                                        <== NOT EXECUTED
      rtems_fdisk_segment_queue_push_tail (&fd->failed, sc);          
    return ret;                                                       
  }                                                                   
                                                                      
  fd->erased_blocks += sc->pages;                                     
  sc->erased++;                                                       
40004d34:	c2 06 60 2c 	ld  [ %i1 + 0x2c ], %g1                        
    if (!rtems_fdisk_segment_queue_present (&fd->failed, sc))         
      rtems_fdisk_segment_queue_push_tail (&fd->failed, sc);          
    return ret;                                                       
  }                                                                   
                                                                      
  fd->erased_blocks += sc->pages;                                     
40004d38:	c4 06 60 14 	ld  [ %i1 + 0x14 ], %g2                        
  sc->erased++;                                                       
                                                                      
  memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
40004d3c:	d2 06 60 18 	ld  [ %i1 + 0x18 ], %o1                        
40004d40:	d0 07 60 14 	ld  [ %i5 + 0x14 ], %o0                        
      rtems_fdisk_segment_queue_push_tail (&fd->failed, sc);          
    return ret;                                                       
  }                                                                   
                                                                      
  fd->erased_blocks += sc->pages;                                     
  sc->erased++;                                                       
40004d44:	82 00 60 01 	inc  %g1                                       
                                                                      
  memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
40004d48:	f8 06 60 10 	ld  [ %i1 + 0x10 ], %i4                        
    if (!rtems_fdisk_segment_queue_present (&fd->failed, sc))         
      rtems_fdisk_segment_queue_push_tail (&fd->failed, sc);          
    return ret;                                                       
  }                                                                   
                                                                      
  fd->erased_blocks += sc->pages;                                     
40004d4c:	84 00 c0 02 	add  %g3, %g2, %g2                             
40004d50:	c4 27 60 28 	st  %g2, [ %i5 + 0x28 ]                        
  sc->erased++;                                                       
                                                                      
  memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
40004d54:	7f ff f6 19 	call  400025b8 <.umul>                         
40004d58:	c2 26 60 2c 	st  %g1, [ %i1 + 0x2c ]                        
40004d5c:	92 10 20 ff 	mov  0xff, %o1                                 
40004d60:	94 10 00 08 	mov  %o0, %o2                                  
40004d64:	40 00 7c 08 	call  40023d84 <memset>                        
40004d68:	90 10 00 1c 	mov  %i4, %o0                                  
{                                                                     
  if (sc)                                                             
  {                                                                   
    sc->next = 0;                                                     
                                                                      
    if (queue->head)                                                  
40004d6c:	c2 07 60 34 	ld  [ %i5 + 0x34 ], %g1                        
  fd->erased_blocks += sc->pages;                                     
  sc->erased++;                                                       
                                                                      
  memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
                                                                      
  sc->pages_active = 0;                                               
40004d70:	c0 26 60 1c 	clr  [ %i1 + 0x1c ]                            
  sc->pages_used   = 0;                                               
40004d74:	c0 26 60 20 	clr  [ %i1 + 0x20 ]                            
  sc->pages_bad    = 0;                                               
40004d78:	c0 26 60 24 	clr  [ %i1 + 0x24 ]                            
                                                                      
  sc->failed = false;                                                 
40004d7c:	c0 26 60 28 	clr  [ %i1 + 0x28 ]                            
{                                                                     
  if (sc)                                                             
  {                                                                   
    sc->next = 0;                                                     
                                                                      
    if (queue->head)                                                  
40004d80:	80 a0 60 00 	cmp  %g1, 0                                    
40004d84:	02 80 00 0a 	be  40004dac <rtems_fdisk_erase_segment+0x158> 
40004d88:	c0 26 40 00 	clr  [ %i1 ]                                   
    {                                                                 
      queue->tail->next = sc;                                         
40004d8c:	c2 07 60 38 	ld  [ %i5 + 0x38 ], %g1                        
40004d90:	f2 20 40 00 	st  %i1, [ %g1 ]                               
      queue->tail       = sc;                                         
40004d94:	f2 27 60 38 	st  %i1, [ %i5 + 0x38 ]                        
    else                                                              
    {                                                                 
      queue->head = queue->tail = sc;                                 
    }                                                                 
                                                                      
    queue->count++;                                                   
40004d98:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        
40004d9c:	82 00 60 01 	inc  %g1                                       
40004da0:	c2 27 60 3c 	st  %g1, [ %i5 + 0x3c ]                        
40004da4:	81 c7 e0 08 	ret                                            
40004da8:	81 e8 00 00 	restore                                        
      queue->tail->next = sc;                                         
      queue->tail       = sc;                                         
    }                                                                 
    else                                                              
    {                                                                 
      queue->head = queue->tail = sc;                                 
40004dac:	f2 27 60 38 	st  %i1, [ %i5 + 0x38 ]                        
40004db0:	10 bf ff fa 	b  40004d98 <rtems_fdisk_erase_segment+0x144>  
40004db4:	f2 27 60 34 	st  %i1, [ %i5 + 0x34 ]                        
rtems_fdisk_segment_queue_push_tail (rtems_fdisk_segment_ctl_queue* queue,
                                     rtems_fdisk_segment_ctl*       sc)
{                                                                     
  if (sc)                                                             
  {                                                                   
    sc->next = 0;                                                     
40004db8:	c0 26 40 00 	clr  [ %i1 ]                                   <== NOT EXECUTED
      queue->tail->next = sc;                                         
      queue->tail       = sc;                                         
    }                                                                 
    else                                                              
    {                                                                 
      queue->head = queue->tail = sc;                                 
40004dbc:	f2 27 60 5c 	st  %i1, [ %i5 + 0x5c ]                        <== NOT EXECUTED
40004dc0:	10 bf ff d8 	b  40004d20 <rtems_fdisk_erase_segment+0xcc>   <== NOT EXECUTED
40004dc4:	f2 27 60 58 	st  %i1, [ %i5 + 0x58 ]                        <== NOT EXECUTED
40004dc8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40004dcc:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40004bd8 <rtems_fdisk_error>: * @param ... The arguments for the format text. * @return int The number of bytes written to the output. */ static int rtems_fdisk_error (const char *format, ...) {
40004bd8:	9d e3 bf 98 	save  %sp, -104, %sp                           <== NOT EXECUTED
  int ret;                                                            
  va_list args;                                                       
  va_start (args, format);                                            
  fprintf (stderr, "fdisk:error:");                                   
40004bdc:	21 10 00 e4 	sethi  %hi(0x40039000), %l0                    <== NOT EXECUTED
40004be0:	c2 04 23 70 	ld  [ %l0 + 0x370 ], %g1	! 40039370 <_impure_ptr><== NOT EXECUTED
static int                                                            
rtems_fdisk_error (const char *format, ...)                           
{                                                                     
  int ret;                                                            
  va_list args;                                                       
  va_start (args, format);                                            
40004be4:	f2 27 a0 48 	st  %i1, [ %fp + 0x48 ]                        <== NOT EXECUTED
40004be8:	f4 27 a0 4c 	st  %i2, [ %fp + 0x4c ]                        <== NOT EXECUTED
40004bec:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]                        <== NOT EXECUTED
40004bf0:	f8 27 a0 54 	st  %i4, [ %fp + 0x54 ]                        <== NOT EXECUTED
40004bf4:	fa 27 a0 58 	st  %i5, [ %fp + 0x58 ]                        <== NOT EXECUTED
  fprintf (stderr, "fdisk:error:");                                   
40004bf8:	d6 00 60 0c 	ld  [ %g1 + 0xc ], %o3                         <== NOT EXECUTED
static int                                                            
rtems_fdisk_error (const char *format, ...)                           
{                                                                     
  int ret;                                                            
  va_list args;                                                       
  va_start (args, format);                                            
40004bfc:	82 07 a0 48 	add  %fp, 0x48, %g1                            <== NOT EXECUTED
  fprintf (stderr, "fdisk:error:");                                   
40004c00:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
static int                                                            
rtems_fdisk_error (const char *format, ...)                           
{                                                                     
  int ret;                                                            
  va_list args;                                                       
  va_start (args, format);                                            
40004c04:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          <== NOT EXECUTED
  fprintf (stderr, "fdisk:error:");                                   
40004c08:	94 10 20 0c 	mov  0xc, %o2                                  <== NOT EXECUTED
40004c0c:	11 10 00 d0 	sethi  %hi(0x40034000), %o0                    <== NOT EXECUTED
40004c10:	40 00 7b 46 	call  40023928 <fwrite>                        <== NOT EXECUTED
40004c14:	90 12 23 b0 	or  %o0, 0x3b0, %o0	! 400343b0 <__FUNCTION__.6193+0x2e8><== NOT EXECUTED
  ret =  vfprintf (stderr, format, args);                             
40004c18:	c2 04 23 70 	ld  [ %l0 + 0x370 ], %g1                       <== NOT EXECUTED
40004c1c:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          <== NOT EXECUTED
40004c20:	d0 00 60 0c 	ld  [ %g1 + 0xc ], %o0                         <== NOT EXECUTED
40004c24:	40 00 9c a6 	call  4002bebc <vfprintf>                      <== NOT EXECUTED
40004c28:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
  fprintf (stderr, "\n");                                             
40004c2c:	c2 04 23 70 	ld  [ %l0 + 0x370 ], %g1                       <== NOT EXECUTED
{                                                                     
  int ret;                                                            
  va_list args;                                                       
  va_start (args, format);                                            
  fprintf (stderr, "fdisk:error:");                                   
  ret =  vfprintf (stderr, format, args);                             
40004c30:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
  fprintf (stderr, "\n");                                             
40004c34:	d2 00 60 0c 	ld  [ %g1 + 0xc ], %o1                         <== NOT EXECUTED
40004c38:	40 00 79 5b 	call  400231a4 <fputc>                         <== NOT EXECUTED
40004c3c:	90 10 20 0a 	mov  0xa, %o0                                  <== NOT EXECUTED
  fflush (stderr);                                                    
40004c40:	c2 04 23 70 	ld  [ %l0 + 0x370 ], %g1                       <== NOT EXECUTED
40004c44:	40 00 78 40 	call  40022d44 <fflush>                        <== NOT EXECUTED
40004c48:	d0 00 60 0c 	ld  [ %g1 + 0xc ], %o0                         <== NOT EXECUTED
  va_end (args);                                                      
  return ret;                                                         
}                                                                     
40004c4c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40004c50:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

400047e8 <rtems_fdisk_info>: * @param ... The arguments for the format text. * @return int The number of bytes written to the output. */ static int rtems_fdisk_info (const rtems_flashdisk* fd, const char *format, ...) {
400047e8:	9d e3 bf 98 	save  %sp, -104, %sp                           
  int ret = 0;                                                        
  if (fd->info_level >= 2)                                            
  {                                                                   
    va_list args;                                                     
    va_start (args, format);                                          
400047ec:	f4 27 a0 4c 	st  %i2, [ %fp + 0x4c ]                        
400047f0:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]                        
400047f4:	f8 27 a0 54 	st  %i4, [ %fp + 0x54 ]                        
400047f8:	fa 27 a0 58 	st  %i5, [ %fp + 0x58 ]                        
 */                                                                   
static int                                                            
rtems_fdisk_info (const rtems_flashdisk* fd, const char *format, ...) 
{                                                                     
  int ret = 0;                                                        
  if (fd->info_level >= 2)                                            
400047fc:	c2 06 20 6c 	ld  [ %i0 + 0x6c ], %g1                        
40004800:	80 a0 60 01 	cmp  %g1, 1                                    
40004804:	08 80 00 19 	bleu  40004868 <rtems_fdisk_info+0x80>         <== ALWAYS TAKEN
40004808:	b0 10 20 00 	clr  %i0                                       
  {                                                                   
    va_list args;                                                     
    va_start (args, format);                                          
    fprintf (stdout, "fdisk:");                                       
4000480c:	3b 10 00 e4 	sethi  %hi(0x40039000), %i5                    <== NOT EXECUTED
40004810:	c2 07 63 70 	ld  [ %i5 + 0x370 ], %g1	! 40039370 <_impure_ptr><== NOT EXECUTED
40004814:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
40004818:	d6 00 60 08 	ld  [ %g1 + 8 ], %o3                           <== NOT EXECUTED
{                                                                     
  int ret = 0;                                                        
  if (fd->info_level >= 2)                                            
  {                                                                   
    va_list args;                                                     
    va_start (args, format);                                          
4000481c:	82 07 a0 4c 	add  %fp, 0x4c, %g1                            <== NOT EXECUTED
    fprintf (stdout, "fdisk:");                                       
40004820:	94 10 20 06 	mov  6, %o2                                    <== NOT EXECUTED
{                                                                     
  int ret = 0;                                                        
  if (fd->info_level >= 2)                                            
  {                                                                   
    va_list args;                                                     
    va_start (args, format);                                          
40004824:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          <== NOT EXECUTED
    fprintf (stdout, "fdisk:");                                       
40004828:	11 10 00 d0 	sethi  %hi(0x40034000), %o0                    <== NOT EXECUTED
4000482c:	40 00 7c 3f 	call  40023928 <fwrite>                        <== NOT EXECUTED
40004830:	90 12 23 20 	or  %o0, 0x320, %o0	! 40034320 <__FUNCTION__.6193+0x258><== NOT EXECUTED
    ret =  vfprintf (stdout, format, args);                           
40004834:	c2 07 63 70 	ld  [ %i5 + 0x370 ], %g1                       <== NOT EXECUTED
40004838:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          <== NOT EXECUTED
4000483c:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           <== NOT EXECUTED
40004840:	40 00 9d 9f 	call  4002bebc <vfprintf>                      <== NOT EXECUTED
40004844:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
    fprintf (stdout, "\n");                                           
40004848:	c2 07 63 70 	ld  [ %i5 + 0x370 ], %g1                       <== NOT EXECUTED
  if (fd->info_level >= 2)                                            
  {                                                                   
    va_list args;                                                     
    va_start (args, format);                                          
    fprintf (stdout, "fdisk:");                                       
    ret =  vfprintf (stdout, format, args);                           
4000484c:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
    fprintf (stdout, "\n");                                           
40004850:	d2 00 60 08 	ld  [ %g1 + 8 ], %o1                           <== NOT EXECUTED
40004854:	40 00 7a 54 	call  400231a4 <fputc>                         <== NOT EXECUTED
40004858:	90 10 20 0a 	mov  0xa, %o0                                  <== NOT EXECUTED
    fflush (stdout);                                                  
4000485c:	c2 07 63 70 	ld  [ %i5 + 0x370 ], %g1                       <== NOT EXECUTED
40004860:	40 00 79 39 	call  40022d44 <fflush>                        <== NOT EXECUTED
40004864:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           <== NOT EXECUTED
    va_end (args);                                                    
  }                                                                   
  return ret;                                                         
}                                                                     
40004868:	81 c7 e0 08 	ret                                            
4000486c:	81 e8 00 00 	restore                                        
                                                                      

4000706c <rtems_fdisk_initialize>: */ rtems_device_driver rtems_fdisk_initialize (rtems_device_major_number major, rtems_device_minor_number minor, void* arg __attribute__((unused))) {
4000706c:	9d e3 bf 80 	save  %sp, -128, %sp                           
  const rtems_flashdisk_config* c = rtems_flashdisk_configuration;    
  rtems_flashdisk*              fd;                                   
  rtems_status_code             sc;                                   
                                                                      
  sc = rtems_disk_io_initialize ();                                   
40007070:	7f ff f5 05 	call  40004484 <rtems_disk_io_initialize>      
40007074:	a4 10 00 18 	mov  %i0, %l2                                  
  if (sc != RTEMS_SUCCESSFUL)                                         
40007078:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4000707c:	02 80 00 04 	be  4000708c <rtems_fdisk_initialize+0x20>     <== ALWAYS TAKEN
40007080:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  rtems_flashdisk_count = rtems_flashdisk_configuration_size;         
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
40007084:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40007088:	81 e8 00 00 	restore                                        <== NOT EXECUTED
static rtems_status_code                                              
rtems_fdisk_crc16_gen_factors (uint16_t pattern)                      
{                                                                     
  uint32_t b;                                                         
                                                                      
  rtems_fdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);        
4000708c:	40 00 05 4c 	call  400085bc <malloc>                        
40007090:	90 10 22 00 	mov  0x200, %o0                                
40007094:	03 10 01 26 	sethi  %hi(0x40049800), %g1                    
40007098:	d0 20 60 e0 	st  %o0, [ %g1 + 0xe0 ]	! 400498e0 <rtems_fdisk_crc16_factor>
  if (!rtems_fdisk_crc16_factor)                                      
4000709c:	80 a2 20 00 	cmp  %o0, 0                                    
400070a0:	02 bf ff f9 	be  40007084 <rtems_fdisk_initialize+0x18>     <== NEVER TAKEN
400070a4:	b0 10 20 1a 	mov  0x1a, %i0                                 
  for (b = 0; b < 256; b++)                                           
  {                                                                   
    uint32_t i;                                                       
    uint16_t v = b;                                                   
    for (i = 8; i--;)                                                 
      v = v & 1 ? (v >> 1) ^ pattern : v >> 1;                        
400070a8:	09 3f ff e1 	sethi  %hi(0xffff8400), %g4                    
rtems_fdisk_crc16_gen_factors (uint16_t pattern)                      
{                                                                     
  uint32_t b;                                                         
                                                                      
  rtems_fdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);        
  if (!rtems_fdisk_crc16_factor)                                      
400070ac:	86 10 20 00 	clr  %g3                                       
  for (b = 0; b < 256; b++)                                           
  {                                                                   
    uint32_t i;                                                       
    uint16_t v = b;                                                   
    for (i = 8; i--;)                                                 
      v = v & 1 ? (v >> 1) ^ pattern : v >> 1;                        
400070b0:	88 11 20 08 	or  %g4, 8, %g4                                
    return RTEMS_NO_MEMORY;                                           
                                                                      
  for (b = 0; b < 256; b++)                                           
  {                                                                   
    uint32_t i;                                                       
    uint16_t v = b;                                                   
400070b4:	82 10 00 03 	mov  %g3, %g1                                  
400070b8:	84 10 20 08 	mov  8, %g2                                    
    for (i = 8; i--;)                                                 
      v = v & 1 ? (v >> 1) ^ pattern : v >> 1;                        
400070bc:	80 88 60 01 	btst  1, %g1                                   
400070c0:	83 28 60 10 	sll  %g1, 0x10, %g1                            
400070c4:	02 80 00 03 	be  400070d0 <rtems_fdisk_initialize+0x64>     
400070c8:	83 30 60 11 	srl  %g1, 0x11, %g1                            
400070cc:	82 18 40 04 	xor  %g1, %g4, %g1                             
                                                                      
  for (b = 0; b < 256; b++)                                           
  {                                                                   
    uint32_t i;                                                       
    uint16_t v = b;                                                   
    for (i = 8; i--;)                                                 
400070d0:	84 80 bf ff 	addcc  %g2, -1, %g2                            
400070d4:	12 bf ff fb 	bne  400070c0 <rtems_fdisk_initialize+0x54>    
400070d8:	80 88 60 01 	btst  1, %g1                                   
 * @param major Flash disk major device number.                       
 * @param minor Minor device number, not applicable.                  
 * @param arg Initialization argument, not applicable.                
 */                                                                   
rtems_device_driver                                                   
rtems_fdisk_initialize (rtems_device_major_number major,              
400070dc:	85 28 e0 01 	sll  %g3, 1, %g2                               
                                                                      
  rtems_fdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);        
  if (!rtems_fdisk_crc16_factor)                                      
    return RTEMS_NO_MEMORY;                                           
                                                                      
  for (b = 0; b < 256; b++)                                           
400070e0:	86 00 e0 01 	inc  %g3                                       
400070e4:	80 a0 e1 00 	cmp  %g3, 0x100                                
400070e8:	12 bf ff f3 	bne  400070b4 <rtems_fdisk_initialize+0x48>    
400070ec:	c2 32 00 02 	sth  %g1, [ %o0 + %g2 ]                        
                                                                      
  sc = rtems_fdisk_crc16_gen_factors (0x8408);                        
  if (sc != RTEMS_SUCCESSFUL)                                         
      return sc;                                                      
                                                                      
  rtems_flashdisks = calloc (rtems_flashdisk_configuration_size,      
400070f0:	03 10 00 e4 	sethi  %hi(0x40039000), %g1                    
400070f4:	fa 00 61 bc 	ld  [ %g1 + 0x1bc ], %i5	! 400391bc <rtems_flashdisk_configuration_size>
400070f8:	92 10 20 74 	mov  0x74, %o1                                 
400070fc:	90 10 00 1d 	mov  %i5, %o0                                  
40007100:	40 00 03 2f 	call  40007dbc <calloc>                        
40007104:	35 10 01 26 	sethi  %hi(0x40049800), %i2                    
40007108:	d0 26 a0 d8 	st  %o0, [ %i2 + 0xd8 ]	! 400498d8 <rtems_flashdisks>
                             sizeof (rtems_flashdisk));               
                                                                      
  if (!rtems_flashdisks)                                              
4000710c:	80 a2 20 00 	cmp  %o0, 0                                    
40007110:	02 bf ff dd 	be  40007084 <rtems_fdisk_initialize+0x18>     <== NEVER TAKEN
40007114:	b0 10 20 1a 	mov  0x1a, %i0                                 
    return RTEMS_NO_MEMORY;                                           
                                                                      
  for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
40007118:	80 a7 60 00 	cmp  %i5, 0                                    
4000711c:	02 80 00 f6 	be  400074f4 <rtems_fdisk_initialize+0x488>    <== NEVER TAKEN
40007120:	21 10 00 ce 	sethi  %hi(0x40033800), %l0                    
40007124:	a6 10 20 00 	clr  %l3                                       
40007128:	a0 14 23 50 	or  %l0, 0x350, %l0                            
4000712c:	a2 10 20 00 	clr  %l1                                       
                                                                      
    name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;         
                                                                      
    fd->major              = major;                                   
    fd->minor              = minor;                                   
    fd->flags              = c->flags;                                
40007130:	f8 04 20 0c 	ld  [ %l0 + 0xc ], %i4                         
    fd->compact_segs       = c->compact_segs;                         
40007134:	c8 04 20 14 	ld  [ %l0 + 0x14 ], %g4                        
    fd->avail_compact_segs = c->avail_compact_segs;                   
40007138:	c6 04 20 18 	ld  [ %l0 + 0x18 ], %g3                        
    fd->block_size         = c->block_size;                           
4000713c:	fa 04 00 00 	ld  [ %l0 ], %i5                               
    fd->unavail_blocks     = c->unavail_blocks;                       
40007140:	c4 04 20 10 	ld  [ %l0 + 0x10 ], %g2                        
    fd->info_level         = c->info_level;                           
40007144:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
  if (!rtems_flashdisks)                                              
    return RTEMS_NO_MEMORY;                                           
                                                                      
  for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
  {                                                                   
    char     name[] = RTEMS_FLASHDISK_DEVICE_BASE_NAME "a";           
40007148:	35 00 00 18 	sethi  %hi(0x6000), %i2                        
4000714c:	b4 16 a1 00 	or  %i2, 0x100, %i2	! 6100 <PROM_START+0x6100> 
40007150:	f4 37 bf f8 	sth  %i2, [ %fp + -8 ]                         
    fd->avail_compact_segs = c->avail_compact_segs;                   
    fd->block_size         = c->block_size;                           
    fd->unavail_blocks     = c->unavail_blocks;                       
    fd->info_level         = c->info_level;                           
                                                                      
    for (device = 0; device < c->device_count; device++)              
40007154:	e8 04 20 04 	ld  [ %l0 + 4 ], %l4                           
    uint32_t blocks = 0;                                              
    int      ret;                                                     
                                                                      
    fd = &rtems_flashdisks[minor];                                    
                                                                      
    name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;         
40007158:	e2 2f bf f9 	stb  %l1, [ %fp + -7 ]                         
  if (!rtems_flashdisks)                                              
    return RTEMS_NO_MEMORY;                                           
                                                                      
  for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
  {                                                                   
    char     name[] = RTEMS_FLASHDISK_DEVICE_BASE_NAME "a";           
4000715c:	35 0b d9 19 	sethi  %hi(0x2f646400), %i2                    
40007160:	37 0b d9 99 	sethi  %hi(0x2f666400), %i3                    
40007164:	b4 16 a1 76 	or  %i2, 0x176, %i2                            
40007168:	b6 16 e0 64 	or  %i3, 0x64, %i3                             
4000716c:	f4 3f bf f0 	std  %i2, [ %fp + -16 ]                        
                                                                      
    fd = &rtems_flashdisks[minor];                                    
                                                                      
    name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;         
                                                                      
    fd->major              = major;                                   
40007170:	e4 22 00 13 	st  %l2, [ %o0 + %l3 ]                         
    dev_t    dev = rtems_filesystem_make_dev_t (major, minor);        
    uint32_t device;                                                  
    uint32_t blocks = 0;                                              
    int      ret;                                                     
                                                                      
    fd = &rtems_flashdisks[minor];                                    
40007174:	b6 02 00 13 	add  %o0, %l3, %i3                             
                                                                      
    name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;         
                                                                      
    fd->major              = major;                                   
    fd->minor              = minor;                                   
40007178:	e2 26 e0 04 	st  %l1, [ %i3 + 4 ]                           
    fd->flags              = c->flags;                                
4000717c:	f8 26 e0 08 	st  %i4, [ %i3 + 8 ]                           
    fd->compact_segs       = c->compact_segs;                         
40007180:	c8 26 e0 0c 	st  %g4, [ %i3 + 0xc ]                         
    fd->avail_compact_segs = c->avail_compact_segs;                   
40007184:	c6 26 e0 10 	st  %g3, [ %i3 + 0x10 ]                        
    fd->block_size         = c->block_size;                           
40007188:	fa 26 e0 14 	st  %i5, [ %i3 + 0x14 ]                        
    fd->unavail_blocks     = c->unavail_blocks;                       
4000718c:	c4 26 e0 20 	st  %g2, [ %i3 + 0x20 ]                        
    fd->info_level         = c->info_level;                           
                                                                      
    for (device = 0; device < c->device_count; device++)              
40007190:	80 a5 20 00 	cmp  %l4, 0                                    
40007194:	02 80 00 a3 	be  40007420 <rtems_fdisk_initialize+0x3b4>    <== NEVER TAKEN
40007198:	c2 26 e0 6c 	st  %g1, [ %i3 + 0x6c ]                        
4000719c:	f4 04 20 08 	ld  [ %l0 + 8 ], %i2                           
 * @param major Flash disk major device number.                       
 * @param minor Minor device number, not applicable.                  
 * @param arg Initialization argument, not applicable.                
 */                                                                   
rtems_device_driver                                                   
rtems_fdisk_initialize (rtems_device_major_number major,              
400071a0:	83 2d 20 02 	sll  %l4, 2, %g1                               
400071a4:	b1 2d 20 04 	sll  %l4, 4, %i0                               
  for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
  {                                                                   
    char     name[] = RTEMS_FLASHDISK_DEVICE_BASE_NAME "a";           
    dev_t    dev = rtems_filesystem_make_dev_t (major, minor);        
    uint32_t device;                                                  
    uint32_t blocks = 0;                                              
400071a8:	b2 10 20 00 	clr  %i1                                       
 * @param major Flash disk major device number.                       
 * @param minor Minor device number, not applicable.                  
 * @param arg Initialization argument, not applicable.                
 */                                                                   
rtems_device_driver                                                   
rtems_fdisk_initialize (rtems_device_major_number major,              
400071ac:	b0 26 00 01 	sub  %i0, %g1, %i0                             
400071b0:	b0 06 80 18 	add  %i2, %i0, %i0                             
rtems_fdisk_blocks_in_device (const rtems_fdisk_device_desc* dd,      
                              uint32_t                       page_size)
{                                                                     
  uint32_t count = 0;                                                 
  uint32_t s;                                                         
  for (s = 0; s < dd->segment_count; s++)                             
400071b4:	c4 06 80 00 	ld  [ %i2 ], %g2                               
400071b8:	80 a0 a0 00 	cmp  %g2, 0                                    
400071bc:	02 80 00 93 	be  40007408 <rtems_fdisk_initialize+0x39c>    <== NEVER TAKEN
400071c0:	87 28 a0 02 	sll  %g2, 2, %g3                               
400071c4:	ea 06 a0 04 	ld  [ %i2 + 4 ], %l5                           
 * @param major Flash disk major device number.                       
 * @param minor Minor device number, not applicable.                  
 * @param arg Initialization argument, not applicable.                
 */                                                                   
rtems_device_driver                                                   
rtems_fdisk_initialize (rtems_device_major_number major,              
400071c8:	b9 28 a0 04 	sll  %g2, 4, %i4                               
 */                                                                   
static uint32_t                                                       
rtems_fdisk_blocks_in_device (const rtems_fdisk_device_desc* dd,      
                              uint32_t                       page_size)
{                                                                     
  uint32_t count = 0;                                                 
400071cc:	ae 10 20 00 	clr  %l7                                       
 * @param major Flash disk major device number.                       
 * @param minor Minor device number, not applicable.                  
 * @param arg Initialization argument, not applicable.                
 */                                                                   
rtems_device_driver                                                   
rtems_fdisk_initialize (rtems_device_major_number major,              
400071d0:	b8 27 00 03 	sub  %i4, %g3, %i4                             
400071d4:	b8 05 40 1c 	add  %l5, %i4, %i4                             
 */                                                                   
static uint32_t                                                       
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,     
                              uint32_t                        page_size)
{                                                                     
  return sd->size / page_size;                                        
400071d8:	d0 05 60 08 	ld  [ %l5 + 8 ], %o0                           
400071dc:	7f ff ed 31 	call  400026a0 <.udiv>                         
400071e0:	92 10 00 1d 	mov  %i5, %o1                                  
rtems_fdisk_page_desc_pages (const rtems_fdisk_segment_desc* sd,      
                             uint32_t                        page_size)
{                                                                     
  uint32_t pages = rtems_fdisk_pages_in_segment (sd, page_size);      
  uint32_t bytes = pages * sizeof (rtems_fdisk_page_desc);            
  return ((bytes - 1) / page_size) + 1;                               
400071e4:	92 10 00 1d 	mov  %i5, %o1                                  
400071e8:	ac 02 3f ff 	add  %o0, -1, %l6                              
static uint32_t                                                       
rtems_fdisk_page_desc_pages (const rtems_fdisk_segment_desc* sd,      
                             uint32_t                        page_size)
{                                                                     
  uint32_t pages = rtems_fdisk_pages_in_segment (sd, page_size);      
  uint32_t bytes = pages * sizeof (rtems_fdisk_page_desc);            
400071ec:	91 2a 20 03 	sll  %o0, 3, %o0                               
  return ((bytes - 1) / page_size) + 1;                               
400071f0:	7f ff ed 2c 	call  400026a0 <.udiv>                         
400071f4:	90 02 3f ff 	add  %o0, -1, %o0                              
  for (s = 0; s < dd->segment_count; s++)                             
  {                                                                   
    const rtems_fdisk_segment_desc* sd = &dd->segments[s];            
    count +=                                                          
      (rtems_fdisk_pages_in_segment (sd, page_size) -                 
       rtems_fdisk_page_desc_pages (sd, page_size)) * sd->count;      
400071f8:	d2 15 40 00 	lduh  [ %l5 ], %o1                             
400071fc:	7f ff ec ef 	call  400025b8 <.umul>                         
40007200:	90 25 80 08 	sub  %l6, %o0, %o0                             
40007204:	aa 05 60 0c 	add  %l5, 0xc, %l5                             
rtems_fdisk_blocks_in_device (const rtems_fdisk_device_desc* dd,      
                              uint32_t                       page_size)
{                                                                     
  uint32_t count = 0;                                                 
  uint32_t s;                                                         
  for (s = 0; s < dd->segment_count; s++)                             
40007208:	80 a5 40 1c 	cmp  %l5, %i4                                  
4000720c:	12 bf ff f3 	bne  400071d8 <rtems_fdisk_initialize+0x16c>   <== NEVER TAKEN
40007210:	ae 05 c0 08 	add  %l7, %o0, %l7                             
40007214:	b4 06 a0 0c 	add  %i2, 0xc, %i2                             
    fd->avail_compact_segs = c->avail_compact_segs;                   
    fd->block_size         = c->block_size;                           
    fd->unavail_blocks     = c->unavail_blocks;                       
    fd->info_level         = c->info_level;                           
                                                                      
    for (device = 0; device < c->device_count; device++)              
40007218:	80 a6 80 18 	cmp  %i2, %i0                                  
4000721c:	12 bf ff e6 	bne  400071b4 <rtems_fdisk_initialize+0x148>   <== NEVER TAKEN
40007220:	b2 06 40 17 	add  %i1, %l7, %i1                             
                                              c->block_size);         
                                                                      
    /*                                                                
     * One copy buffer of a page size.                                
     */                                                               
    fd->copy_buffer = malloc (c->block_size);                         
40007224:	40 00 04 e6 	call  400085bc <malloc>                        
40007228:	90 10 00 1d 	mov  %i5, %o0                                  
    if (!fd->copy_buffer)                                             
4000722c:	80 a2 20 00 	cmp  %o0, 0                                    
40007230:	02 80 00 af 	be  400074ec <rtems_fdisk_initialize+0x480>    <== NEVER TAKEN
40007234:	d0 26 e0 68 	st  %o0, [ %i3 + 0x68 ]                        
      return RTEMS_NO_MEMORY;                                         
                                                                      
    fd->blocks = calloc (blocks, sizeof (rtems_fdisk_block_ctl));     
40007238:	90 10 00 19 	mov  %i1, %o0                                  
4000723c:	40 00 02 e0 	call  40007dbc <calloc>                        
40007240:	92 10 20 08 	mov  8, %o1                                    
    if (!fd->blocks)                                                  
40007244:	80 a2 20 00 	cmp  %o0, 0                                    
40007248:	02 80 00 a9 	be  400074ec <rtems_fdisk_initialize+0x480>    <== NEVER TAKEN
4000724c:	d0 26 e0 18 	st  %o0, [ %i3 + 0x18 ]                        
      return RTEMS_NO_MEMORY;                                         
                                                                      
    fd->block_count = blocks;                                         
40007250:	f2 26 e0 1c 	st  %i1, [ %i3 + 0x1c ]                        
                                                                      
    fd->devices = calloc (c->device_count, sizeof (rtems_fdisk_device_ctl));
40007254:	90 10 00 14 	mov  %l4, %o0                                  
40007258:	40 00 02 d9 	call  40007dbc <calloc>                        
4000725c:	92 10 20 0c 	mov  0xc, %o1                                  
    if (!fd->devices)                                                 
40007260:	80 a2 20 00 	cmp  %o0, 0                                    
40007264:	02 80 00 a2 	be  400074ec <rtems_fdisk_initialize+0x480>    <== NEVER TAKEN
40007268:	d0 26 e0 2c 	st  %o0, [ %i3 + 0x2c ]                        
      return RTEMS_NO_MEMORY;                                         
                                                                      
    sc = rtems_semaphore_create (rtems_build_name ('F', 'D', 'S', 'K'), 1,
4000726c:	03 10 00 d3 	sethi  %hi(0x40034c00), %g1                    
40007270:	d0 00 62 c8 	ld  [ %g1 + 0x2c8 ], %o0	! 40034ec8 <__FUNCTION__.6193+0xe00>
40007274:	92 10 20 01 	mov  1, %o1                                    
40007278:	94 10 20 54 	mov  0x54, %o2                                 
4000727c:	96 10 20 00 	clr  %o3                                       
40007280:	40 00 15 f2 	call  4000ca48 <rtems_semaphore_create>        
40007284:	98 06 e0 64 	add  %i3, 0x64, %o4                            
                                 RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE |
                                 RTEMS_INHERIT_PRIORITY, 0, &fd->lock);
    if (sc != RTEMS_SUCCESSFUL)                                       
40007288:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4000728c:	12 80 00 8d 	bne  400074c0 <rtems_fdisk_initialize+0x454>   <== NEVER TAKEN
40007290:	b4 07 bf f0 	add  %fp, -16, %i2                             
      free (fd->blocks);                                              
      free (fd->devices);                                             
      return sc;                                                      
    }                                                                 
                                                                      
    sc = rtems_disk_create_phys(dev, c->block_size,                   
40007294:	d6 06 e0 20 	ld  [ %i3 + 0x20 ], %o3                        
40007298:	d4 04 00 00 	ld  [ %l0 ], %o2                               
4000729c:	90 10 00 12 	mov  %l2, %o0                                  
400072a0:	f4 23 a0 5c 	st  %i2, [ %sp + 0x5c ]                        
400072a4:	92 10 00 11 	mov  %l1, %o1                                  
400072a8:	96 26 40 0b 	sub  %i1, %o3, %o3                             
400072ac:	19 10 00 17 	sethi  %hi(0x40005c00), %o4                    
400072b0:	9a 10 20 00 	clr  %o5                                       
400072b4:	7f ff f3 d4 	call  40004204 <rtems_disk_create_phys>        
400072b8:	98 13 20 54 	or  %o4, 0x54, %o4                             
                                blocks - fd->unavail_blocks,          
                                rtems_fdisk_ioctl, NULL, name);       
    if (sc != RTEMS_SUCCESSFUL)                                       
400072bc:	b0 92 20 00 	orcc  %o0, 0, %i0                              
400072c0:	12 80 00 70 	bne  40007480 <rtems_fdisk_initialize+0x414>   <== NEVER TAKEN
400072c4:	01 00 00 00 	nop                                            
      free (fd->devices);                                             
      rtems_fdisk_error ("disk create phy failed");                   
      return sc;                                                      
    }                                                                 
                                                                      
    for (device = 0; device < c->device_count; device++)              
400072c8:	f0 04 20 04 	ld  [ %l0 + 4 ], %i0                           
400072cc:	80 a6 20 00 	cmp  %i0, 0                                    
400072d0:	22 80 00 3b 	be,a   400073bc <rtems_fdisk_initialize+0x350> <== NEVER TAKEN
400072d4:	f0 26 e0 30 	st  %i0, [ %i3 + 0x30 ]                        <== NOT EXECUTED
400072d8:	f4 04 20 08 	ld  [ %l0 + 8 ], %i2                           
400072dc:	f2 06 e0 2c 	ld  [ %i3 + 0x2c ], %i1                        
400072e0:	ba 10 20 00 	clr  %i5                                       
static uint32_t                                                       
rtems_fdisk_count_segments (const rtems_fdisk_device_desc* dd)        
{                                                                     
  uint32_t count = 0;                                                 
  uint32_t segment;                                                   
  for (segment = 0; segment < dd->segment_count; segment++)           
400072e4:	c4 06 80 00 	ld  [ %i2 ], %g2                               
400072e8:	80 a0 a0 00 	cmp  %g2, 0                                    
400072ec:	02 80 00 5d 	be  40007460 <rtems_fdisk_initialize+0x3f4>    <== NEVER TAKEN
400072f0:	a9 28 a0 02 	sll  %g2, 2, %l4                               
400072f4:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1                           
 * Count the segments for a device.                                   
 */                                                                   
static uint32_t                                                       
rtems_fdisk_count_segments (const rtems_fdisk_device_desc* dd)        
{                                                                     
  uint32_t count = 0;                                                 
400072f8:	b8 10 20 00 	clr  %i4                                       
 * @param major Flash disk major device number.                       
 * @param minor Minor device number, not applicable.                  
 * @param arg Initialization argument, not applicable.                
 */                                                                   
rtems_device_driver                                                   
rtems_fdisk_initialize (rtems_device_major_number major,              
400072fc:	85 28 a0 04 	sll  %g2, 4, %g2                               
40007300:	88 20 80 14 	sub  %g2, %l4, %g4                             
40007304:	88 00 40 04 	add  %g1, %g4, %g4                             
rtems_fdisk_count_segments (const rtems_fdisk_device_desc* dd)        
{                                                                     
  uint32_t count = 0;                                                 
  uint32_t segment;                                                   
  for (segment = 0; segment < dd->segment_count; segment++)           
    count += dd->segments[segment].count;                             
40007308:	c6 10 40 00 	lduh  [ %g1 ], %g3                             
4000730c:	82 00 60 0c 	add  %g1, 0xc, %g1                             
static uint32_t                                                       
rtems_fdisk_count_segments (const rtems_fdisk_device_desc* dd)        
{                                                                     
  uint32_t count = 0;                                                 
  uint32_t segment;                                                   
  for (segment = 0; segment < dd->segment_count; segment++)           
40007310:	80 a0 40 04 	cmp  %g1, %g4                                  
40007314:	12 bf ff fd 	bne  40007308 <rtems_fdisk_initialize+0x29c>   <== NEVER TAKEN
40007318:	b8 07 00 03 	add  %i4, %g3, %i4                             
      uint32_t                 segment_count;                         
      uint32_t                 segment;                               
                                                                      
      segment_count = rtems_fdisk_count_segments (&c->devices[device]);
                                                                      
      fd->devices[device].segments = calloc (segment_count,           
4000731c:	c4 27 bf ec 	st  %g2, [ %fp + -20 ]                         
40007320:	90 10 00 1c 	mov  %i4, %o0                                  
40007324:	40 00 02 a6 	call  40007dbc <calloc>                        
40007328:	92 10 20 30 	mov  0x30, %o1                                 
4000732c:	d0 26 40 00 	st  %o0, [ %i1 ]                               
                                             sizeof (rtems_fdisk_segment_ctl));
      if (!fd->devices[device].segments)                              
40007330:	80 a2 20 00 	cmp  %o0, 0                                    
40007334:	02 80 00 3d 	be  40007428 <rtems_fdisk_initialize+0x3bc>    <== NEVER TAKEN
40007338:	c4 07 bf ec 	ld  [ %fp + -20 ], %g2                         
4000733c:	c6 06 a0 04 	ld  [ %i2 + 4 ], %g3                           
 * @param major Flash disk major device number.                       
 * @param minor Minor device number, not applicable.                  
 * @param arg Initialization argument, not applicable.                
 */                                                                   
rtems_device_driver                                                   
rtems_fdisk_initialize (rtems_device_major_number major,              
40007340:	84 20 80 14 	sub  %g2, %l4, %g2                             
40007344:	9e 00 c0 02 	add  %g3, %g2, %o7                             
        const rtems_fdisk_segment_desc* sd;                           
        uint32_t                        seg_segment;                  
                                                                      
        sd = &c->devices[device].segments[segment];                   
                                                                      
        for (seg_segment = 0; seg_segment < sd->count; seg_segment++, sc++)
40007348:	c8 10 c0 00 	lduh  [ %g3 ], %g4                             
4000734c:	80 a1 20 00 	cmp  %g4, 0                                    
40007350:	02 80 00 0f 	be  4000738c <rtems_fdisk_initialize+0x320>    <== NEVER TAKEN
40007354:	82 10 00 08 	mov  %o0, %g1                                  
40007358:	84 10 20 00 	clr  %g2                                       
        {                                                             
          sc->descriptor = sd;                                        
          sc->device     = device;                                    
          sc->segment    = seg_segment;                               
4000735c:	c4 20 60 0c 	st  %g2, [ %g1 + 0xc ]                         
                                                                      
        sd = &c->devices[device].segments[segment];                   
                                                                      
        for (seg_segment = 0; seg_segment < sd->count; seg_segment++, sc++)
        {                                                             
          sc->descriptor = sd;                                        
40007360:	c6 20 60 04 	st  %g3, [ %g1 + 4 ]                           
          sc->device     = device;                                    
40007364:	fa 20 60 08 	st  %i5, [ %g1 + 8 ]                           
          sc->segment    = seg_segment;                               
          sc->erased     = 0;                                         
40007368:	c0 20 60 2c 	clr  [ %g1 + 0x2c ]                            
        const rtems_fdisk_segment_desc* sd;                           
        uint32_t                        seg_segment;                  
                                                                      
        sd = &c->devices[device].segments[segment];                   
                                                                      
        for (seg_segment = 0; seg_segment < sd->count; seg_segment++, sc++)
4000736c:	84 00 a0 01 	inc  %g2                                       
40007370:	80 a0 80 04 	cmp  %g2, %g4                                  
40007374:	0a bf ff fa 	bcs  4000735c <rtems_fdisk_initialize+0x2f0>   
40007378:	82 00 60 30 	add  %g1, 0x30, %g1                            
 * @param major Flash disk major device number.                       
 * @param minor Minor device number, not applicable.                  
 * @param arg Initialization argument, not applicable.                
 */                                                                   
rtems_device_driver                                                   
rtems_fdisk_initialize (rtems_device_major_number major,              
4000737c:	83 29 20 04 	sll  %g4, 4, %g1                               
40007380:	89 29 20 06 	sll  %g4, 6, %g4                               
40007384:	88 21 00 01 	sub  %g4, %g1, %g4                             
40007388:	90 02 00 04 	add  %o0, %g4, %o0                             
4000738c:	86 00 e0 0c 	add  %g3, 0xc, %g3                             
        return RTEMS_NO_MEMORY;                                       
      }                                                               
                                                                      
      sc = fd->devices[device].segments;                              
                                                                      
      for (segment = 0; segment < c->devices[device].segment_count; segment++)
40007390:	80 a0 c0 0f 	cmp  %g3, %o7                                  
40007394:	32 bf ff ee 	bne,a   4000734c <rtems_fdisk_initialize+0x2e0><== NEVER TAKEN
40007398:	c8 10 c0 00 	lduh  [ %g3 ], %g4                             <== NOT EXECUTED
          sc->erased     = 0;                                         
        }                                                             
      }                                                               
                                                                      
      fd->devices[device].segment_count = segment_count;              
      fd->devices[device].descriptor    = &c->devices[device];        
4000739c:	f4 26 60 08 	st  %i2, [ %i1 + 8 ]                           
          sc->segment    = seg_segment;                               
          sc->erased     = 0;                                         
        }                                                             
      }                                                               
                                                                      
      fd->devices[device].segment_count = segment_count;              
400073a0:	f8 26 60 04 	st  %i4, [ %i1 + 4 ]                           
      free (fd->devices);                                             
      rtems_fdisk_error ("disk create phy failed");                   
      return sc;                                                      
    }                                                                 
                                                                      
    for (device = 0; device < c->device_count; device++)              
400073a4:	ba 07 60 01 	inc  %i5                                       
400073a8:	b4 06 a0 0c 	add  %i2, 0xc, %i2                             
400073ac:	80 a7 40 18 	cmp  %i5, %i0                                  
400073b0:	12 bf ff cd 	bne  400072e4 <rtems_fdisk_initialize+0x278>   <== NEVER TAKEN
400073b4:	b2 06 60 0c 	add  %i1, 0xc, %i1                             
                                                                      
      fd->devices[device].segment_count = segment_count;              
      fd->devices[device].descriptor    = &c->devices[device];        
    }                                                                 
                                                                      
    fd->device_count = c->device_count;                               
400073b8:	f0 26 e0 30 	st  %i0, [ %i3 + 0x30 ]                        
                                                                      
    ret = rtems_fdisk_recover_block_mappings (fd);                    
400073bc:	7f ff f9 31 	call  40005880 <rtems_fdisk_recover_block_mappings>
400073c0:	90 10 00 1b 	mov  %i3, %o0                                  
    if (ret)                                                          
400073c4:	b0 92 20 00 	orcc  %o0, 0, %i0                              
400073c8:	12 80 00 63 	bne  40007554 <rtems_fdisk_initialize+0x4e8>   <== NEVER TAKEN
400073cc:	92 10 00 11 	mov  %l1, %o1                                  
      rtems_fdisk_error ("recovery of disk failed: %s (%d)",          
                         strerror (ret), ret);                        
      return ret;                                                     
    }                                                                 
                                                                      
    ret = rtems_fdisk_compact (fd);                                   
400073d0:	7f ff f8 76 	call  400055a8 <rtems_fdisk_compact>           
400073d4:	90 10 00 1b 	mov  %i3, %o0                                  
    if (ret)                                                          
400073d8:	b0 92 20 00 	orcc  %o0, 0, %i0                              
400073dc:	12 80 00 4a 	bne  40007504 <rtems_fdisk_initialize+0x498>   <== NEVER TAKEN
400073e0:	a0 04 20 20 	add  %l0, 0x20, %l0                            
                             sizeof (rtems_flashdisk));               
                                                                      
  if (!rtems_flashdisks)                                              
    return RTEMS_NO_MEMORY;                                           
                                                                      
  for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
400073e4:	37 10 00 e4 	sethi  %hi(0x40039000), %i3                    
400073e8:	fa 06 e1 bc 	ld  [ %i3 + 0x1bc ], %i5	! 400391bc <rtems_flashdisk_configuration_size>
400073ec:	a2 04 60 01 	inc  %l1                                       
400073f0:	80 a7 40 11 	cmp  %i5, %l1                                  
400073f4:	08 80 00 40 	bleu  400074f4 <rtems_fdisk_initialize+0x488>  <== ALWAYS TAKEN
400073f8:	a6 04 e0 74 	add  %l3, 0x74, %l3                            
400073fc:	03 10 01 26 	sethi  %hi(0x40049800), %g1                    <== NOT EXECUTED
40007400:	10 bf ff 4c 	b  40007130 <rtems_fdisk_initialize+0xc4>      <== NOT EXECUTED
40007404:	d0 00 60 d8 	ld  [ %g1 + 0xd8 ], %o0	! 400498d8 <rtems_flashdisks><== NOT EXECUTED
 */                                                                   
static uint32_t                                                       
rtems_fdisk_blocks_in_device (const rtems_fdisk_device_desc* dd,      
                              uint32_t                       page_size)
{                                                                     
  uint32_t count = 0;                                                 
40007408:	ae 10 20 00 	clr  %l7                                       <== NOT EXECUTED
4000740c:	b4 06 a0 0c 	add  %i2, 0xc, %i2                             <== NOT EXECUTED
    fd->avail_compact_segs = c->avail_compact_segs;                   
    fd->block_size         = c->block_size;                           
    fd->unavail_blocks     = c->unavail_blocks;                       
    fd->info_level         = c->info_level;                           
                                                                      
    for (device = 0; device < c->device_count; device++)              
40007410:	80 a6 80 18 	cmp  %i2, %i0                                  <== NOT EXECUTED
40007414:	12 bf ff 68 	bne  400071b4 <rtems_fdisk_initialize+0x148>   <== NOT EXECUTED
40007418:	b2 06 40 17 	add  %i1, %l7, %i1                             <== NOT EXECUTED
4000741c:	30 bf ff 82 	b,a   40007224 <rtems_fdisk_initialize+0x1b8>  <== NOT EXECUTED
  for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
  {                                                                   
    char     name[] = RTEMS_FLASHDISK_DEVICE_BASE_NAME "a";           
    dev_t    dev = rtems_filesystem_make_dev_t (major, minor);        
    uint32_t device;                                                  
    uint32_t blocks = 0;                                              
40007420:	10 bf ff 81 	b  40007224 <rtems_fdisk_initialize+0x1b8>     <== NOT EXECUTED
40007424:	b2 10 20 00 	clr  %i1                                       <== NOT EXECUTED
                                                                      
      fd->devices[device].segments = calloc (segment_count,           
                                             sizeof (rtems_fdisk_segment_ctl));
      if (!fd->devices[device].segments)                              
      {                                                               
        rtems_disk_delete (dev);                                      
40007428:	92 10 00 11 	mov  %l1, %o1                                  <== NOT EXECUTED
4000742c:	7f ff f2 c5 	call  40003f40 <rtems_disk_delete>             <== NOT EXECUTED
40007430:	90 10 00 12 	mov  %l2, %o0                                  <== NOT EXECUTED
        rtems_semaphore_delete (fd->lock);                            
40007434:	d0 06 e0 64 	ld  [ %i3 + 0x64 ], %o0                        <== NOT EXECUTED
40007438:	40 00 15 f5 	call  4000cc0c <rtems_semaphore_delete>        <== NOT EXECUTED
4000743c:	b0 10 20 1a 	mov  0x1a, %i0                                 <== NOT EXECUTED
        free (fd->copy_buffer);                                       
40007440:	40 00 02 c2 	call  40007f48 <free>                          <== NOT EXECUTED
40007444:	d0 06 e0 68 	ld  [ %i3 + 0x68 ], %o0                        <== NOT EXECUTED
        free (fd->blocks);                                            
40007448:	40 00 02 c0 	call  40007f48 <free>                          <== NOT EXECUTED
4000744c:	d0 06 e0 18 	ld  [ %i3 + 0x18 ], %o0                        <== NOT EXECUTED
        free (fd->devices);                                           
40007450:	40 00 02 be 	call  40007f48 <free>                          <== NOT EXECUTED
40007454:	d0 06 e0 2c 	ld  [ %i3 + 0x2c ], %o0                        <== NOT EXECUTED
40007458:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000745c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
      uint32_t                 segment_count;                         
      uint32_t                 segment;                               
                                                                      
      segment_count = rtems_fdisk_count_segments (&c->devices[device]);
                                                                      
      fd->devices[device].segments = calloc (segment_count,           
40007460:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
40007464:	40 00 02 56 	call  40007dbc <calloc>                        <== NOT EXECUTED
40007468:	92 10 20 30 	mov  0x30, %o1                                 <== NOT EXECUTED
                                             sizeof (rtems_fdisk_segment_ctl));
      if (!fd->devices[device].segments)                              
4000746c:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40007470:	02 bf ff ee 	be  40007428 <rtems_fdisk_initialize+0x3bc>    <== NOT EXECUTED
40007474:	d0 26 40 00 	st  %o0, [ %i1 ]                               <== NOT EXECUTED
 * Count the segments for a device.                                   
 */                                                                   
static uint32_t                                                       
rtems_fdisk_count_segments (const rtems_fdisk_device_desc* dd)        
{                                                                     
  uint32_t count = 0;                                                 
40007478:	10 bf ff c9 	b  4000739c <rtems_fdisk_initialize+0x330>     <== NOT EXECUTED
4000747c:	b8 10 20 00 	clr  %i4                                       <== NOT EXECUTED
    sc = rtems_disk_create_phys(dev, c->block_size,                   
                                blocks - fd->unavail_blocks,          
                                rtems_fdisk_ioctl, NULL, name);       
    if (sc != RTEMS_SUCCESSFUL)                                       
    {                                                                 
      rtems_semaphore_delete (fd->lock);                              
40007480:	40 00 15 e3 	call  4000cc0c <rtems_semaphore_delete>        <== NOT EXECUTED
40007484:	d0 06 e0 64 	ld  [ %i3 + 0x64 ], %o0                        <== NOT EXECUTED
      rtems_disk_delete (dev);                                        
40007488:	92 10 00 11 	mov  %l1, %o1                                  <== NOT EXECUTED
4000748c:	7f ff f2 ad 	call  40003f40 <rtems_disk_delete>             <== NOT EXECUTED
40007490:	90 10 00 12 	mov  %l2, %o0                                  <== NOT EXECUTED
      free (fd->copy_buffer);                                         
40007494:	40 00 02 ad 	call  40007f48 <free>                          <== NOT EXECUTED
40007498:	d0 06 e0 68 	ld  [ %i3 + 0x68 ], %o0                        <== NOT EXECUTED
      free (fd->blocks);                                              
4000749c:	40 00 02 ab 	call  40007f48 <free>                          <== NOT EXECUTED
400074a0:	d0 06 e0 18 	ld  [ %i3 + 0x18 ], %o0                        <== NOT EXECUTED
      free (fd->devices);                                             
400074a4:	40 00 02 a9 	call  40007f48 <free>                          <== NOT EXECUTED
400074a8:	d0 06 e0 2c 	ld  [ %i3 + 0x2c ], %o0                        <== NOT EXECUTED
      rtems_fdisk_error ("disk create phy failed");                   
400074ac:	11 10 00 d3 	sethi  %hi(0x40034c00), %o0                    <== NOT EXECUTED
400074b0:	7f ff f5 ca 	call  40004bd8 <rtems_fdisk_error>             <== NOT EXECUTED
400074b4:	90 12 22 60 	or  %o0, 0x260, %o0	! 40034e60 <__FUNCTION__.6193+0xd98><== NOT EXECUTED
400074b8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400074bc:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    sc = rtems_semaphore_create (rtems_build_name ('F', 'D', 'S', 'K'), 1,
                                 RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE |
                                 RTEMS_INHERIT_PRIORITY, 0, &fd->lock);
    if (sc != RTEMS_SUCCESSFUL)                                       
    {                                                                 
      rtems_fdisk_error ("disk lock create failed");                  
400074c0:	11 10 00 d3 	sethi  %hi(0x40034c00), %o0                    <== NOT EXECUTED
400074c4:	7f ff f5 c5 	call  40004bd8 <rtems_fdisk_error>             <== NOT EXECUTED
400074c8:	90 12 22 48 	or  %o0, 0x248, %o0	! 40034e48 <__FUNCTION__.6193+0xd80><== NOT EXECUTED
      free (fd->copy_buffer);                                         
400074cc:	40 00 02 9f 	call  40007f48 <free>                          <== NOT EXECUTED
400074d0:	d0 06 e0 68 	ld  [ %i3 + 0x68 ], %o0                        <== NOT EXECUTED
      free (fd->blocks);                                              
400074d4:	40 00 02 9d 	call  40007f48 <free>                          <== NOT EXECUTED
400074d8:	d0 06 e0 18 	ld  [ %i3 + 0x18 ], %o0                        <== NOT EXECUTED
      free (fd->devices);                                             
400074dc:	40 00 02 9b 	call  40007f48 <free>                          <== NOT EXECUTED
400074e0:	d0 06 e0 2c 	ld  [ %i3 + 0x2c ], %o0                        <== NOT EXECUTED
400074e4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400074e8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
    fd->block_count = blocks;                                         
                                                                      
    fd->devices = calloc (c->device_count, sizeof (rtems_fdisk_device_ctl));
    if (!fd->devices)                                                 
      return RTEMS_NO_MEMORY;                                         
400074ec:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400074f0:	91 e8 20 1a 	restore  %g0, 0x1a, %o0                        <== NOT EXECUTED
                         strerror (ret), ret);                        
      return ret;                                                     
    }                                                                 
  }                                                                   
                                                                      
  rtems_flashdisk_count = rtems_flashdisk_configuration_size;         
400074f4:	03 10 01 26 	sethi  %hi(0x40049800), %g1                    
400074f8:	fa 20 60 dc 	st  %i5, [ %g1 + 0xdc ]	! 400498dc <rtems_flashdisk_count>
                                                                      
  return RTEMS_SUCCESSFUL;                                            
400074fc:	81 c7 e0 08 	ret                                            
40007500:	91 e8 20 00 	restore  %g0, 0, %o0                           
    }                                                                 
                                                                      
    ret = rtems_fdisk_compact (fd);                                   
    if (ret)                                                          
    {                                                                 
      rtems_disk_delete (dev);                                        
40007504:	92 10 00 11 	mov  %l1, %o1                                  <== NOT EXECUTED
40007508:	7f ff f2 8e 	call  40003f40 <rtems_disk_delete>             <== NOT EXECUTED
4000750c:	90 10 00 12 	mov  %l2, %o0                                  <== NOT EXECUTED
      rtems_semaphore_delete (fd->lock);                              
40007510:	40 00 15 bf 	call  4000cc0c <rtems_semaphore_delete>        <== NOT EXECUTED
40007514:	d0 06 e0 64 	ld  [ %i3 + 0x64 ], %o0                        <== NOT EXECUTED
      free (fd->copy_buffer);                                         
40007518:	40 00 02 8c 	call  40007f48 <free>                          <== NOT EXECUTED
4000751c:	d0 06 e0 68 	ld  [ %i3 + 0x68 ], %o0                        <== NOT EXECUTED
      free (fd->blocks);                                              
40007520:	40 00 02 8a 	call  40007f48 <free>                          <== NOT EXECUTED
40007524:	d0 06 e0 18 	ld  [ %i3 + 0x18 ], %o0                        <== NOT EXECUTED
      free (fd->devices);                                             
40007528:	40 00 02 88 	call  40007f48 <free>                          <== NOT EXECUTED
4000752c:	d0 06 e0 2c 	ld  [ %i3 + 0x2c ], %o0                        <== NOT EXECUTED
      rtems_fdisk_error ("compacting of disk failed: %s (%d)",        
40007530:	40 00 76 dd 	call  400250a4 <strerror>                      <== NOT EXECUTED
40007534:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40007538:	94 10 00 18 	mov  %i0, %o2                                  <== NOT EXECUTED
4000753c:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40007540:	11 10 00 d3 	sethi  %hi(0x40034c00), %o0                    <== NOT EXECUTED
40007544:	7f ff f5 a5 	call  40004bd8 <rtems_fdisk_error>             <== NOT EXECUTED
40007548:	90 12 22 a0 	or  %o0, 0x2a0, %o0	! 40034ea0 <__FUNCTION__.6193+0xdd8><== NOT EXECUTED
4000754c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40007550:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    fd->device_count = c->device_count;                               
                                                                      
    ret = rtems_fdisk_recover_block_mappings (fd);                    
    if (ret)                                                          
    {                                                                 
      rtems_disk_delete (dev);                                        
40007554:	7f ff f2 7b 	call  40003f40 <rtems_disk_delete>             <== NOT EXECUTED
40007558:	90 10 00 12 	mov  %l2, %o0                                  <== NOT EXECUTED
      rtems_semaphore_delete (fd->lock);                              
4000755c:	40 00 15 ac 	call  4000cc0c <rtems_semaphore_delete>        <== NOT EXECUTED
40007560:	d0 06 e0 64 	ld  [ %i3 + 0x64 ], %o0                        <== NOT EXECUTED
      free (fd->copy_buffer);                                         
40007564:	40 00 02 79 	call  40007f48 <free>                          <== NOT EXECUTED
40007568:	d0 06 e0 68 	ld  [ %i3 + 0x68 ], %o0                        <== NOT EXECUTED
      free (fd->blocks);                                              
4000756c:	40 00 02 77 	call  40007f48 <free>                          <== NOT EXECUTED
40007570:	d0 06 e0 18 	ld  [ %i3 + 0x18 ], %o0                        <== NOT EXECUTED
      free (fd->devices);                                             
40007574:	40 00 02 75 	call  40007f48 <free>                          <== NOT EXECUTED
40007578:	d0 06 e0 2c 	ld  [ %i3 + 0x2c ], %o0                        <== NOT EXECUTED
      rtems_fdisk_error ("recovery of disk failed: %s (%d)",          
4000757c:	40 00 76 ca 	call  400250a4 <strerror>                      <== NOT EXECUTED
40007580:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40007584:	94 10 00 18 	mov  %i0, %o2                                  <== NOT EXECUTED
40007588:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
4000758c:	11 10 00 d3 	sethi  %hi(0x40034c00), %o0                    <== NOT EXECUTED
40007590:	7f ff f5 92 	call  40004bd8 <rtems_fdisk_error>             <== NOT EXECUTED
40007594:	90 12 22 78 	or  %o0, 0x278, %o0	! 40034e78 <__FUNCTION__.6193+0xdb0><== NOT EXECUTED
40007598:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000759c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40005c54 <rtems_fdisk_ioctl>: * @param argp IOCTL argument. * @retval The IOCTL return value */ static int rtems_fdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp) {
40005c54:	9d e3 bf 48 	save  %sp, -184, %sp                           
  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;                                       
                                                                      
  errno = 0;                                                          
40005c58:	40 00 73 38 	call  40022938 <__errno>                       
40005c5c:	fa 06 20 04 	ld  [ %i0 + 4 ], %i5                           
                                                                      
  sc = rtems_semaphore_obtain (rtems_flashdisks[minor].lock, RTEMS_WAIT, 0);
40005c60:	21 10 01 26 	sethi  %hi(0x40049800), %l0                    
40005c64:	c2 04 20 d8 	ld  [ %l0 + 0xd8 ], %g1	! 400498d8 <rtems_flashdisks>
  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;                                       
                                                                      
  errno = 0;                                                          
40005c68:	c0 22 00 00 	clr  [ %o0 ]                                   
                                                                      
  sc = rtems_semaphore_obtain (rtems_flashdisks[minor].lock, RTEMS_WAIT, 0);
40005c6c:	87 2f 60 05 	sll  %i5, 5, %g3                               
40005c70:	85 2f 60 02 	sll  %i5, 2, %g2                               
40005c74:	84 20 c0 02 	sub  %g3, %g2, %g2                             
40005c78:	84 00 80 1d 	add  %g2, %i5, %g2                             
40005c7c:	ab 28 a0 02 	sll  %g2, 2, %l5                               
40005c80:	82 00 40 15 	add  %g1, %l5, %g1                             
40005c84:	d0 00 60 64 	ld  [ %g1 + 0x64 ], %o0                        
40005c88:	92 10 20 00 	clr  %o1                                       
40005c8c:	40 00 1c 17 	call  4000cce8 <rtems_semaphore_obtain>        
40005c90:	94 10 20 00 	clr  %o2                                       
  if (sc != RTEMS_SUCCESSFUL)                                         
40005c94:	80 a2 20 00 	cmp  %o0, 0                                    
40005c98:	12 80 00 36 	bne  40005d70 <rtems_fdisk_ioctl+0x11c>        <== NEVER TAKEN
40005c9c:	01 00 00 00 	nop                                            
    errno = EIO;                                                      
  else                                                                
  {                                                                   
    errno = 0;                                                        
40005ca0:	40 00 73 26 	call  40022938 <__errno>                       
40005ca4:	01 00 00 00 	nop                                            
    switch (req)                                                      
40005ca8:	03 08 00 10 	sethi  %hi(0x20004000), %g1                    
40005cac:	84 10 62 83 	or  %g1, 0x283, %g2	! 20004283 <RAM_SIZE+0x1fc04283>
40005cb0:	80 a6 40 02 	cmp  %i1, %g2                                  
40005cb4:	02 80 00 5b 	be  40005e20 <rtems_fdisk_ioctl+0x1cc>         <== NEVER TAKEN
40005cb8:	c0 22 00 00 	clr  [ %o0 ]                                   
40005cbc:	80 a6 40 02 	cmp  %i1, %g2                                  
40005cc0:	38 80 00 37 	bgu,a   40005d9c <rtems_fdisk_ioctl+0x148>     
40005cc4:	82 10 62 85 	or  %g1, 0x285, %g1                            
40005cc8:	84 10 62 81 	or  %g1, 0x281, %g2                            
40005ccc:	80 a6 40 02 	cmp  %i1, %g2                                  
40005cd0:	02 80 00 de 	be  40006048 <rtems_fdisk_ioctl+0x3f4>         <== NEVER TAKEN
40005cd4:	01 00 00 00 	nop                                            
40005cd8:	08 80 00 d0 	bleu  40006018 <rtems_fdisk_ioctl+0x3c4>       <== ALWAYS TAKEN
40005cdc:	82 10 62 80 	or  %g1, 0x280, %g1                            
      case RTEMS_FDISK_IOCTL_COMPACT:                                 
        errno = rtems_fdisk_compact (&rtems_flashdisks[minor]);       
        break;                                                        
                                                                      
      case RTEMS_FDISK_IOCTL_ERASE_USED:                              
        errno = rtems_fdisk_erase_used (&rtems_flashdisks[minor]);    
40005ce0:	40 00 73 16 	call  40022938 <__errno>                       <== NOT EXECUTED
40005ce4:	b8 10 20 00 	clr  %i4                                       <== NOT EXECUTED
40005ce8:	fa 04 20 d8 	ld  [ %l0 + 0xd8 ], %i5                        <== NOT EXECUTED
40005cec:	b6 10 00 08 	mov  %o0, %i3                                  <== NOT EXECUTED
40005cf0:	ba 07 40 15 	add  %i5, %l5, %i5                             <== NOT EXECUTED
 * Pop the head of the segment control queue.                         
 */                                                                   
static rtems_fdisk_segment_ctl*                                       
rtems_fdisk_segment_queue_pop_head (rtems_fdisk_segment_ctl_queue* queue)
{                                                                     
  if (queue->head)                                                    
40005cf4:	c2 07 60 4c 	ld  [ %i5 + 0x4c ], %g1                        <== NOT EXECUTED
40005cf8:	92 90 60 00 	orcc  %g1, 0, %o1                              <== NOT EXECUTED
40005cfc:	02 80 00 15 	be  40005d50 <rtems_fdisk_ioctl+0xfc>          <== NOT EXECUTED
40005d00:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
  {                                                                   
    rtems_fdisk_segment_ctl* sc = queue->head;                        
                                                                      
    queue->head = sc->next;                                           
40005d04:	c4 00 40 00 	ld  [ %g1 ], %g2                               <== NOT EXECUTED
    if (!queue->head)                                                 
40005d08:	80 a0 a0 00 	cmp  %g2, 0                                    <== NOT EXECUTED
40005d0c:	02 80 01 09 	be  40006130 <rtems_fdisk_ioctl+0x4dc>         <== NOT EXECUTED
40005d10:	c4 27 60 4c 	st  %g2, [ %i5 + 0x4c ]                        <== NOT EXECUTED
      queue->tail = 0;                                                
                                                                      
    queue->count--;                                                   
40005d14:	c4 07 60 54 	ld  [ %i5 + 0x54 ], %g2                        <== NOT EXECUTED
40005d18:	84 00 bf ff 	add  %g2, -1, %g2                              <== NOT EXECUTED
40005d1c:	c4 27 60 54 	st  %g2, [ %i5 + 0x54 ]                        <== NOT EXECUTED
  {                                                                   
    /*                                                                
     * The segment will either end up on the available queue or       
     * the failed queue.                                              
     */                                                               
    int ret = rtems_fdisk_erase_segment (fd, sc);                     
40005d20:	7f ff fb cd 	call  40004c54 <rtems_fdisk_erase_segment>     <== NOT EXECUTED
40005d24:	c0 20 40 00 	clr  [ %g1 ]                                   <== NOT EXECUTED
    if (ret && !latched_ret)                                          
40005d28:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40005d2c:	02 bf ff f3 	be  40005cf8 <rtems_fdisk_ioctl+0xa4>          <== NOT EXECUTED
40005d30:	c2 07 60 4c 	ld  [ %i5 + 0x4c ], %g1                        <== NOT EXECUTED
40005d34:	80 a7 20 00 	cmp  %i4, 0                                    <== NOT EXECUTED
40005d38:	12 bf ff f0 	bne  40005cf8 <rtems_fdisk_ioctl+0xa4>         <== NOT EXECUTED
40005d3c:	01 00 00 00 	nop                                            <== NOT EXECUTED
40005d40:	b8 10 00 08 	mov  %o0, %i4                                  <== NOT EXECUTED
 * Pop the head of the segment control queue.                         
 */                                                                   
static rtems_fdisk_segment_ctl*                                       
rtems_fdisk_segment_queue_pop_head (rtems_fdisk_segment_ctl_queue* queue)
{                                                                     
  if (queue->head)                                                    
40005d44:	92 90 60 00 	orcc  %g1, 0, %o1                              <== NOT EXECUTED
40005d48:	12 bf ff ef 	bne  40005d04 <rtems_fdisk_ioctl+0xb0>         <== NOT EXECUTED
40005d4c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40005d50:	c4 04 20 d8 	ld  [ %l0 + 0xd8 ], %g2                        <== NOT EXECUTED
      case RTEMS_FDISK_IOCTL_COMPACT:                                 
        errno = rtems_fdisk_compact (&rtems_flashdisks[minor]);       
        break;                                                        
                                                                      
      case RTEMS_FDISK_IOCTL_ERASE_USED:                              
        errno = rtems_fdisk_erase_used (&rtems_flashdisks[minor]);    
40005d54:	f8 26 c0 00 	st  %i4, [ %i3 ]                               <== NOT EXECUTED
40005d58:	84 00 80 15 	add  %g2, %l5, %g2                             <== NOT EXECUTED
      default:                                                        
        rtems_blkdev_ioctl (dd, req, argp);                           
        break;                                                        
    }                                                                 
                                                                      
    sc = rtems_semaphore_release (rtems_flashdisks[minor].lock);      
40005d5c:	40 00 1c 32 	call  4000ce24 <rtems_semaphore_release>       <== NOT EXECUTED
40005d60:	d0 00 a0 64 	ld  [ %g2 + 0x64 ], %o0                        <== NOT EXECUTED
    if (sc != RTEMS_SUCCESSFUL)                                       
40005d64:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40005d68:	02 80 00 06 	be  40005d80 <rtems_fdisk_ioctl+0x12c>         <== NOT EXECUTED
40005d6c:	01 00 00 00 	nop                                            <== NOT EXECUTED
      errno = EIO;                                                    
40005d70:	40 00 72 f2 	call  40022938 <__errno>                       <== NOT EXECUTED
40005d74:	01 00 00 00 	nop                                            <== NOT EXECUTED
40005d78:	82 10 20 05 	mov  5, %g1	! 5 <PROM_START+0x5>               <== NOT EXECUTED
40005d7c:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  return errno == 0 ? 0 : -1;                                         
40005d80:	40 00 72 ee 	call  40022938 <__errno>                       <== NOT EXECUTED
40005d84:	01 00 00 00 	nop                                            <== NOT EXECUTED
40005d88:	c2 02 00 00 	ld  [ %o0 ], %g1                               <== NOT EXECUTED
40005d8c:	80 a0 00 01 	cmp  %g0, %g1                                  <== NOT EXECUTED
40005d90:	b0 60 20 00 	subx  %g0, 0, %i0                              <== NOT EXECUTED
40005d94:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40005d98:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL)                                         
    errno = EIO;                                                      
  else                                                                
  {                                                                   
    errno = 0;                                                        
    switch (req)                                                      
40005d9c:	80 a6 40 01 	cmp  %i1, %g1                                  
40005da0:	02 80 00 e6 	be  40006138 <rtems_fdisk_ioctl+0x4e4>         
40005da4:	01 00 00 00 	nop                                            
40005da8:	0a 80 00 a5 	bcs  4000603c <rtems_fdisk_ioctl+0x3e8>        <== NEVER TAKEN
40005dac:	c4 04 20 d8 	ld  [ %l0 + 0xd8 ], %g2                        
40005db0:	03 30 06 10 	sethi  %hi(0xc0184000), %g1                    
40005db4:	82 10 62 01 	or  %g1, 0x201, %g1	! c0184201 <LEON_REG+0x40184201>
40005db8:	80 a6 40 01 	cmp  %i1, %g1                                  
40005dbc:	12 80 00 9a 	bne  40006024 <rtems_fdisk_ioctl+0x3d0>        
40005dc0:	90 10 00 18 	mov  %i0, %o0                                  
    {                                                                 
      case RTEMS_BLKIO_REQUEST:                                       
        if ((minor >= rtems_flashdisk_count) ||                       
40005dc4:	03 10 01 26 	sethi  %hi(0x40049800), %g1                    
40005dc8:	c2 00 60 dc 	ld  [ %g1 + 0xdc ], %g1	! 400498dc <rtems_flashdisk_count>
40005dcc:	80 a0 40 1d 	cmp  %g1, %i5                                  
40005dd0:	08 80 02 0b 	bleu  400065fc <rtems_fdisk_ioctl+0x9a8>       <== NEVER TAKEN
40005dd4:	c2 04 20 d8 	ld  [ %l0 + 0xd8 ], %g1                        
            (rtems_flashdisks[minor].device_count == 0))              
40005dd8:	82 00 40 15 	add  %g1, %l5, %g1                             
  {                                                                   
    errno = 0;                                                        
    switch (req)                                                      
    {                                                                 
      case RTEMS_BLKIO_REQUEST:                                       
        if ((minor >= rtems_flashdisk_count) ||                       
40005ddc:	c2 00 60 30 	ld  [ %g1 + 0x30 ], %g1                        
40005de0:	80 a0 60 00 	cmp  %g1, 0                                    
40005de4:	02 80 02 06 	be  400065fc <rtems_fdisk_ioctl+0x9a8>         <== NEVER TAKEN
40005de8:	01 00 00 00 	nop                                            
        {                                                             
          errno = ENODEV;                                             
        }                                                             
        else                                                          
        {                                                             
          switch (r->req)                                             
40005dec:	c2 06 80 00 	ld  [ %i2 ], %g1                               
40005df0:	80 a0 60 00 	cmp  %g1, 0                                    
40005df4:	02 80 03 b0 	be  40006cb4 <rtems_fdisk_ioctl+0x1060>        
40005df8:	80 a0 60 01 	cmp  %g1, 1                                    
40005dfc:	02 80 02 09 	be  40006620 <rtems_fdisk_ioctl+0x9cc>         <== ALWAYS TAKEN
40005e00:	01 00 00 00 	nop                                            
            case RTEMS_BLKDEV_REQ_WRITE:                              
              errno = rtems_fdisk_write (&rtems_flashdisks[minor], r);
              break;                                                  
                                                                      
            default:                                                  
              errno = EINVAL;                                         
40005e04:	40 00 72 cd 	call  40022938 <__errno>                       <== NOT EXECUTED
40005e08:	01 00 00 00 	nop                                            <== NOT EXECUTED
40005e0c:	c4 04 20 d8 	ld  [ %l0 + 0xd8 ], %g2                        <== NOT EXECUTED
40005e10:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
40005e14:	84 00 80 15 	add  %g2, %l5, %g2                             <== NOT EXECUTED
              break;                                                  
40005e18:	10 80 00 74 	b  40005fe8 <rtems_fdisk_ioctl+0x394>          <== NOT EXECUTED
40005e1c:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
      case RTEMS_FDISK_IOCTL_ERASE_USED:                              
        errno = rtems_fdisk_erase_used (&rtems_flashdisks[minor]);    
        break;                                                        
                                                                      
      case RTEMS_FDISK_IOCTL_MONITORING:                              
        errno = rtems_fdisk_monitoring_data (&rtems_flashdisks[minor],
40005e20:	40 00 72 c6 	call  40022938 <__errno>                       <== NOT EXECUTED
40005e24:	01 00 00 00 	nop                                            <== NOT EXECUTED
40005e28:	c4 04 20 d8 	ld  [ %l0 + 0xd8 ], %g2                        <== NOT EXECUTED
40005e2c:	84 00 80 15 	add  %g2, %l5, %g2                             <== NOT EXECUTED
{                                                                     
  uint32_t i;                                                         
  uint32_t j;                                                         
                                                                      
  data->block_size     = fd->block_size;                              
  data->block_count    = fd->block_count;                             
40005e30:	c6 00 a0 1c 	ld  [ %g2 + 0x1c ], %g3                        <== NOT EXECUTED
                             rtems_fdisk_monitor_data* data)          
{                                                                     
  uint32_t i;                                                         
  uint32_t j;                                                         
                                                                      
  data->block_size     = fd->block_size;                              
40005e34:	fa 00 a0 14 	ld  [ %g2 + 0x14 ], %i5                        <== NOT EXECUTED
  data->block_count    = fd->block_count;                             
  data->unavail_blocks = fd->unavail_blocks;                          
40005e38:	c8 00 a0 20 	ld  [ %g2 + 0x20 ], %g4                        <== NOT EXECUTED
  data->device_count   = fd->device_count;                            
40005e3c:	c2 00 a0 30 	ld  [ %g2 + 0x30 ], %g1                        <== NOT EXECUTED
                             rtems_fdisk_monitor_data* data)          
{                                                                     
  uint32_t i;                                                         
  uint32_t j;                                                         
                                                                      
  data->block_size     = fd->block_size;                              
40005e40:	fa 26 80 00 	st  %i5, [ %i2 ]                               <== NOT EXECUTED
  data->block_count    = fd->block_count;                             
40005e44:	c6 26 a0 04 	st  %g3, [ %i2 + 4 ]                           <== NOT EXECUTED
  data->unavail_blocks = fd->unavail_blocks;                          
40005e48:	c8 26 a0 08 	st  %g4, [ %i2 + 8 ]                           <== NOT EXECUTED
  data->device_count   = fd->device_count;                            
40005e4c:	c2 26 a0 0c 	st  %g1, [ %i2 + 0xc ]                         <== NOT EXECUTED
                                                                      
  data->blocks_used = 0;                                              
  for (i = 0; i < fd->block_count; i++)                               
40005e50:	80 a0 e0 00 	cmp  %g3, 0                                    <== NOT EXECUTED
40005e54:	02 80 00 0f 	be  40005e90 <rtems_fdisk_ioctl+0x23c>         <== NOT EXECUTED
40005e58:	c0 26 a0 18 	clr  [ %i2 + 0x18 ]                            <== NOT EXECUTED
40005e5c:	fa 00 a0 18 	ld  [ %g2 + 0x18 ], %i5                        <== NOT EXECUTED
 * @param req IOCTL request code.                                     
 * @param argp IOCTL argument.                                        
 * @retval The IOCTL return value                                     
 */                                                                   
static int                                                            
rtems_fdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)   
40005e60:	89 28 e0 03 	sll  %g3, 3, %g4                               <== NOT EXECUTED
40005e64:	86 10 20 00 	clr  %g3                                       <== NOT EXECUTED
  data->unavail_blocks = fd->unavail_blocks;                          
  data->device_count   = fd->device_count;                            
                                                                      
  data->blocks_used = 0;                                              
  for (i = 0; i < fd->block_count; i++)                               
    if (fd->blocks[i].segment)                                        
40005e68:	f8 07 40 03 	ld  [ %i5 + %g3 ], %i4                         <== NOT EXECUTED
40005e6c:	80 a7 20 00 	cmp  %i4, 0                                    <== NOT EXECUTED
40005e70:	02 80 00 05 	be  40005e84 <rtems_fdisk_ioctl+0x230>         <== NOT EXECUTED
40005e74:	86 00 e0 08 	add  %g3, 8, %g3                               <== NOT EXECUTED
      data->blocks_used++;                                            
40005e78:	f8 06 a0 18 	ld  [ %i2 + 0x18 ], %i4                        <== NOT EXECUTED
40005e7c:	b8 07 20 01 	inc  %i4                                       <== NOT EXECUTED
40005e80:	f8 26 a0 18 	st  %i4, [ %i2 + 0x18 ]                        <== NOT EXECUTED
  data->block_count    = fd->block_count;                             
  data->unavail_blocks = fd->unavail_blocks;                          
  data->device_count   = fd->device_count;                            
                                                                      
  data->blocks_used = 0;                                              
  for (i = 0; i < fd->block_count; i++)                               
40005e84:	80 a0 c0 04 	cmp  %g3, %g4                                  <== NOT EXECUTED
40005e88:	32 bf ff f9 	bne,a   40005e6c <rtems_fdisk_ioctl+0x218>     <== NOT EXECUTED
40005e8c:	f8 07 40 03 	ld  [ %i5 + %g3 ], %i4                         <== NOT EXECUTED
 * Count the number of elements on the list.                          
 */                                                                   
static uint32_t                                                       
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{                                                                     
  rtems_fdisk_segment_ctl* sc = queue->head;                          
40005e90:	c8 00 a0 34 	ld  [ %g2 + 0x34 ], %g4                        <== NOT EXECUTED
  uint32_t                 count = 0;                                 
                                                                      
  while (sc)                                                          
40005e94:	80 a1 20 00 	cmp  %g4, 0                                    <== NOT EXECUTED
40005e98:	02 80 00 06 	be  40005eb0 <rtems_fdisk_ioctl+0x25c>         <== NOT EXECUTED
40005e9c:	86 10 20 00 	clr  %g3                                       <== NOT EXECUTED
  {                                                                   
    count++;                                                          
    sc = sc->next;                                                    
40005ea0:	c8 01 00 00 	ld  [ %g4 ], %g4                               <== NOT EXECUTED
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{                                                                     
  rtems_fdisk_segment_ctl* sc = queue->head;                          
  uint32_t                 count = 0;                                 
                                                                      
  while (sc)                                                          
40005ea4:	80 a1 20 00 	cmp  %g4, 0                                    <== NOT EXECUTED
40005ea8:	12 bf ff fe 	bne  40005ea0 <rtems_fdisk_ioctl+0x24c>        <== NOT EXECUTED
40005eac:	86 00 e0 01 	inc  %g3                                       <== NOT EXECUTED
 * Count the number of elements on the list.                          
 */                                                                   
static uint32_t                                                       
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{                                                                     
  rtems_fdisk_segment_ctl* sc = queue->head;                          
40005eb0:	c8 00 a0 40 	ld  [ %g2 + 0x40 ], %g4                        <== NOT EXECUTED
  data->blocks_used = 0;                                              
  for (i = 0; i < fd->block_count; i++)                               
    if (fd->blocks[i].segment)                                        
      data->blocks_used++;                                            
                                                                      
  data->segs_available = rtems_fdisk_segment_count_queue (&fd->available);
40005eb4:	c6 26 a0 1c 	st  %g3, [ %i2 + 0x1c ]                        <== NOT EXECUTED
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{                                                                     
  rtems_fdisk_segment_ctl* sc = queue->head;                          
  uint32_t                 count = 0;                                 
                                                                      
  while (sc)                                                          
40005eb8:	80 a1 20 00 	cmp  %g4, 0                                    <== NOT EXECUTED
40005ebc:	02 80 00 06 	be  40005ed4 <rtems_fdisk_ioctl+0x280>         <== NOT EXECUTED
40005ec0:	86 10 20 00 	clr  %g3                                       <== NOT EXECUTED
  {                                                                   
    count++;                                                          
    sc = sc->next;                                                    
40005ec4:	c8 01 00 00 	ld  [ %g4 ], %g4                               <== NOT EXECUTED
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{                                                                     
  rtems_fdisk_segment_ctl* sc = queue->head;                          
  uint32_t                 count = 0;                                 
                                                                      
  while (sc)                                                          
40005ec8:	80 a1 20 00 	cmp  %g4, 0                                    <== NOT EXECUTED
40005ecc:	12 bf ff fe 	bne  40005ec4 <rtems_fdisk_ioctl+0x270>        <== NOT EXECUTED
40005ed0:	86 00 e0 01 	inc  %g3                                       <== NOT EXECUTED
 * Count the number of elements on the list.                          
 */                                                                   
static uint32_t                                                       
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{                                                                     
  rtems_fdisk_segment_ctl* sc = queue->head;                          
40005ed4:	c8 00 a0 58 	ld  [ %g2 + 0x58 ], %g4                        <== NOT EXECUTED
  for (i = 0; i < fd->block_count; i++)                               
    if (fd->blocks[i].segment)                                        
      data->blocks_used++;                                            
                                                                      
  data->segs_available = rtems_fdisk_segment_count_queue (&fd->available);
  data->segs_used      = rtems_fdisk_segment_count_queue (&fd->used); 
40005ed8:	c6 26 a0 20 	st  %g3, [ %i2 + 0x20 ]                        <== NOT EXECUTED
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{                                                                     
  rtems_fdisk_segment_ctl* sc = queue->head;                          
  uint32_t                 count = 0;                                 
                                                                      
  while (sc)                                                          
40005edc:	80 a1 20 00 	cmp  %g4, 0                                    <== NOT EXECUTED
40005ee0:	02 80 00 06 	be  40005ef8 <rtems_fdisk_ioctl+0x2a4>         <== NOT EXECUTED
40005ee4:	86 10 20 00 	clr  %g3                                       <== NOT EXECUTED
  {                                                                   
    count++;                                                          
    sc = sc->next;                                                    
40005ee8:	c8 01 00 00 	ld  [ %g4 ], %g4                               <== NOT EXECUTED
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{                                                                     
  rtems_fdisk_segment_ctl* sc = queue->head;                          
  uint32_t                 count = 0;                                 
                                                                      
  while (sc)                                                          
40005eec:	80 a1 20 00 	cmp  %g4, 0                                    <== NOT EXECUTED
40005ef0:	12 bf ff fe 	bne  40005ee8 <rtems_fdisk_ioctl+0x294>        <== NOT EXECUTED
40005ef4:	86 00 e0 01 	inc  %g3                                       <== NOT EXECUTED
    if (fd->blocks[i].segment)                                        
      data->blocks_used++;                                            
                                                                      
  data->segs_available = rtems_fdisk_segment_count_queue (&fd->available);
  data->segs_used      = rtems_fdisk_segment_count_queue (&fd->used); 
  data->segs_failed    = rtems_fdisk_segment_count_queue (&fd->failed);
40005ef8:	c6 26 a0 24 	st  %g3, [ %i2 + 0x24 ]                        <== NOT EXECUTED
                                                                      
  data->segment_count = 0;                                            
40005efc:	c0 26 a0 10 	clr  [ %i2 + 0x10 ]                            <== NOT EXECUTED
  data->page_count    = 0;                                            
40005f00:	c0 26 a0 14 	clr  [ %i2 + 0x14 ]                            <== NOT EXECUTED
  data->pages_desc    = 0;                                            
40005f04:	c0 26 a0 2c 	clr  [ %i2 + 0x2c ]                            <== NOT EXECUTED
  data->pages_active  = 0;                                            
40005f08:	c0 26 a0 30 	clr  [ %i2 + 0x30 ]                            <== NOT EXECUTED
  data->pages_used    = 0;                                            
40005f0c:	c0 26 a0 34 	clr  [ %i2 + 0x34 ]                            <== NOT EXECUTED
  data->pages_bad     = 0;                                            
40005f10:	c0 26 a0 38 	clr  [ %i2 + 0x38 ]                            <== NOT EXECUTED
  data->seg_erases    = 0;                                            
                                                                      
  for (i = 0; i < fd->device_count; i++)                              
40005f14:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40005f18:	02 80 00 31 	be  40005fdc <rtems_fdisk_ioctl+0x388>         <== NOT EXECUTED
40005f1c:	c0 26 a0 28 	clr  [ %i2 + 0x28 ]                            <== NOT EXECUTED
40005f20:	e0 00 a0 2c 	ld  [ %g2 + 0x2c ], %l0                        <== NOT EXECUTED
 * @param req IOCTL request code.                                     
 * @param argp IOCTL argument.                                        
 * @retval The IOCTL return value                                     
 */                                                                   
static int                                                            
rtems_fdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)   
40005f24:	87 28 60 02 	sll  %g1, 2, %g3                               <== NOT EXECUTED
40005f28:	a2 10 20 00 	clr  %l1                                       <== NOT EXECUTED
40005f2c:	83 28 60 04 	sll  %g1, 4, %g1                               <== NOT EXECUTED
40005f30:	a4 20 40 03 	sub  %g1, %g3, %l2                             <== NOT EXECUTED
40005f34:	a4 04 00 12 	add  %l0, %l2, %l2                             <== NOT EXECUTED
  data->pages_bad     = 0;                                            
  data->seg_erases    = 0;                                            
                                                                      
  for (i = 0; i < fd->device_count; i++)                              
  {                                                                   
    data->segment_count += fd->devices[i].segment_count;              
40005f38:	f0 04 20 04 	ld  [ %l0 + 4 ], %i0                           <== NOT EXECUTED
                                                                      
    for (j = 0; j < fd->devices[i].segment_count; j++)                
40005f3c:	80 a6 20 00 	cmp  %i0, 0                                    <== NOT EXECUTED
40005f40:	02 80 00 22 	be  40005fc8 <rtems_fdisk_ioctl+0x374>         <== NOT EXECUTED
40005f44:	a2 04 40 18 	add  %l1, %i0, %l1                             <== NOT EXECUTED
40005f48:	c2 04 00 00 	ld  [ %l0 ], %g1                               <== NOT EXECUTED
40005f4c:	f2 06 a0 14 	ld  [ %i2 + 0x14 ], %i1                        <== NOT EXECUTED
40005f50:	f6 06 a0 2c 	ld  [ %i2 + 0x2c ], %i3                        <== NOT EXECUTED
40005f54:	f8 06 a0 30 	ld  [ %i2 + 0x30 ], %i4                        <== NOT EXECUTED
40005f58:	fa 06 a0 34 	ld  [ %i2 + 0x34 ], %i5                        <== NOT EXECUTED
40005f5c:	c8 06 a0 38 	ld  [ %i2 + 0x38 ], %g4                        <== NOT EXECUTED
40005f60:	c6 06 a0 28 	ld  [ %i2 + 0x28 ], %g3                        <== NOT EXECUTED
 * @param req IOCTL request code.                                     
 * @param argp IOCTL argument.                                        
 * @retval The IOCTL return value                                     
 */                                                                   
static int                                                            
rtems_fdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)   
40005f64:	9f 2e 20 04 	sll  %i0, 4, %o7                               <== NOT EXECUTED
40005f68:	b1 2e 20 06 	sll  %i0, 6, %i0                               <== NOT EXECUTED
40005f6c:	92 26 00 0f 	sub  %i0, %o7, %o1                             <== NOT EXECUTED
40005f70:	92 00 40 09 	add  %g1, %o1, %o1                             <== NOT EXECUTED
                                                                      
    for (j = 0; j < fd->devices[i].segment_count; j++)                
    {                                                                 
      rtems_fdisk_segment_ctl* sc = &fd->devices[i].segments[j];      
                                                                      
      data->page_count   += sc->pages;                                
40005f74:	d4 00 60 14 	ld  [ %g1 + 0x14 ], %o2                        <== NOT EXECUTED
      data->pages_desc   += sc->pages_desc;                           
40005f78:	d6 00 60 18 	ld  [ %g1 + 0x18 ], %o3                        <== NOT EXECUTED
      data->pages_active += sc->pages_active;                         
40005f7c:	d8 00 60 1c 	ld  [ %g1 + 0x1c ], %o4                        <== NOT EXECUTED
      data->pages_used   += sc->pages_used;                           
40005f80:	da 00 60 20 	ld  [ %g1 + 0x20 ], %o5                        <== NOT EXECUTED
      data->pages_bad    += sc->pages_bad;                            
40005f84:	de 00 60 24 	ld  [ %g1 + 0x24 ], %o7                        <== NOT EXECUTED
      data->seg_erases   += sc->erased;                               
40005f88:	f0 00 60 2c 	ld  [ %g1 + 0x2c ], %i0                        <== NOT EXECUTED
                                                                      
    for (j = 0; j < fd->devices[i].segment_count; j++)                
    {                                                                 
      rtems_fdisk_segment_ctl* sc = &fd->devices[i].segments[j];      
                                                                      
      data->page_count   += sc->pages;                                
40005f8c:	b2 06 40 0a 	add  %i1, %o2, %i1                             <== NOT EXECUTED
40005f90:	82 00 60 30 	add  %g1, 0x30, %g1                            <== NOT EXECUTED
      data->pages_desc   += sc->pages_desc;                           
40005f94:	b6 06 c0 0b 	add  %i3, %o3, %i3                             <== NOT EXECUTED
      data->pages_active += sc->pages_active;                         
40005f98:	b8 07 00 0c 	add  %i4, %o4, %i4                             <== NOT EXECUTED
      data->pages_used   += sc->pages_used;                           
40005f9c:	ba 07 40 0d 	add  %i5, %o5, %i5                             <== NOT EXECUTED
      data->pages_bad    += sc->pages_bad;                            
40005fa0:	88 01 00 0f 	add  %g4, %o7, %g4                             <== NOT EXECUTED
                                                                      
  for (i = 0; i < fd->device_count; i++)                              
  {                                                                   
    data->segment_count += fd->devices[i].segment_count;              
                                                                      
    for (j = 0; j < fd->devices[i].segment_count; j++)                
40005fa4:	80 a0 40 09 	cmp  %g1, %o1                                  <== NOT EXECUTED
40005fa8:	12 bf ff f3 	bne  40005f74 <rtems_fdisk_ioctl+0x320>        <== NOT EXECUTED
40005fac:	86 00 c0 18 	add  %g3, %i0, %g3                             <== NOT EXECUTED
40005fb0:	f2 26 a0 14 	st  %i1, [ %i2 + 0x14 ]                        <== NOT EXECUTED
40005fb4:	f6 26 a0 2c 	st  %i3, [ %i2 + 0x2c ]                        <== NOT EXECUTED
40005fb8:	f8 26 a0 30 	st  %i4, [ %i2 + 0x30 ]                        <== NOT EXECUTED
40005fbc:	fa 26 a0 34 	st  %i5, [ %i2 + 0x34 ]                        <== NOT EXECUTED
40005fc0:	c8 26 a0 38 	st  %g4, [ %i2 + 0x38 ]                        <== NOT EXECUTED
40005fc4:	c6 26 a0 28 	st  %g3, [ %i2 + 0x28 ]                        <== NOT EXECUTED
40005fc8:	a0 04 20 0c 	add  %l0, 0xc, %l0                             <== NOT EXECUTED
  data->pages_active  = 0;                                            
  data->pages_used    = 0;                                            
  data->pages_bad     = 0;                                            
  data->seg_erases    = 0;                                            
                                                                      
  for (i = 0; i < fd->device_count; i++)                              
40005fcc:	80 a4 00 12 	cmp  %l0, %l2                                  <== NOT EXECUTED
40005fd0:	32 bf ff db 	bne,a   40005f3c <rtems_fdisk_ioctl+0x2e8>     <== NOT EXECUTED
40005fd4:	f0 04 20 04 	ld  [ %l0 + 4 ], %i0                           <== NOT EXECUTED
40005fd8:	e2 26 a0 10 	st  %l1, [ %i2 + 0x10 ]                        <== NOT EXECUTED
      data->pages_bad    += sc->pages_bad;                            
      data->seg_erases   += sc->erased;                               
    }                                                                 
  }                                                                   
                                                                      
  data->info_level = fd->info_level;                                  
40005fdc:	c2 00 a0 6c 	ld  [ %g2 + 0x6c ], %g1                        <== NOT EXECUTED
40005fe0:	c2 26 a0 3c 	st  %g1, [ %i2 + 0x3c ]                        <== NOT EXECUTED
      case RTEMS_FDISK_IOCTL_ERASE_USED:                              
        errno = rtems_fdisk_erase_used (&rtems_flashdisks[minor]);    
        break;                                                        
                                                                      
      case RTEMS_FDISK_IOCTL_MONITORING:                              
        errno = rtems_fdisk_monitoring_data (&rtems_flashdisks[minor],
40005fe4:	c0 22 00 00 	clr  [ %o0 ]                                   <== NOT EXECUTED
      default:                                                        
        rtems_blkdev_ioctl (dd, req, argp);                           
        break;                                                        
    }                                                                 
                                                                      
    sc = rtems_semaphore_release (rtems_flashdisks[minor].lock);      
40005fe8:	40 00 1b 8f 	call  4000ce24 <rtems_semaphore_release>       
40005fec:	d0 00 a0 64 	ld  [ %g2 + 0x64 ], %o0                        
    if (sc != RTEMS_SUCCESSFUL)                                       
40005ff0:	80 a2 20 00 	cmp  %o0, 0                                    
40005ff4:	12 bf ff 5f 	bne  40005d70 <rtems_fdisk_ioctl+0x11c>        <== NEVER TAKEN
40005ff8:	01 00 00 00 	nop                                            
      errno = EIO;                                                    
  }                                                                   
                                                                      
  return errno == 0 ? 0 : -1;                                         
40005ffc:	40 00 72 4f 	call  40022938 <__errno>                       
40006000:	01 00 00 00 	nop                                            
40006004:	c2 02 00 00 	ld  [ %o0 ], %g1                               
40006008:	80 a0 00 01 	cmp  %g0, %g1                                  
4000600c:	b0 60 20 00 	subx  %g0, 0, %i0                              
40006010:	81 c7 e0 08 	ret                                            
40006014:	81 e8 00 00 	restore                                        
  if (sc != RTEMS_SUCCESSFUL)                                         
    errno = EIO;                                                      
  else                                                                
  {                                                                   
    errno = 0;                                                        
    switch (req)                                                      
40006018:	80 a6 40 01 	cmp  %i1, %g1                                  
4000601c:	02 80 00 15 	be  40006070 <rtems_fdisk_ioctl+0x41c>         <== NEVER TAKEN
40006020:	90 10 00 18 	mov  %i0, %o0                                  
      case RTEMS_FDISK_IOCTL_PRINT_STATUS:                            
        errno = rtems_fdisk_print_status (&rtems_flashdisks[minor]);  
        break;                                                        
                                                                      
      default:                                                        
        rtems_blkdev_ioctl (dd, req, argp);                           
40006024:	92 10 00 19 	mov  %i1, %o1                                  
40006028:	40 00 42 c0 	call  40016b28 <rtems_blkdev_ioctl>            
4000602c:	94 10 00 1a 	mov  %i2, %o2                                  
40006030:	c4 04 20 d8 	ld  [ %l0 + 0xd8 ], %g2                        
        break;                                                        
40006034:	10 bf ff ed 	b  40005fe8 <rtems_fdisk_ioctl+0x394>          
40006038:	84 00 80 15 	add  %g2, %l5, %g2                             
        errno = rtems_fdisk_monitoring_data (&rtems_flashdisks[minor],
                                             (rtems_fdisk_monitor_data*) argp);
        break;                                                        
                                                                      
      case RTEMS_FDISK_IOCTL_INFO_LEVEL:                              
        rtems_flashdisks[minor].info_level = (uintptr_t) argp;        
4000603c:	84 00 80 15 	add  %g2, %l5, %g2                             <== NOT EXECUTED
        break;                                                        
40006040:	10 bf ff ea 	b  40005fe8 <rtems_fdisk_ioctl+0x394>          <== NOT EXECUTED
40006044:	f4 20 a0 6c 	st  %i2, [ %g2 + 0x6c ]                        <== NOT EXECUTED
      case RTEMS_FDISK_IOCTL_ERASE_DISK:                              
        errno = rtems_fdisk_erase_disk (&rtems_flashdisks[minor]);    
        break;                                                        
                                                                      
      case RTEMS_FDISK_IOCTL_COMPACT:                                 
        errno = rtems_fdisk_compact (&rtems_flashdisks[minor]);       
40006048:	40 00 72 3c 	call  40022938 <__errno>                       <== NOT EXECUTED
4000604c:	01 00 00 00 	nop                                            <== NOT EXECUTED
40006050:	ba 10 00 08 	mov  %o0, %i5                                  <== NOT EXECUTED
40006054:	d0 04 20 d8 	ld  [ %l0 + 0xd8 ], %o0                        <== NOT EXECUTED
40006058:	7f ff fd 54 	call  400055a8 <rtems_fdisk_compact>           <== NOT EXECUTED
4000605c:	90 02 00 15 	add  %o0, %l5, %o0                             <== NOT EXECUTED
40006060:	c4 04 20 d8 	ld  [ %l0 + 0xd8 ], %g2                        <== NOT EXECUTED
40006064:	d0 27 40 00 	st  %o0, [ %i5 ]                               <== NOT EXECUTED
        break;                                                        
40006068:	10 bf ff e0 	b  40005fe8 <rtems_fdisk_ioctl+0x394>          <== NOT EXECUTED
4000606c:	84 00 80 15 	add  %g2, %l5, %g2                             <== NOT EXECUTED
          }                                                           
        }                                                             
        break;                                                        
                                                                      
      case RTEMS_FDISK_IOCTL_ERASE_DISK:                              
        errno = rtems_fdisk_erase_disk (&rtems_flashdisks[minor]);    
40006070:	40 00 72 32 	call  40022938 <__errno>                       <== NOT EXECUTED
40006074:	01 00 00 00 	nop                                            <== NOT EXECUTED
40006078:	fa 04 20 d8 	ld  [ %l0 + 0xd8 ], %i5                        <== NOT EXECUTED
4000607c:	b4 10 00 08 	mov  %o0, %i2                                  <== NOT EXECUTED
40006080:	ba 07 40 15 	add  %i5, %l5, %i5                             <== NOT EXECUTED
{                                                                     
  uint32_t device;                                                    
  int      ret;                                                       
                                                                      
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_info (fd, "erase-disk");                                
40006084:	13 10 00 d3 	sethi  %hi(0x40034c00), %o1                    <== NOT EXECUTED
40006088:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4000608c:	7f ff f9 d7 	call  400047e8 <rtems_fdisk_info>              <== NOT EXECUTED
40006090:	92 12 60 18 	or  %o1, 0x18, %o1                             <== NOT EXECUTED
 */                                                                   
static int                                                            
rtems_fdisk_erase_flash (const rtems_flashdisk* fd)                   
{                                                                     
  uint32_t device;                                                    
  for (device = 0; device < fd->device_count; device++)               
40006094:	c2 07 60 30 	ld  [ %i5 + 0x30 ], %g1                        <== NOT EXECUTED
40006098:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4000609c:	02 80 03 e3 	be  40007028 <rtems_fdisk_ioctl+0x13d4>        <== NOT EXECUTED
400060a0:	31 10 00 d3 	sethi  %hi(0x40034c00), %i0                    <== NOT EXECUTED
rtems_fdisk_device_erase (const rtems_flashdisk* fd, uint32_t device) 
{                                                                     
  const rtems_fdisk_driver_handlers* ops;                             
  ops = fd->devices[device].descriptor->flash_ops;                    
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_printf (fd, " device-erase: %02d", device);             
400060a4:	33 10 00 d3 	sethi  %hi(0x40034c00), %i1                    <== NOT EXECUTED
 */                                                                   
static int                                                            
rtems_fdisk_erase_flash (const rtems_flashdisk* fd)                   
{                                                                     
  uint32_t device;                                                    
  for (device = 0; device < fd->device_count; device++)               
400060a8:	b6 10 20 00 	clr  %i3                                       <== NOT EXECUTED
400060ac:	b8 10 20 00 	clr  %i4                                       <== NOT EXECUTED
  {                                                                   
    int ret;                                                          
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_info (fd, " erase-flash:%02d", device);               
400060b0:	b0 16 20 28 	or  %i0, 0x28, %i0                             <== NOT EXECUTED
rtems_fdisk_device_erase (const rtems_flashdisk* fd, uint32_t device) 
{                                                                     
  const rtems_fdisk_driver_handlers* ops;                             
  ops = fd->devices[device].descriptor->flash_ops;                    
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_printf (fd, " device-erase: %02d", device);             
400060b4:	10 80 00 06 	b  400060cc <rtems_fdisk_ioctl+0x478>          <== NOT EXECUTED
400060b8:	b2 16 60 40 	or  %i1, 0x40, %i1                             <== NOT EXECUTED
 */                                                                   
static int                                                            
rtems_fdisk_erase_flash (const rtems_flashdisk* fd)                   
{                                                                     
  uint32_t device;                                                    
  for (device = 0; device < fd->device_count; device++)               
400060bc:	b8 07 20 01 	inc  %i4                                       <== NOT EXECUTED
400060c0:	80 a7 00 01 	cmp  %i4, %g1                                  <== NOT EXECUTED
400060c4:	1a 80 03 be 	bcc  40006fbc <rtems_fdisk_ioctl+0x1368>       <== NOT EXECUTED
400060c8:	b6 06 e0 0c 	add  %i3, 0xc, %i3                             <== NOT EXECUTED
  {                                                                   
    int ret;                                                          
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_info (fd, " erase-flash:%02d", device);               
400060cc:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
400060d0:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
400060d4:	7f ff f9 c5 	call  400047e8 <rtems_fdisk_info>              <== NOT EXECUTED
400060d8:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 */                                                                   
static int                                                            
rtems_fdisk_device_erase (const rtems_flashdisk* fd, uint32_t device) 
{                                                                     
  const rtems_fdisk_driver_handlers* ops;                             
  ops = fd->devices[device].descriptor->flash_ops;                    
400060dc:	c2 07 60 2c 	ld  [ %i5 + 0x2c ], %g1                        <== NOT EXECUTED
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_printf (fd, " device-erase: %02d", device);             
400060e0:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
 */                                                                   
static int                                                            
rtems_fdisk_device_erase (const rtems_flashdisk* fd, uint32_t device) 
{                                                                     
  const rtems_fdisk_driver_handlers* ops;                             
  ops = fd->devices[device].descriptor->flash_ops;                    
400060e4:	82 00 40 1b 	add  %g1, %i3, %g1                             <== NOT EXECUTED
400060e8:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           <== NOT EXECUTED
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_printf (fd, " device-erase: %02d", device);             
400060ec:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
 */                                                                   
static int                                                            
rtems_fdisk_device_erase (const rtems_flashdisk* fd, uint32_t device) 
{                                                                     
  const rtems_fdisk_driver_handlers* ops;                             
  ops = fd->devices[device].descriptor->flash_ops;                    
400060f0:	e2 00 60 08 	ld  [ %g1 + 8 ], %l1                           <== NOT EXECUTED
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_printf (fd, " device-erase: %02d", device);             
400060f4:	7f ff f9 df 	call  40004870 <rtems_fdisk_printf>            <== NOT EXECUTED
400060f8:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
#endif                                                                
  return ops->erase_device (fd->devices[device].descriptor, device);  
400060fc:	c4 07 60 2c 	ld  [ %i5 + 0x2c ], %g2                        <== NOT EXECUTED
40006100:	c2 04 60 14 	ld  [ %l1 + 0x14 ], %g1                        <== NOT EXECUTED
40006104:	84 00 80 1b 	add  %g2, %i3, %g2                             <== NOT EXECUTED
40006108:	d0 00 a0 08 	ld  [ %g2 + 8 ], %o0                           <== NOT EXECUTED
4000610c:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
40006110:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
    rtems_fdisk_info (fd, " erase-flash:%02d", device);               
#endif                                                                
                                                                      
    ret = rtems_fdisk_device_erase (fd, device);                      
                                                                      
    if (ret != 0)                                                     
40006114:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40006118:	22 bf ff e9 	be,a   400060bc <rtems_fdisk_ioctl+0x468>      <== NOT EXECUTED
4000611c:	c2 07 60 30 	ld  [ %i5 + 0x30 ], %g1                        <== NOT EXECUTED
40006120:	c4 04 20 d8 	ld  [ %l0 + 0xd8 ], %g2                        <== NOT EXECUTED
          }                                                           
        }                                                             
        break;                                                        
                                                                      
      case RTEMS_FDISK_IOCTL_ERASE_DISK:                              
        errno = rtems_fdisk_erase_disk (&rtems_flashdisks[minor]);    
40006124:	d0 26 80 00 	st  %o0, [ %i2 ]                               <== NOT EXECUTED
        break;                                                        
40006128:	10 bf ff b0 	b  40005fe8 <rtems_fdisk_ioctl+0x394>          <== NOT EXECUTED
4000612c:	84 00 80 15 	add  %g2, %l5, %g2                             <== NOT EXECUTED
  {                                                                   
    rtems_fdisk_segment_ctl* sc = queue->head;                        
                                                                      
    queue->head = sc->next;                                           
    if (!queue->head)                                                 
      queue->tail = 0;                                                
40006130:	10 bf fe f9 	b  40005d14 <rtems_fdisk_ioctl+0xc0>           <== NOT EXECUTED
40006134:	c0 27 60 50 	clr  [ %i5 + 0x50 ]                            <== NOT EXECUTED
      case RTEMS_FDISK_IOCTL_INFO_LEVEL:                              
        rtems_flashdisks[minor].info_level = (uintptr_t) argp;        
        break;                                                        
                                                                      
      case RTEMS_FDISK_IOCTL_PRINT_STATUS:                            
        errno = rtems_fdisk_print_status (&rtems_flashdisks[minor]);  
40006138:	40 00 72 00 	call  40022938 <__errno>                       
4000613c:	ba 10 20 00 	clr  %i5                                       
40006140:	c2 04 20 d8 	ld  [ %l0 + 0xd8 ], %g1                        
40006144:	d0 27 bf e8 	st  %o0, [ %fp + -24 ]                         
40006148:	b6 00 40 15 	add  %g1, %l5, %i3                             
  uint32_t count;                                                     
  uint32_t device;                                                    
                                                                      
  fd->info_level = 3;                                                 
                                                                      
  rtems_fdisk_printf (fd,                                             
4000614c:	d4 00 40 15 	ld  [ %g1 + %l5 ], %o2                         
 */                                                                   
static int                                                            
rtems_fdisk_print_status (rtems_flashdisk* fd)                        
{                                                                     
#if RTEMS_FDISK_TRACE                                                 
  uint32_t current_info_level = fd->info_level;                       
40006150:	c4 06 e0 6c 	ld  [ %i3 + 0x6c ], %g2                        
  uint32_t count;                                                     
  uint32_t device;                                                    
                                                                      
  fd->info_level = 3;                                                 
                                                                      
  rtems_fdisk_printf (fd,                                             
40006154:	d6 06 e0 04 	ld  [ %i3 + 4 ], %o3                           
  uint32_t current_info_level = fd->info_level;                       
  uint32_t total;                                                     
  uint32_t count;                                                     
  uint32_t device;                                                    
                                                                      
  fd->info_level = 3;                                                 
40006158:	82 10 20 03 	mov  3, %g1                                    
 */                                                                   
static int                                                            
rtems_fdisk_print_status (rtems_flashdisk* fd)                        
{                                                                     
#if RTEMS_FDISK_TRACE                                                 
  uint32_t current_info_level = fd->info_level;                       
4000615c:	c4 27 bf e4 	st  %g2, [ %fp + -28 ]                         
  uint32_t total;                                                     
  uint32_t count;                                                     
  uint32_t device;                                                    
                                                                      
  fd->info_level = 3;                                                 
40006160:	c2 26 e0 6c 	st  %g1, [ %i3 + 0x6c ]                        
                                                                      
  rtems_fdisk_printf (fd,                                             
40006164:	90 10 00 1b 	mov  %i3, %o0                                  
40006168:	13 10 00 d3 	sethi  %hi(0x40034c00), %o1                    
4000616c:	7f ff f9 c1 	call  40004870 <rtems_fdisk_printf>            
40006170:	92 12 60 58 	or  %o1, 0x58, %o1	! 40034c58 <__FUNCTION__.6193+0xb90>
                      "Flash Disk Driver Status : %d.%d", fd->major, fd->minor);
                                                                      
  rtems_fdisk_printf (fd, "Block count\t%d", fd->block_count);        
40006174:	d4 06 e0 1c 	ld  [ %i3 + 0x1c ], %o2                        
40006178:	90 10 00 1b 	mov  %i3, %o0                                  
4000617c:	13 10 00 d3 	sethi  %hi(0x40034c00), %o1                    
40006180:	7f ff f9 bc 	call  40004870 <rtems_fdisk_printf>            
40006184:	92 12 60 80 	or  %o1, 0x80, %o1	! 40034c80 <__FUNCTION__.6193+0xbb8>
  rtems_fdisk_printf (fd, "Unavail blocks\t%d", fd->unavail_blocks);  
40006188:	d4 06 e0 20 	ld  [ %i3 + 0x20 ], %o2                        
4000618c:	90 10 00 1b 	mov  %i3, %o0                                  
40006190:	13 10 00 d3 	sethi  %hi(0x40034c00), %o1                    
40006194:	7f ff f9 b7 	call  40004870 <rtems_fdisk_printf>            
40006198:	92 12 60 90 	or  %o1, 0x90, %o1	! 40034c90 <__FUNCTION__.6193+0xbc8>
  rtems_fdisk_printf (fd, "Starvation threshold\t%d", fd->starvation_threshold);
4000619c:	d4 06 e0 24 	ld  [ %i3 + 0x24 ], %o2                        
400061a0:	90 10 00 1b 	mov  %i3, %o0                                  
400061a4:	13 10 00 d3 	sethi  %hi(0x40034c00), %o1                    
400061a8:	7f ff f9 b2 	call  40004870 <rtems_fdisk_printf>            
400061ac:	92 12 60 a8 	or  %o1, 0xa8, %o1	! 40034ca8 <__FUNCTION__.6193+0xbe0>
  rtems_fdisk_printf (fd, "Starvations\t%d", fd->starvations);        
400061b0:	d4 06 e0 70 	ld  [ %i3 + 0x70 ], %o2                        
400061b4:	90 10 00 1b 	mov  %i3, %o0                                  
400061b8:	13 10 00 d3 	sethi  %hi(0x40034c00), %o1                    
400061bc:	7f ff f9 ad 	call  40004870 <rtems_fdisk_printf>            
400061c0:	92 12 60 c0 	or  %o1, 0xc0, %o1	! 40034cc0 <__FUNCTION__.6193+0xbf8>
 * Count the number of elements on the list.                          
 */                                                                   
static uint32_t                                                       
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{                                                                     
  rtems_fdisk_segment_ctl* sc = queue->head;                          
400061c4:	c2 06 e0 34 	ld  [ %i3 + 0x34 ], %g1                        
  uint32_t                 count = 0;                                 
                                                                      
  while (sc)                                                          
400061c8:	80 a0 60 00 	cmp  %g1, 0                                    
400061cc:	22 80 00 07 	be,a   400061e8 <rtems_fdisk_ioctl+0x594>      <== NEVER TAKEN
400061d0:	d6 06 e0 3c 	ld  [ %i3 + 0x3c ], %o3                        <== NOT EXECUTED
  {                                                                   
    count++;                                                          
    sc = sc->next;                                                    
400061d4:	c2 00 40 00 	ld  [ %g1 ], %g1                               
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{                                                                     
  rtems_fdisk_segment_ctl* sc = queue->head;                          
  uint32_t                 count = 0;                                 
                                                                      
  while (sc)                                                          
400061d8:	80 a0 60 00 	cmp  %g1, 0                                    
400061dc:	12 bf ff fe 	bne  400061d4 <rtems_fdisk_ioctl+0x580>        <== NEVER TAKEN
400061e0:	ba 07 60 01 	inc  %i5                                       
  rtems_fdisk_printf (fd, "Unavail blocks\t%d", fd->unavail_blocks);  
  rtems_fdisk_printf (fd, "Starvation threshold\t%d", fd->starvation_threshold);
  rtems_fdisk_printf (fd, "Starvations\t%d", fd->starvations);        
  count = rtems_fdisk_segment_count_queue (&fd->available);           
  total = count;                                                      
  rtems_fdisk_printf (fd, "Available queue\t%ld (%ld)",               
400061e4:	d6 06 e0 3c 	ld  [ %i3 + 0x3c ], %o3                        
400061e8:	94 10 00 1d 	mov  %i5, %o2                                  
400061ec:	90 10 00 1b 	mov  %i3, %o0                                  
400061f0:	13 10 00 d3 	sethi  %hi(0x40034c00), %o1                    
400061f4:	7f ff f9 9f 	call  40004870 <rtems_fdisk_printf>            
400061f8:	92 12 60 d0 	or  %o1, 0xd0, %o1	! 40034cd0 <__FUNCTION__.6193+0xc08>
 * Count the number of elements on the list.                          
 */                                                                   
static uint32_t                                                       
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{                                                                     
  rtems_fdisk_segment_ctl* sc = queue->head;                          
400061fc:	c2 06 e0 40 	ld  [ %i3 + 0x40 ], %g1                        
  uint32_t                 count = 0;                                 
                                                                      
  while (sc)                                                          
40006200:	80 a0 60 00 	cmp  %g1, 0                                    
40006204:	02 80 00 06 	be  4000621c <rtems_fdisk_ioctl+0x5c8>         <== NEVER TAKEN
40006208:	94 10 20 00 	clr  %o2                                       
  {                                                                   
    count++;                                                          
    sc = sc->next;                                                    
4000620c:	c2 00 40 00 	ld  [ %g1 ], %g1                               
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{                                                                     
  rtems_fdisk_segment_ctl* sc = queue->head;                          
  uint32_t                 count = 0;                                 
                                                                      
  while (sc)                                                          
40006210:	80 a0 60 00 	cmp  %g1, 0                                    
40006214:	12 bf ff fe 	bne  4000620c <rtems_fdisk_ioctl+0x5b8>        
40006218:	94 02 a0 01 	inc  %o2                                       
  total = count;                                                      
  rtems_fdisk_printf (fd, "Available queue\t%ld (%ld)",               
                      count, rtems_fdisk_segment_queue_count (&fd->available));
  count = rtems_fdisk_segment_count_queue (&fd->used);                
  total += count;                                                     
  rtems_fdisk_printf (fd, "Used queue\t%ld (%ld)",                    
4000621c:	d6 06 e0 48 	ld  [ %i3 + 0x48 ], %o3                        
  count = rtems_fdisk_segment_count_queue (&fd->available);           
  total = count;                                                      
  rtems_fdisk_printf (fd, "Available queue\t%ld (%ld)",               
                      count, rtems_fdisk_segment_queue_count (&fd->available));
  count = rtems_fdisk_segment_count_queue (&fd->used);                
  total += count;                                                     
40006220:	ba 02 80 1d 	add  %o2, %i5, %i5                             
  rtems_fdisk_printf (fd, "Used queue\t%ld (%ld)",                    
40006224:	90 10 00 1b 	mov  %i3, %o0                                  
40006228:	13 10 00 d3 	sethi  %hi(0x40034c00), %o1                    
4000622c:	7f ff f9 91 	call  40004870 <rtems_fdisk_printf>            
40006230:	92 12 60 f0 	or  %o1, 0xf0, %o1	! 40034cf0 <__FUNCTION__.6193+0xc28>
 * Count the number of elements on the list.                          
 */                                                                   
static uint32_t                                                       
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{                                                                     
  rtems_fdisk_segment_ctl* sc = queue->head;                          
40006234:	c2 06 e0 4c 	ld  [ %i3 + 0x4c ], %g1                        
  uint32_t                 count = 0;                                 
                                                                      
  while (sc)                                                          
40006238:	80 a0 60 00 	cmp  %g1, 0                                    
4000623c:	02 80 00 06 	be  40006254 <rtems_fdisk_ioctl+0x600>         <== ALWAYS TAKEN
40006240:	94 10 20 00 	clr  %o2                                       
  {                                                                   
    count++;                                                          
    sc = sc->next;                                                    
40006244:	c2 00 40 00 	ld  [ %g1 ], %g1                               <== NOT EXECUTED
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{                                                                     
  rtems_fdisk_segment_ctl* sc = queue->head;                          
  uint32_t                 count = 0;                                 
                                                                      
  while (sc)                                                          
40006248:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4000624c:	12 bf ff fe 	bne  40006244 <rtems_fdisk_ioctl+0x5f0>        <== NOT EXECUTED
40006250:	94 02 a0 01 	inc  %o2                                       <== NOT EXECUTED
  total += count;                                                     
  rtems_fdisk_printf (fd, "Used queue\t%ld (%ld)",                    
                      count, rtems_fdisk_segment_queue_count (&fd->used));
  count = rtems_fdisk_segment_count_queue (&fd->erase);               
  total += count;                                                     
  rtems_fdisk_printf (fd, "Erase queue\t%ld (%ld)",                   
40006254:	d6 06 e0 54 	ld  [ %i3 + 0x54 ], %o3                        
  count = rtems_fdisk_segment_count_queue (&fd->used);                
  total += count;                                                     
  rtems_fdisk_printf (fd, "Used queue\t%ld (%ld)",                    
                      count, rtems_fdisk_segment_queue_count (&fd->used));
  count = rtems_fdisk_segment_count_queue (&fd->erase);               
  total += count;                                                     
40006258:	ba 07 40 0a 	add  %i5, %o2, %i5                             
  rtems_fdisk_printf (fd, "Erase queue\t%ld (%ld)",                   
4000625c:	90 10 00 1b 	mov  %i3, %o0                                  
40006260:	13 10 00 d3 	sethi  %hi(0x40034c00), %o1                    
40006264:	7f ff f9 83 	call  40004870 <rtems_fdisk_printf>            
40006268:	92 12 61 08 	or  %o1, 0x108, %o1	! 40034d08 <__FUNCTION__.6193+0xc40>
 * Count the number of elements on the list.                          
 */                                                                   
static uint32_t                                                       
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{                                                                     
  rtems_fdisk_segment_ctl* sc = queue->head;                          
4000626c:	c4 06 e0 58 	ld  [ %i3 + 0x58 ], %g2                        
  uint32_t                 count = 0;                                 
                                                                      
  while (sc)                                                          
40006270:	80 a0 a0 00 	cmp  %g2, 0                                    
40006274:	02 80 00 06 	be  4000628c <rtems_fdisk_ioctl+0x638>         <== ALWAYS TAKEN
40006278:	94 10 20 00 	clr  %o2                                       
  {                                                                   
    count++;                                                          
    sc = sc->next;                                                    
4000627c:	c4 00 80 00 	ld  [ %g2 ], %g2                               <== NOT EXECUTED
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{                                                                     
  rtems_fdisk_segment_ctl* sc = queue->head;                          
  uint32_t                 count = 0;                                 
                                                                      
  while (sc)                                                          
40006280:	80 a0 a0 00 	cmp  %g2, 0                                    <== NOT EXECUTED
40006284:	12 bf ff fe 	bne  4000627c <rtems_fdisk_ioctl+0x628>        <== NOT EXECUTED
40006288:	94 02 a0 01 	inc  %o2                                       <== NOT EXECUTED
  total += count;                                                     
  rtems_fdisk_printf (fd, "Erase queue\t%ld (%ld)",                   
                      count, rtems_fdisk_segment_queue_count (&fd->erase));
  count = rtems_fdisk_segment_count_queue (&fd->failed);              
  total += count;                                                     
  rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",                  
4000628c:	d6 06 e0 60 	ld  [ %i3 + 0x60 ], %o3                        
  count = rtems_fdisk_segment_count_queue (&fd->erase);               
  total += count;                                                     
  rtems_fdisk_printf (fd, "Erase queue\t%ld (%ld)",                   
                      count, rtems_fdisk_segment_queue_count (&fd->erase));
  count = rtems_fdisk_segment_count_queue (&fd->failed);              
  total += count;                                                     
40006290:	ba 07 40 0a 	add  %i5, %o2, %i5                             
  rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",                  
40006294:	90 10 00 1b 	mov  %i3, %o0                                  
40006298:	13 10 00 d3 	sethi  %hi(0x40034c00), %o1                    
4000629c:	7f ff f9 75 	call  40004870 <rtems_fdisk_printf>            
400062a0:	92 12 61 20 	or  %o1, 0x120, %o1	! 40034d20 <__FUNCTION__.6193+0xc58>
                      count, rtems_fdisk_segment_queue_count (&fd->failed));
                                                                      
  count = 0;                                                          
  for (device = 0; device < fd->device_count; device++)               
400062a4:	c4 06 e0 30 	ld  [ %i3 + 0x30 ], %g2                        
400062a8:	80 a0 a0 00 	cmp  %g2, 0                                    
400062ac:	02 80 00 db 	be  40006618 <rtems_fdisk_ioctl+0x9c4>         <== NEVER TAKEN
400062b0:	87 28 a0 02 	sll  %g2, 2, %g3                               
400062b4:	c2 06 e0 2c 	ld  [ %i3 + 0x2c ], %g1                        
  count = rtems_fdisk_segment_count_queue (&fd->failed);              
  total += count;                                                     
  rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",                  
                      count, rtems_fdisk_segment_queue_count (&fd->failed));
                                                                      
  count = 0;                                                          
400062b8:	96 10 20 00 	clr  %o3                                       
 * @param req IOCTL request code.                                     
 * @param argp IOCTL argument.                                        
 * @retval The IOCTL return value                                     
 */                                                                   
static int                                                            
rtems_fdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)   
400062bc:	85 28 a0 04 	sll  %g2, 4, %g2                               
400062c0:	84 20 80 03 	sub  %g2, %g3, %g2                             
400062c4:	84 00 80 01 	add  %g2, %g1, %g2                             
  rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",                  
                      count, rtems_fdisk_segment_queue_count (&fd->failed));
                                                                      
  count = 0;                                                          
  for (device = 0; device < fd->device_count; device++)               
    count += fd->devices[device].segment_count;                       
400062c8:	c6 00 60 04 	ld  [ %g1 + 4 ], %g3                           
400062cc:	82 00 60 0c 	add  %g1, 0xc, %g1                             
  total += count;                                                     
  rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",                  
                      count, rtems_fdisk_segment_queue_count (&fd->failed));
                                                                      
  count = 0;                                                          
  for (device = 0; device < fd->device_count; device++)               
400062d0:	80 a0 40 02 	cmp  %g1, %g2                                  
400062d4:	12 bf ff fd 	bne  400062c8 <rtems_fdisk_ioctl+0x674>        <== NEVER TAKEN
400062d8:	96 02 c0 03 	add  %o3, %g3, %o3                             
    count += fd->devices[device].segment_count;                       
                                                                      
  rtems_fdisk_printf (fd, "Queue total\t%ld of %ld, %s", total, count,
400062dc:	19 10 00 d2 	sethi  %hi(0x40034800), %o4                    
400062e0:	80 a7 40 0b 	cmp  %i5, %o3                                  
400062e4:	02 80 02 71 	be  40006ca8 <rtems_fdisk_ioctl+0x1054>        <== ALWAYS TAKEN
400062e8:	98 13 20 20 	or  %o4, 0x20, %o4                             
400062ec:	94 10 00 1d 	mov  %i5, %o2                                  
400062f0:	90 10 00 1b 	mov  %i3, %o0                                  
400062f4:	13 10 00 d3 	sethi  %hi(0x40034c00), %o1                    
400062f8:	7f ff f9 5e 	call  40004870 <rtems_fdisk_printf>            
400062fc:	92 12 61 38 	or  %o1, 0x138, %o1	! 40034d38 <__FUNCTION__.6193+0xc70>
                      total == count ? "ok" : "MISSING");             
                                                                      
  rtems_fdisk_printf (fd, "Device count\t%d", fd->device_count);      
40006300:	d4 06 e0 30 	ld  [ %i3 + 0x30 ], %o2                        
40006304:	90 10 00 1b 	mov  %i3, %o0                                  
40006308:	13 10 00 d3 	sethi  %hi(0x40034c00), %o1                    
4000630c:	7f ff f9 59 	call  40004870 <rtems_fdisk_printf>            
40006310:	92 12 61 58 	or  %o1, 0x158, %o1	! 40034d58 <__FUNCTION__.6193+0xc90>
                                                                      
  for (device = 0; device < fd->device_count; device++)               
40006314:	c2 06 e0 30 	ld  [ %i3 + 0x30 ], %g1                        
40006318:	80 a0 60 00 	cmp  %g1, 0                                    
4000631c:	22 80 00 8e 	be,a   40006554 <rtems_fdisk_ioctl+0x900>      <== NEVER TAKEN
40006320:	fa 06 e0 40 	ld  [ %i3 + 0x40 ], %i5                        <== NOT EXECUTED
40006324:	b0 10 20 00 	clr  %i0                                       
40006328:	c0 27 bf ec 	clr  [ %fp + -20 ]                             
  {                                                                   
    uint32_t block;                                                   
    uint32_t seg;                                                     
                                                                      
    rtems_fdisk_printf (fd, " Device\t\t%ld", device);                
4000632c:	d4 07 bf ec 	ld  [ %fp + -20 ], %o2                         
40006330:	13 10 00 d3 	sethi  %hi(0x40034c00), %o1                    
40006334:	90 10 00 1b 	mov  %i3, %o0                                  
40006338:	7f ff f9 4e 	call  40004870 <rtems_fdisk_printf>            
4000633c:	92 12 61 68 	or  %o1, 0x168, %o1                            
    rtems_fdisk_printf (fd, "  Segment count\t%ld",                   
40006340:	c2 06 e0 2c 	ld  [ %i3 + 0x2c ], %g1                        
40006344:	90 10 00 1b 	mov  %i3, %o0                                  
40006348:	82 00 40 18 	add  %g1, %i0, %g1                             
4000634c:	d4 00 60 04 	ld  [ %g1 + 4 ], %o2                           
40006350:	13 10 00 d3 	sethi  %hi(0x40034c00), %o1                    
40006354:	7f ff f9 47 	call  40004870 <rtems_fdisk_printf>            
40006358:	92 12 61 78 	or  %o1, 0x178, %o1	! 40034d78 <__FUNCTION__.6193+0xcb0>
                        fd->devices[device].segment_count);           
                                                                      
    for (seg = 0; seg < fd->devices[device].segment_count; seg++)     
4000635c:	c2 06 e0 2c 	ld  [ %i3 + 0x2c ], %g1                        
40006360:	82 00 40 18 	add  %g1, %i0, %g1                             
40006364:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
40006368:	80 a0 a0 00 	cmp  %g2, 0                                    
4000636c:	02 80 00 73 	be  40006538 <rtems_fdisk_ioctl+0x8e4>         <== NEVER TAKEN
40006370:	c4 07 bf ec 	ld  [ %fp + -20 ], %g2                         
40006374:	b2 10 20 00 	clr  %i1                                       
40006378:	b4 10 20 00 	clr  %i2                                       
    {                                                                 
      rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[seg];
4000637c:	f8 00 40 00 	ld  [ %g1 ], %i4                               
      uint32_t                 active = 0;                            
      uint32_t                 used = 0;                              
      bool                     is_active = false;                     
      char                     queues[5];                             
                                                                      
      rtems_fdisk_queue_status (fd, sc, queues);                      
40006380:	90 10 00 1b 	mov  %i3, %o0                                  
    rtems_fdisk_printf (fd, "  Segment count\t%ld",                   
                        fd->devices[device].segment_count);           
                                                                      
    for (seg = 0; seg < fd->devices[device].segment_count; seg++)     
    {                                                                 
      rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[seg];
40006384:	b8 07 00 19 	add  %i4, %i1, %i4                             
      uint32_t                 active = 0;                            
      uint32_t                 used = 0;                              
      bool                     is_active = false;                     
      char                     queues[5];                             
                                                                      
      rtems_fdisk_queue_status (fd, sc, queues);                      
40006388:	94 07 bf f8 	add  %fp, -8, %o2                              
4000638c:	7f ff f8 b9 	call  40004670 <rtems_fdisk_queue_status>      
40006390:	92 10 00 1c 	mov  %i4, %o1                                  
                                                                      
      for (page = 0; page < sc->pages; page++)                        
40006394:	d8 07 20 14 	ld  [ %i4 + 0x14 ], %o4                        
40006398:	80 a3 20 00 	cmp  %o4, 0                                    
4000639c:	22 80 00 94 	be,a   400065ec <rtems_fdisk_ioctl+0x998>      <== NEVER TAKEN
400063a0:	c2 06 e0 1c 	ld  [ %i3 + 0x1c ], %g1                        <== NOT EXECUTED
400063a4:	c6 06 e0 1c 	ld  [ %i3 + 0x1c ], %g3                        
      rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[seg];
      uint32_t                 page;                                  
      uint32_t                 erased = 0;                            
      uint32_t                 active = 0;                            
      uint32_t                 used = 0;                              
      bool                     is_active = false;                     
400063a8:	a8 10 20 00 	clr  %l4                                       
400063ac:	82 10 00 03 	mov  %g3, %g1                                  
    for (seg = 0; seg < fd->devices[device].segment_count; seg++)     
    {                                                                 
      rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[seg];
      uint32_t                 page;                                  
      uint32_t                 erased = 0;                            
      uint32_t                 active = 0;                            
400063b0:	ae 10 20 00 	clr  %l7                                       
      uint32_t                 used = 0;                              
400063b4:	ac 10 20 00 	clr  %l6                                       
                                                                      
    for (seg = 0; seg < fd->devices[device].segment_count; seg++)     
    {                                                                 
      rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[seg];
      uint32_t                 page;                                  
      uint32_t                 erased = 0;                            
400063b8:	a2 10 20 00 	clr  %l1                                       
      bool                     is_active = false;                     
      char                     queues[5];                             
                                                                      
      rtems_fdisk_queue_status (fd, sc, queues);                      
                                                                      
      for (page = 0; page < sc->pages; page++)                        
400063bc:	a4 10 20 00 	clr  %l2                                       
      {                                                               
        if (rtems_fdisk_page_desc_erased (&sc->page_descriptors[page]))
400063c0:	c8 07 20 10 	ld  [ %i4 + 0x10 ], %g4                        
 * @param req IOCTL request code.                                     
 * @param argp IOCTL argument.                                        
 * @retval The IOCTL return value                                     
 */                                                                   
static int                                                            
rtems_fdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)   
400063c4:	85 2c a0 03 	sll  %l2, 3, %g2                               
static bool                                                           
rtems_fdisk_page_desc_erased (const rtems_fdisk_page_desc* pd)        
{                                                                     
  return ((pd->crc == 0xffff) &&                                      
          (pd->flags == 0xffff) &&                                    
          (pd->block == 0xffffffff)) ? true : false;                  
400063c8:	fa 01 00 02 	ld  [ %g4 + %g2 ], %i5                         
400063cc:	80 a7 7f ff 	cmp  %i5, -1                                   
400063d0:	02 80 00 7d 	be  400065c4 <rtems_fdisk_ioctl+0x970>         
400063d4:	84 01 00 02 	add  %g4, %g2, %g2                             
 * only set a flag by changing it from 1 to 0.                        
 */                                                                   
static bool                                                           
rtems_fdisk_page_desc_flags_set (rtems_fdisk_page_desc* pd, uint16_t flags)
{                                                                     
  return (pd->flags & flags) == 0 ? true : false;                     
400063d8:	c4 10 a0 02 	lduh  [ %g2 + 2 ], %g2                         
                                                                      
      for (page = 0; page < sc->pages; page++)                        
      {                                                               
        if (rtems_fdisk_page_desc_erased (&sc->page_descriptors[page]))
          erased++;                                                   
        else if (rtems_fdisk_page_desc_flags_set (&sc->page_descriptors[page],
400063dc:	80 88 a0 01 	btst  1, %g2                                   
400063e0:	12 80 00 07 	bne  400063fc <rtems_fdisk_ioctl+0x7a8>        <== NEVER TAKEN
400063e4:	80 a0 e0 00 	cmp  %g3, 0                                    
                                                  RTEMS_FDISK_PAGE_ACTIVE))
        {                                                             
          if (rtems_fdisk_page_desc_flags_set (&sc->page_descriptors[page],
400063e8:	80 88 a0 02 	btst  2, %g2                                   
400063ec:	32 80 00 7c 	bne,a   400065dc <rtems_fdisk_ioctl+0x988>     
400063f0:	ae 05 e0 01 	inc  %l7                                       
                                               RTEMS_FDISK_PAGE_USED))
            used++;                                                   
400063f4:	ac 05 a0 01 	inc  %l6                                       
            active++;                                                 
            is_active = true;                                         
          }                                                           
        }                                                             
                                                                      
        for (block = 0; block < fd->block_count; block++)             
400063f8:	80 a0 e0 00 	cmp  %g3, 0                                    
400063fc:	22 80 00 23 	be,a   40006488 <rtems_fdisk_ioctl+0x834>      <== NEVER TAKEN
40006400:	a4 04 a0 01 	inc  %l2                                       <== NOT EXECUTED
40006404:	ba 10 20 00 	clr  %i5                                       
        {                                                             
          if ((fd->blocks[block].segment == sc) &&                    
              (fd->blocks[block].page == page) && !is_active)         
40006408:	10 80 00 06 	b  40006420 <rtems_fdisk_ioctl+0x7cc>          
4000640c:	a6 0d 20 ff 	and  %l4, 0xff, %l3                            
            active++;                                                 
            is_active = true;                                         
          }                                                           
        }                                                             
                                                                      
        for (block = 0; block < fd->block_count; block++)             
40006410:	ba 07 60 01 	inc  %i5                                       
40006414:	80 a7 40 03 	cmp  %i5, %g3                                  
40006418:	1a 80 00 1a 	bcc  40006480 <rtems_fdisk_ioctl+0x82c>        
4000641c:	82 10 00 03 	mov  %g3, %g1                                  
        {                                                             
          if ((fd->blocks[block].segment == sc) &&                    
40006420:	c4 06 e0 18 	ld  [ %i3 + 0x18 ], %g2                        
 * @param req IOCTL request code.                                     
 * @param argp IOCTL argument.                                        
 * @retval The IOCTL return value                                     
 */                                                                   
static int                                                            
rtems_fdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)   
40006424:	83 2f 60 03 	sll  %i5, 3, %g1                               
          }                                                           
        }                                                             
                                                                      
        for (block = 0; block < fd->block_count; block++)             
        {                                                             
          if ((fd->blocks[block].segment == sc) &&                    
40006428:	c8 00 80 01 	ld  [ %g2 + %g1 ], %g4                         
4000642c:	80 a7 00 04 	cmp  %i4, %g4                                  
40006430:	12 bf ff f8 	bne  40006410 <rtems_fdisk_ioctl+0x7bc>        
40006434:	82 00 80 01 	add  %g2, %g1, %g1                             
40006438:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
4000643c:	80 a4 80 01 	cmp  %l2, %g1                                  
40006440:	32 bf ff f5 	bne,a   40006414 <rtems_fdisk_ioctl+0x7c0>     
40006444:	ba 07 60 01 	inc  %i5                                       
              (fd->blocks[block].page == page) && !is_active)         
40006448:	80 a4 e0 00 	cmp  %l3, 0                                    
4000644c:	32 bf ff f2 	bne,a   40006414 <rtems_fdisk_ioctl+0x7c0>     <== ALWAYS TAKEN
40006450:	ba 07 60 01 	inc  %i5                                       
            rtems_fdisk_printf (fd,                                   
40006454:	96 10 00 1d 	mov  %i5, %o3                                  <== NOT EXECUTED
40006458:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
4000645c:	13 10 00 d3 	sethi  %hi(0x40034c00), %o1                    <== NOT EXECUTED
40006460:	94 10 00 12 	mov  %l2, %o2                                  <== NOT EXECUTED
40006464:	7f ff f9 03 	call  40004870 <rtems_fdisk_printf>            <== NOT EXECUTED
40006468:	92 12 61 90 	or  %o1, 0x190, %o1                            <== NOT EXECUTED
4000646c:	c6 06 e0 1c 	ld  [ %i3 + 0x1c ], %g3                        <== NOT EXECUTED
            active++;                                                 
            is_active = true;                                         
          }                                                           
        }                                                             
                                                                      
        for (block = 0; block < fd->block_count; block++)             
40006470:	ba 07 60 01 	inc  %i5                                       <== NOT EXECUTED
40006474:	80 a7 40 03 	cmp  %i5, %g3                                  <== NOT EXECUTED
40006478:	0a bf ff ea 	bcs  40006420 <rtems_fdisk_ioctl+0x7cc>        <== NOT EXECUTED
4000647c:	82 10 00 03 	mov  %g3, %g1                                  <== NOT EXECUTED
40006480:	d8 07 20 14 	ld  [ %i4 + 0x14 ], %o4                        
      bool                     is_active = false;                     
      char                     queues[5];                             
                                                                      
      rtems_fdisk_queue_status (fd, sc, queues);                      
                                                                      
      for (page = 0; page < sc->pages; page++)                        
40006484:	a4 04 a0 01 	inc  %l2                                       
40006488:	80 a4 80 0c 	cmp  %l2, %o4                                  
4000648c:	2a bf ff ce 	bcs,a   400063c4 <rtems_fdisk_ioctl+0x770>     
40006490:	c8 07 20 10 	ld  [ %i4 + 0x10 ], %g4                        
                                page, block);                         
        }                                                             
      }                                                               
                                                                      
      count = 0;                                                      
      for (block = 0; block < fd->block_count; block++)               
40006494:	80 a0 60 00 	cmp  %g1, 0                                    
40006498:	02 80 00 53 	be  400065e4 <rtems_fdisk_ioctl+0x990>         <== NEVER TAKEN
4000649c:	83 28 60 03 	sll  %g1, 3, %g1                               
400064a0:	fa 06 e0 18 	ld  [ %i3 + 0x18 ], %i5                        
 * @param req IOCTL request code.                                     
 * @param argp IOCTL argument.                                        
 * @retval The IOCTL return value                                     
 */                                                                   
static int                                                            
rtems_fdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)   
400064a4:	84 10 20 00 	clr  %g2                                       
400064a8:	86 10 20 00 	clr  %g3                                       
      }                                                               
                                                                      
      count = 0;                                                      
      for (block = 0; block < fd->block_count; block++)               
      {                                                               
        if (fd->blocks[block].segment == sc)                          
400064ac:	c8 07 40 02 	ld  [ %i5 + %g2 ], %g4                         
400064b0:	84 00 a0 08 	add  %g2, 8, %g2                               
          count++;                                                    
400064b4:	88 1f 00 04 	xor  %i4, %g4, %g4                             
400064b8:	80 a0 00 04 	cmp  %g0, %g4                                  
400064bc:	86 60 ff ff 	subx  %g3, -1, %g3                             
                                page, block);                         
        }                                                             
      }                                                               
                                                                      
      count = 0;                                                      
      for (block = 0; block < fd->block_count; block++)               
400064c0:	80 a0 80 01 	cmp  %g2, %g1                                  
400064c4:	32 bf ff fb 	bne,a   400064b0 <rtems_fdisk_ioctl+0x85c>     
400064c8:	c8 07 40 02 	ld  [ %i5 + %g2 ], %g4                         
                          " u:%3ld/%3ld e:%3ld/%3ld br:%ld",          
                          seg, queues,                                
                          sc->pages, sc->pages_active, active,        
                          sc->pages_used, used, erased,               
                          sc->pages - (sc->pages_active +             
                                       sc->pages_used + sc->pages_bad),
400064cc:	c4 07 20 20 	ld  [ %i4 + 0x20 ], %g2                        
      rtems_fdisk_printf (fd, "  %3ld %s p:%3ld a:%3ld/%3ld" \        
                          " u:%3ld/%3ld e:%3ld/%3ld br:%ld",          
                          seg, queues,                                
                          sc->pages, sc->pages_active, active,        
                          sc->pages_used, used, erased,               
                          sc->pages - (sc->pages_active +             
400064d0:	c2 07 20 1c 	ld  [ %i4 + 0x1c ], %g1                        
      {                                                               
        if (fd->blocks[block].segment == sc)                          
          count++;                                                    
      }                                                               
                                                                      
      rtems_fdisk_printf (fd, "  %3ld %s p:%3ld a:%3ld/%3ld" \        
400064d4:	c4 23 a0 60 	st  %g2, [ %sp + 0x60 ]                        
400064d8:	ee 23 a0 5c 	st  %l7, [ %sp + 0x5c ]                        
400064dc:	ec 23 a0 64 	st  %l6, [ %sp + 0x64 ]                        
400064e0:	e2 23 a0 68 	st  %l1, [ %sp + 0x68 ]                        
 * @param req IOCTL request code.                                     
 * @param argp IOCTL argument.                                        
 * @retval The IOCTL return value                                     
 */                                                                   
static int                                                            
rtems_fdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)   
400064e4:	c8 07 20 24 	ld  [ %i4 + 0x24 ], %g4                        
      {                                                               
        if (fd->blocks[block].segment == sc)                          
          count++;                                                    
      }                                                               
                                                                      
      rtems_fdisk_printf (fd, "  %3ld %s p:%3ld a:%3ld/%3ld" \        
400064e8:	94 10 00 1a 	mov  %i2, %o2                                  
 * @param req IOCTL request code.                                     
 * @param argp IOCTL argument.                                        
 * @retval The IOCTL return value                                     
 */                                                                   
static int                                                            
rtems_fdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)   
400064ec:	84 00 80 04 	add  %g2, %g4, %g2                             
400064f0:	84 00 80 01 	add  %g2, %g1, %g2                             
      {                                                               
        if (fd->blocks[block].segment == sc)                          
          count++;                                                    
      }                                                               
                                                                      
      rtems_fdisk_printf (fd, "  %3ld %s p:%3ld a:%3ld/%3ld" \        
400064f4:	84 23 00 02 	sub  %o4, %g2, %g2                             
400064f8:	9a 10 00 01 	mov  %g1, %o5                                  
400064fc:	c4 23 a0 6c 	st  %g2, [ %sp + 0x6c ]                        
40006500:	c6 23 a0 70 	st  %g3, [ %sp + 0x70 ]                        
40006504:	90 10 00 1b 	mov  %i3, %o0                                  
40006508:	13 10 00 d3 	sethi  %hi(0x40034c00), %o1                    
4000650c:	96 07 bf f8 	add  %fp, -8, %o3                              
40006510:	7f ff f8 d8 	call  40004870 <rtems_fdisk_printf>            
40006514:	92 12 61 c0 	or  %o1, 0x1c0, %o1                            
                                                                      
    rtems_fdisk_printf (fd, " Device\t\t%ld", device);                
    rtems_fdisk_printf (fd, "  Segment count\t%ld",                   
                        fd->devices[device].segment_count);           
                                                                      
    for (seg = 0; seg < fd->devices[device].segment_count; seg++)     
40006518:	c2 06 e0 2c 	ld  [ %i3 + 0x2c ], %g1                        
4000651c:	b4 06 a0 01 	inc  %i2                                       
40006520:	82 00 40 18 	add  %g1, %i0, %g1                             
40006524:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
40006528:	80 a6 80 02 	cmp  %i2, %g2                                  
4000652c:	0a bf ff 94 	bcs  4000637c <rtems_fdisk_ioctl+0x728>        
40006530:	b2 06 60 30 	add  %i1, 0x30, %i1                            
  rtems_fdisk_printf (fd, "Queue total\t%ld of %ld, %s", total, count,
                      total == count ? "ok" : "MISSING");             
                                                                      
  rtems_fdisk_printf (fd, "Device count\t%d", fd->device_count);      
                                                                      
  for (device = 0; device < fd->device_count; device++)               
40006534:	c4 07 bf ec 	ld  [ %fp + -20 ], %g2                         
40006538:	c2 06 e0 30 	ld  [ %i3 + 0x30 ], %g1                        
4000653c:	84 00 a0 01 	inc  %g2                                       
40006540:	c4 27 bf ec 	st  %g2, [ %fp + -20 ]                         
40006544:	80 a0 80 01 	cmp  %g2, %g1                                  
40006548:	0a bf ff 79 	bcs  4000632c <rtems_fdisk_ioctl+0x6d8>        <== NEVER TAKEN
4000654c:	b0 06 20 0c 	add  %i0, 0xc, %i0                             
                          count);                                     
    }                                                                 
  }                                                                   
                                                                      
  {                                                                   
    rtems_fdisk_segment_ctl* sc = fd->used.head;                      
40006550:	fa 06 e0 40 	ld  [ %i3 + 0x40 ], %i5                        
    int count = 0;                                                    
    rtems_fdisk_printf (fd, "Used List:");                            
40006554:	90 10 00 1b 	mov  %i3, %o0                                  
40006558:	13 10 00 d3 	sethi  %hi(0x40034c00), %o1                    
4000655c:	7f ff f8 c5 	call  40004870 <rtems_fdisk_printf>            
40006560:	92 12 62 00 	or  %o1, 0x200, %o1	! 40034e00 <__FUNCTION__.6193+0xd38>
    while (sc)                                                        
40006564:	80 a7 60 00 	cmp  %i5, 0                                    
40006568:	02 80 00 11 	be  400065ac <rtems_fdisk_ioctl+0x958>         <== NEVER TAKEN
4000656c:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
    {                                                                 
      rtems_fdisk_printf (fd, "  %3d %02d:%03d u:%3ld",               
40006570:	35 10 00 d3 	sethi  %hi(0x40034c00), %i2                    
                                                                      
  {                                                                   
    rtems_fdisk_segment_ctl* sc = fd->used.head;                      
    int count = 0;                                                    
    rtems_fdisk_printf (fd, "Used List:");                            
    while (sc)                                                        
40006574:	b8 10 20 00 	clr  %i4                                       
    {                                                                 
      rtems_fdisk_printf (fd, "  %3d %02d:%03d u:%3ld",               
40006578:	b4 16 a2 10 	or  %i2, 0x210, %i2                            
4000657c:	d6 07 60 08 	ld  [ %i5 + 8 ], %o3                           
40006580:	d8 07 60 0c 	ld  [ %i5 + 0xc ], %o4                         
40006584:	da 07 60 20 	ld  [ %i5 + 0x20 ], %o5                        
40006588:	94 10 00 1c 	mov  %i4, %o2                                  
4000658c:	90 10 00 1b 	mov  %i3, %o0                                  
40006590:	7f ff f8 b8 	call  40004870 <rtems_fdisk_printf>            
40006594:	92 10 00 1a 	mov  %i2, %o1                                  
                          count, sc->device, sc->segment, sc->pages_used);
      sc = sc->next;                                                  
40006598:	fa 07 40 00 	ld  [ %i5 ], %i5                               
                                                                      
  {                                                                   
    rtems_fdisk_segment_ctl* sc = fd->used.head;                      
    int count = 0;                                                    
    rtems_fdisk_printf (fd, "Used List:");                            
    while (sc)                                                        
4000659c:	80 a7 60 00 	cmp  %i5, 0                                    
400065a0:	12 bf ff f7 	bne  4000657c <rtems_fdisk_ioctl+0x928>        
400065a4:	b8 07 20 01 	inc  %i4                                       
                          count, sc->device, sc->segment, sc->pages_used);
      sc = sc->next;                                                  
      count++;                                                        
    }                                                                 
  }                                                                   
  fd->info_level = current_info_level;                                
400065a8:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
400065ac:	c4 04 20 d8 	ld  [ %l0 + 0xd8 ], %g2                        
400065b0:	c2 26 e0 6c 	st  %g1, [ %i3 + 0x6c ]                        
      case RTEMS_FDISK_IOCTL_INFO_LEVEL:                              
        rtems_flashdisks[minor].info_level = (uintptr_t) argp;        
        break;                                                        
                                                                      
      case RTEMS_FDISK_IOCTL_PRINT_STATUS:                            
        errno = rtems_fdisk_print_status (&rtems_flashdisks[minor]);  
400065b4:	c2 07 bf e8 	ld  [ %fp + -24 ], %g1                         
400065b8:	84 00 80 15 	add  %g2, %l5, %g2                             
        break;                                                        
400065bc:	10 bf fe 8b 	b  40005fe8 <rtems_fdisk_ioctl+0x394>          
400065c0:	c0 20 40 00 	clr  [ %g1 ]                                   
static bool                                                           
rtems_fdisk_page_desc_erased (const rtems_fdisk_page_desc* pd)        
{                                                                     
  return ((pd->crc == 0xffff) &&                                      
          (pd->flags == 0xffff) &&                                    
          (pd->block == 0xffffffff)) ? true : false;                  
400065c4:	c8 00 a0 04 	ld  [ %g2 + 4 ], %g4                           
400065c8:	80 a1 3f ff 	cmp  %g4, -1                                   
400065cc:	32 bf ff 84 	bne,a   400063dc <rtems_fdisk_ioctl+0x788>     <== NEVER TAKEN
400065d0:	c4 10 a0 02 	lduh  [ %g2 + 2 ], %g2                         <== NOT EXECUTED
      rtems_fdisk_queue_status (fd, sc, queues);                      
                                                                      
      for (page = 0; page < sc->pages; page++)                        
      {                                                               
        if (rtems_fdisk_page_desc_erased (&sc->page_descriptors[page]))
          erased++;                                                   
400065d4:	10 bf ff 89 	b  400063f8 <rtems_fdisk_ioctl+0x7a4>          
400065d8:	a2 04 60 01 	inc  %l1                                       
                                               RTEMS_FDISK_PAGE_USED))
            used++;                                                   
          else                                                        
          {                                                           
            active++;                                                 
            is_active = true;                                         
400065dc:	10 bf ff 87 	b  400063f8 <rtems_fdisk_ioctl+0x7a4>          
400065e0:	a8 10 20 01 	mov  1, %l4                                    
                                page, block);                         
        }                                                             
      }                                                               
                                                                      
      count = 0;                                                      
      for (block = 0; block < fd->block_count; block++)               
400065e4:	10 bf ff ba 	b  400064cc <rtems_fdisk_ioctl+0x878>          <== NOT EXECUTED
400065e8:	86 10 20 00 	clr  %g3                                       <== NOT EXECUTED
    for (seg = 0; seg < fd->devices[device].segment_count; seg++)     
    {                                                                 
      rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[seg];
      uint32_t                 page;                                  
      uint32_t                 erased = 0;                            
      uint32_t                 active = 0;                            
400065ec:	ae 10 20 00 	clr  %l7                                       <== NOT EXECUTED
      uint32_t                 used = 0;                              
400065f0:	ac 10 20 00 	clr  %l6                                       <== NOT EXECUTED
                                                                      
    for (seg = 0; seg < fd->devices[device].segment_count; seg++)     
    {                                                                 
      rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[seg];
      uint32_t                 page;                                  
      uint32_t                 erased = 0;                            
400065f4:	10 bf ff a8 	b  40006494 <rtems_fdisk_ioctl+0x840>          <== NOT EXECUTED
400065f8:	a2 10 20 00 	clr  %l1                                       <== NOT EXECUTED
    {                                                                 
      case RTEMS_BLKIO_REQUEST:                                       
        if ((minor >= rtems_flashdisk_count) ||                       
            (rtems_flashdisks[minor].device_count == 0))              
        {                                                             
          errno = ENODEV;                                             
400065fc:	40 00 70 cf 	call  40022938 <__errno>                       <== NOT EXECUTED
40006600:	01 00 00 00 	nop                                            <== NOT EXECUTED
40006604:	c4 04 20 d8 	ld  [ %l0 + 0xd8 ], %g2                        <== NOT EXECUTED
40006608:	82 10 20 13 	mov  0x13, %g1                                 <== NOT EXECUTED
4000660c:	84 00 80 15 	add  %g2, %l5, %g2                             <== NOT EXECUTED
40006610:	10 bf fe 76 	b  40005fe8 <rtems_fdisk_ioctl+0x394>          <== NOT EXECUTED
40006614:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
  count = rtems_fdisk_segment_count_queue (&fd->failed);              
  total += count;                                                     
  rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",                  
                      count, rtems_fdisk_segment_queue_count (&fd->failed));
                                                                      
  count = 0;                                                          
40006618:	10 bf ff 31 	b  400062dc <rtems_fdisk_ioctl+0x688>          <== NOT EXECUTED
4000661c:	96 10 20 00 	clr  %o3                                       <== NOT EXECUTED
            case RTEMS_BLKDEV_REQ_READ:                               
              errno = rtems_fdisk_read (&rtems_flashdisks[minor], r); 
              break;                                                  
                                                                      
            case RTEMS_BLKDEV_REQ_WRITE:                              
              errno = rtems_fdisk_write (&rtems_flashdisks[minor], r);
40006620:	40 00 70 c6 	call  40022938 <__errno>                       
40006624:	a8 06 a0 28 	add  %i2, 0x28, %l4                            
40006628:	fa 04 20 d8 	ld  [ %l0 + 0xd8 ], %i5                        
4000662c:	f8 06 a0 10 	ld  [ %i2 + 0x10 ], %i4                        
40006630:	d0 27 bf e0 	st  %o0, [ %fp + -32 ]                         
40006634:	ba 07 40 15 	add  %i5, %l5, %i5                             
 * @param req IOCTL request code.                                     
 * @param argp IOCTL argument.                                        
 * @retval The IOCTL return value                                     
 */                                                                   
static int                                                            
rtems_fdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)   
40006638:	ac 10 20 01 	mov  1, %l6                                    
4000663c:	f4 27 bf ec 	st  %i2, [ %fp + -20 ]                         
40006640:	ea 27 bf e8 	st  %l5, [ %fp + -24 ]                         
{                                                                     
  rtems_blkdev_sg_buffer* sg = req->bufs;                             
  uint32_t                buf;                                        
  int                     ret = 0;                                    
                                                                      
  for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)       
40006644:	82 05 bf ff 	add  %l6, -1, %g1                              
40006648:	80 a0 40 1c 	cmp  %g1, %i4                                  
4000664c:	3a 80 02 7d 	bcc,a   40007040 <rtems_fdisk_ioctl+0x13ec>    
40006650:	f4 07 bf ec 	ld  [ %fp + -20 ], %i2                         
  {                                                                   
    uint8_t* data;                                                    
    uint32_t fb;                                                      
    uint32_t b;                                                       
    fb = sg->length / fd->block_size;                                 
40006654:	d0 05 3f f4 	ld  [ %l4 + -12 ], %o0                         
40006658:	7f ff f0 12 	call  400026a0 <.udiv>                         
4000665c:	d2 07 60 14 	ld  [ %i5 + 0x14 ], %o1                        
40006660:	d0 27 bf e4 	st  %o0, [ %fp + -28 ]                         
    data = sg->buffer;                                                
    for (b = 0; b < fb; b++, data += fd->block_size)                  
40006664:	80 a2 20 00 	cmp  %o0, 0                                    
40006668:	02 80 01 0e 	be  40006aa0 <rtems_fdisk_ioctl+0xe4c>         <== NEVER TAKEN
4000666c:	f4 05 3f f8 	ld  [ %l4 + -8 ], %i2                          
40006670:	b2 10 20 00 	clr  %i1                                       
40006674:	ec 27 bf dc 	st  %l6, [ %fp + -36 ]                         
    {                                                                 
      ret = rtems_fdisk_write_block (fd, sg->block + b, data);        
40006678:	ee 05 3f f0 	ld  [ %l4 + -16 ], %l7                         
  rtems_fdisk_page_desc*   pd;                                        
  uint32_t                 page;                                      
  int                      ret;                                       
                                                                      
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_info (fd, "write-block:%d", block);                     
4000667c:	05 10 00 d2 	sethi  %hi(0x40034800), %g2                    
    uint32_t b;                                                       
    fb = sg->length / fd->block_size;                                 
    data = sg->buffer;                                                
    for (b = 0; b < fb; b++, data += fd->block_size)                  
    {                                                                 
      ret = rtems_fdisk_write_block (fd, sg->block + b, data);        
40006680:	ae 06 40 17 	add  %i1, %l7, %l7                             
  rtems_fdisk_page_desc*   pd;                                        
  uint32_t                 page;                                      
  int                      ret;                                       
                                                                      
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_info (fd, "write-block:%d", block);                     
40006684:	92 10 a1 a8 	or  %g2, 0x1a8, %o1                            
40006688:	90 10 00 1d 	mov  %i5, %o0                                  
4000668c:	7f ff f8 57 	call  400047e8 <rtems_fdisk_info>              
40006690:	94 10 00 17 	mov  %l7, %o2                                  
                                                                      
  /*                                                                  
   * Broken out to allow info messages when testing.                  
   */                                                                 
                                                                      
  if (block >= (fd->block_count - fd->unavail_blocks))                
40006694:	c4 07 60 1c 	ld  [ %i5 + 0x1c ], %g2                        
40006698:	c2 07 60 20 	ld  [ %i5 + 0x20 ], %g1                        
4000669c:	82 20 80 01 	sub  %g2, %g1, %g1                             
400066a0:	80 a5 c0 01 	cmp  %l7, %g1                                  
400066a4:	1a 80 01 02 	bcc  40006aac <rtems_fdisk_ioctl+0xe58>        <== NEVER TAKEN
400066a8:	11 10 00 d2 	sethi  %hi(0x40034800), %o0                    
  {                                                                   
    rtems_fdisk_error ("write-block: block out of range: %d", block); 
    return EIO;                                                       
  }                                                                   
                                                                      
  bc = &fd->blocks[block];                                            
400066ac:	e6 07 60 18 	ld  [ %i5 + 0x18 ], %l3                        
400066b0:	a5 2d e0 03 	sll  %l7, 3, %l2                               
                                                                      
  /*                                                                  
   * Does the page exist in flash ?                                   
   */                                                                 
  if (bc->segment)                                                    
400066b4:	f8 04 c0 12 	ld  [ %l3 + %l2 ], %i4                         
400066b8:	80 a7 20 00 	cmp  %i4, 0                                    
400066bc:	02 80 00 6d 	be  40006870 <rtems_fdisk_ioctl+0xc1c>         
400066c0:	a2 04 c0 12 	add  %l3, %l2, %l1                             
  {                                                                   
    sc = bc->segment;                                                 
    pd = &sc->page_descriptors[bc->page];                             
400066c4:	c2 04 60 04 	ld  [ %l1 + 4 ], %g1                           
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_info (fd, " write:%02d-%03d-%03d: flag used",         
400066c8:	d4 07 20 08 	ld  [ %i4 + 8 ], %o2                           
400066cc:	d6 07 20 0c 	ld  [ %i4 + 0xc ], %o3                         
   * Does the page exist in flash ?                                   
   */                                                                 
  if (bc->segment)                                                    
  {                                                                   
    sc = bc->segment;                                                 
    pd = &sc->page_descriptors[bc->page];                             
400066d0:	f0 07 20 10 	ld  [ %i4 + 0x10 ], %i0                        
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_info (fd, " write:%02d-%03d-%03d: flag used",         
400066d4:	98 10 00 01 	mov  %g1, %o4                                  
   * Does the page exist in flash ?                                   
   */                                                                 
  if (bc->segment)                                                    
  {                                                                   
    sc = bc->segment;                                                 
    pd = &sc->page_descriptors[bc->page];                             
400066d8:	83 28 60 03 	sll  %g1, 3, %g1                               
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_info (fd, " write:%02d-%03d-%03d: flag used",         
400066dc:	90 10 00 1d 	mov  %i5, %o0                                  
   * Does the page exist in flash ?                                   
   */                                                                 
  if (bc->segment)                                                    
  {                                                                   
    sc = bc->segment;                                                 
    pd = &sc->page_descriptors[bc->page];                             
400066e0:	b0 06 00 01 	add  %i0, %g1, %i0                             
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_info (fd, " write:%02d-%03d-%03d: flag used",         
400066e4:	13 10 00 d2 	sethi  %hi(0x40034800), %o1                    
400066e8:	7f ff f8 40 	call  400047e8 <rtems_fdisk_info>              
400066ec:	92 12 61 e0 	or  %o1, 0x1e0, %o1	! 400349e0 <__FUNCTION__.6193+0x918>
#endif                                                                
                                                                      
    /*                                                                
     * The page exists in flash so see if the page has been changed.  
     */                                                               
    if (rtems_fdisk_seg_verify_page (fd, sc->device, sc->segment,     
400066f0:	c4 04 60 04 	ld  [ %l1 + 4 ], %g2                           
                             uint32_t               segment,          
                             uint32_t               page,             
                             const void*            buffer)           
{                                                                     
  return rtems_fdisk_seg_verify (fd, device, segment,                 
                                 page * fd->block_size, buffer, fd->block_size);
400066f4:	ec 07 60 14 	ld  [ %i5 + 0x14 ], %l6                        
#endif                                                                
                                                                      
    /*                                                                
     * The page exists in flash so see if the page has been changed.  
     */                                                               
    if (rtems_fdisk_seg_verify_page (fd, sc->device, sc->segment,     
400066f8:	d0 07 20 18 	ld  [ %i4 + 0x18 ], %o0                        
400066fc:	ea 07 20 08 	ld  [ %i4 + 8 ], %l5                           
                             uint32_t               device,           
                             uint32_t               segment,          
                             uint32_t               page,             
                             const void*            buffer)           
{                                                                     
  return rtems_fdisk_seg_verify (fd, device, segment,                 
40006700:	92 10 00 16 	mov  %l6, %o1                                  
40006704:	7f ff ef ad 	call  400025b8 <.umul>                         
40006708:	90 02 00 02 	add  %o0, %g2, %o0                             
static const rtems_fdisk_segment_desc*                                
rtems_fdisk_seg_descriptor (const rtems_flashdisk* fd,                
                            uint32_t               device,            
                            uint32_t               segment)           
{                                                                     
  return fd->devices[device].segments[segment].descriptor;            
4000670c:	c8 07 60 2c 	ld  [ %i5 + 0x2c ], %g4                        
40006710:	b7 2d 60 04 	sll  %l5, 4, %i3                               
40006714:	87 2d 60 02 	sll  %l5, 2, %g3                               
40006718:	86 26 c0 03 	sub  %i3, %g3, %g3                             
4000671c:	b6 01 00 03 	add  %g4, %g3, %i3                             
40006720:	de 01 00 03 	ld  [ %g4 + %g3 ], %o7                         
                        uint32_t               size)                  
{                                                                     
  const rtems_fdisk_segment_desc*    sd;                              
  const rtems_fdisk_driver_handlers* ops;                             
  sd  = rtems_fdisk_seg_descriptor (fd, device, segment);             
  ops = fd->devices[device].descriptor->flash_ops;                    
40006724:	da 06 e0 08 	ld  [ %i3 + 8 ], %o5                           
#endif                                                                
                                                                      
    /*                                                                
     * The page exists in flash so see if the page has been changed.  
     */                                                               
    if (rtems_fdisk_seg_verify_page (fd, sc->device, sc->segment,     
40006728:	f6 07 20 0c 	ld  [ %i4 + 0xc ], %i3                         
                        uint32_t               size)                  
{                                                                     
  const rtems_fdisk_segment_desc*    sd;                              
  const rtems_fdisk_driver_handlers* ops;                             
  sd  = rtems_fdisk_seg_descriptor (fd, device, segment);             
  ops = fd->devices[device].descriptor->flash_ops;                    
4000672c:	c6 03 60 08 	ld  [ %o5 + 8 ], %g3                           
static const rtems_fdisk_segment_desc*                                
rtems_fdisk_seg_descriptor (const rtems_flashdisk* fd,                
                            uint32_t               device,            
                            uint32_t               segment)           
{                                                                     
  return fd->devices[device].segments[segment].descriptor;            
40006730:	93 2e e0 06 	sll  %i3, 6, %o1                               
40006734:	89 2e e0 04 	sll  %i3, 4, %g4                               
40006738:	88 22 40 04 	sub  %o1, %g4, %g4                             
4000673c:	88 03 c0 04 	add  %o7, %g4, %g4                             
40006740:	c8 01 20 04 	ld  [ %g4 + 4 ], %g4                           
                             uint32_t               device,           
                             uint32_t               segment,          
                             uint32_t               page,             
                             const void*            buffer)           
{                                                                     
  return rtems_fdisk_seg_verify (fd, device, segment,                 
40006744:	84 10 00 08 	mov  %o0, %g2                                  
  const rtems_fdisk_segment_desc*    sd;                              
  const rtems_fdisk_driver_handlers* ops;                             
  sd  = rtems_fdisk_seg_descriptor (fd, device, segment);             
  ops = fd->devices[device].descriptor->flash_ops;                    
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_printf (fd, "  seg-verify: %02d-%03d: o=%08x s=%d",     
40006748:	98 10 00 08 	mov  %o0, %o4                                  
4000674c:	c4 3f bf d0 	std  %g2, [ %fp + -48 ]                        
40006750:	94 10 00 15 	mov  %l5, %o2                                  
40006754:	96 10 00 1b 	mov  %i3, %o3                                  
40006758:	9a 10 00 16 	mov  %l6, %o5                                  
4000675c:	c8 27 bf cc 	st  %g4, [ %fp + -52 ]                         
40006760:	90 10 00 1d 	mov  %i5, %o0                                  
40006764:	13 10 00 d2 	sethi  %hi(0x40034800), %o1                    
40006768:	7f ff f8 42 	call  40004870 <rtems_fdisk_printf>            
4000676c:	92 12 62 08 	or  %o1, 0x208, %o1	! 40034a08 <__FUNCTION__.6193+0x940>
                      device, segment, offset, size);                 
#endif                                                                
  return ops->verify (sd, device, segment, offset, buffer, size);     
40006770:	c6 07 bf d4 	ld  [ %fp + -44 ], %g3                         
40006774:	c8 07 bf cc 	ld  [ %fp + -52 ], %g4                         
40006778:	c4 07 bf d0 	ld  [ %fp + -48 ], %g2                         
4000677c:	c6 00 e0 0c 	ld  [ %g3 + 0xc ], %g3                         
40006780:	90 10 00 04 	mov  %g4, %o0                                  
40006784:	92 10 00 15 	mov  %l5, %o1                                  
40006788:	94 10 00 1b 	mov  %i3, %o2                                  
4000678c:	96 10 00 02 	mov  %g2, %o3                                  
40006790:	98 10 00 1a 	mov  %i2, %o4                                  
40006794:	9f c0 c0 00 	call  %g3                                      
40006798:	9a 10 00 16 	mov  %l6, %o5                                  
#endif                                                                
                                                                      
    /*                                                                
     * The page exists in flash so see if the page has been changed.  
     */                                                               
    if (rtems_fdisk_seg_verify_page (fd, sc->device, sc->segment,     
4000679c:	80 a2 20 00 	cmp  %o0, 0                                    
400067a0:	22 80 00 f9 	be,a   40006b84 <rtems_fdisk_ioctl+0xf30>      
400067a4:	d6 07 20 08 	ld  [ %i4 + 8 ], %o3                           
 * Set the flags. Setting means clear the bit to 0.                   
 */                                                                   
static void                                                           
rtems_fdisk_page_desc_set_flags (rtems_fdisk_page_desc* pd, uint16_t flags)
{                                                                     
  pd->flags &= ~flags;                                                
400067a8:	c6 16 20 02 	lduh  [ %i0 + 2 ], %g3                         
     * matches the flash device.                                      
     */                                                               
                                                                      
    rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_USED);      
                                                                      
    ret = rtems_fdisk_seg_write_page_desc_flags (fd, sc, bc->page, pd);
400067ac:	c2 04 60 04 	ld  [ %l1 + 4 ], %g1                           
                                       uint32_t                     page,
                                       const rtems_fdisk_page_desc* page_desc)
{                                                                     
  uint32_t offset = ((page * sizeof (rtems_fdisk_page_desc)) +        
                     ((uint8_t*) &page_desc->flags) - ((uint8_t*) page_desc));
  if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))             
400067b0:	c4 07 60 08 	ld  [ %i5 + 8 ], %g2                           
 * Set the flags. Setting means clear the bit to 0.                   
 */                                                                   
static void                                                           
rtems_fdisk_page_desc_set_flags (rtems_fdisk_page_desc* pd, uint16_t flags)
{                                                                     
  pd->flags &= ~flags;                                                
400067b4:	86 08 ff fd 	and  %g3, -3, %g3                              
400067b8:	c6 36 20 02 	sth  %g3, [ %i0 + 2 ]                          
rtems_fdisk_seg_write_page_desc_flags (const rtems_flashdisk*       fd,
                                       rtems_fdisk_segment_ctl*     sc,
                                       uint32_t                     page,
                                       const rtems_fdisk_page_desc* page_desc)
{                                                                     
  uint32_t offset = ((page * sizeof (rtems_fdisk_page_desc)) +        
400067bc:	ab 28 60 03 	sll  %g1, 3, %l5                               
                     ((uint8_t*) &page_desc->flags) - ((uint8_t*) page_desc));
  if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))             
400067c0:	80 88 a0 08 	btst  8, %g2                                   
400067c4:	02 80 00 d6 	be  40006b1c <rtems_fdisk_ioctl+0xec8>         <== NEVER TAKEN
400067c8:	aa 05 60 02 	add  %l5, 2, %l5                               
  {                                                                   
    uint16_t flash_flags;                                             
    int      ret;                                                     
    ret = rtems_fdisk_seg_read (fd, sc, offset,                       
400067cc:	c2 27 bf d8 	st  %g1, [ %fp + -40 ]                         
400067d0:	90 10 00 1d 	mov  %i5, %o0                                  
400067d4:	92 10 00 1c 	mov  %i4, %o1                                  
400067d8:	94 10 00 15 	mov  %l5, %o2                                  
400067dc:	96 07 bf f6 	add  %fp, -10, %o3                             
400067e0:	7f ff f8 46 	call  400048f8 <rtems_fdisk_seg_read>          
400067e4:	98 10 20 02 	mov  2, %o4                                    
                                &flash_flags, sizeof (flash_flags));  
    if (ret)                                                          
400067e8:	b6 92 20 00 	orcc  %o0, 0, %i3                              
400067ec:	12 80 00 d5 	bne  40006b40 <rtems_fdisk_ioctl+0xeec>        <== NEVER TAKEN
400067f0:	c2 07 bf d8 	ld  [ %fp + -40 ], %g1                         
      return ret;                                                     
    if ((flash_flags & page_desc->flags) != page_desc->flags)         
400067f4:	c8 16 20 02 	lduh  [ %i0 + 2 ], %g4                         
400067f8:	c4 17 bf f6 	lduh  [ %fp + -10 ], %g2                       
400067fc:	87 29 20 10 	sll  %g4, 0x10, %g3                            
40006800:	88 08 80 04 	and  %g2, %g4, %g4                             
40006804:	89 29 20 10 	sll  %g4, 0x10, %g4                            
40006808:	80 a1 00 03 	cmp  %g4, %g3                                  
4000680c:	02 80 00 c4 	be  40006b1c <rtems_fdisk_ioctl+0xec8>         <== ALWAYS TAKEN
40006810:	9b 30 e0 10 	srl  %g3, 0x10, %o5                            
    {                                                                 
      rtems_fdisk_error ("  seg-write-page-flags: %02d-%03d-%03d: "   
40006814:	d2 07 20 08 	ld  [ %i4 + 8 ], %o1                           <== NOT EXECUTED
40006818:	d4 07 20 0c 	ld  [ %i4 + 0xc ], %o2                         <== NOT EXECUTED
4000681c:	99 28 a0 10 	sll  %g2, 0x10, %o4                            <== NOT EXECUTED
40006820:	11 10 00 d2 	sethi  %hi(0x40034800), %o0                    <== NOT EXECUTED
40006824:	96 10 00 01 	mov  %g1, %o3                                  <== NOT EXECUTED
40006828:	90 12 22 60 	or  %o0, 0x260, %o0                            <== NOT EXECUTED
4000682c:	7f ff f8 eb 	call  40004bd8 <rtems_fdisk_error>             <== NOT EXECUTED
40006830:	99 33 20 10 	srl  %o4, 0x10, %o4                            <== NOT EXECUTED
                        strerror (ret), ret);                         
#endif                                                                
    }                                                                 
    else                                                              
    {                                                                 
      sc->pages_active--;                                             
40006834:	c4 07 20 1c 	ld  [ %i4 + 0x1c ], %g2                        <== NOT EXECUTED
      sc->pages_used++;                                               
40006838:	c2 07 20 20 	ld  [ %i4 + 0x20 ], %g1                        
                        strerror (ret), ret);                         
#endif                                                                
    }                                                                 
    else                                                              
    {                                                                 
      sc->pages_active--;                                             
4000683c:	84 00 bf ff 	add  %g2, -1, %g2                              
      sc->pages_used++;                                               
40006840:	82 00 60 01 	inc  %g1                                       
                        strerror (ret), ret);                         
#endif                                                                
    }                                                                 
    else                                                              
    {                                                                 
      sc->pages_active--;                                             
40006844:	c4 27 20 1c 	st  %g2, [ %i4 + 0x1c ]                        
      sc->pages_used++;                                               
40006848:	c2 27 20 20 	st  %g1, [ %i4 + 0x20 ]                        
    /*                                                                
     * If possible reuse this segment. This will mean the segment     
     * needs to be removed from the available list and placed         
     * back if space is still available.                              
     */                                                               
    rtems_fdisk_queue_segment (fd, sc);                               
4000684c:	90 10 00 1d 	mov  %i5, %o0                                  
40006850:	7f ff f9 8a 	call  40004e78 <rtems_fdisk_queue_segment>     
40006854:	92 10 00 1c 	mov  %i4, %o1                                  
    /*                                                                
     * If no background compacting then compact in the forground.     
     * If we compact we ignore the error as there is little we        
     * can do from here. The write may will work.                     
     */                                                               
    if ((fd->flags & RTEMS_FDISK_BACKGROUND_COMPACT) == 0)            
40006858:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
4000685c:	80 88 60 02 	btst  2, %g1                                   
40006860:	32 80 00 05 	bne,a   40006874 <rtems_fdisk_ioctl+0xc20>     <== NEVER TAKEN
40006864:	f8 07 60 34 	ld  [ %i5 + 0x34 ], %i4                        <== NOT EXECUTED
      rtems_fdisk_compact (fd);                                       
40006868:	7f ff fb 50 	call  400055a8 <rtems_fdisk_compact>           
4000686c:	90 10 00 1d 	mov  %i5, %o0                                  
 * Count the number of elements on the list.                          
 */                                                                   
static uint32_t                                                       
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{                                                                     
  rtems_fdisk_segment_ctl* sc = queue->head;                          
40006870:	f8 07 60 34 	ld  [ %i5 + 0x34 ], %i4                        
  uint32_t                 count = 0;                                 
                                                                      
  while (sc)                                                          
40006874:	80 a7 20 00 	cmp  %i4, 0                                    
40006878:	02 80 00 e7 	be  40006c14 <rtems_fdisk_ioctl+0xfc0>         <== NEVER TAKEN
4000687c:	82 10 00 1c 	mov  %i4, %g1                                  
40006880:	84 10 20 00 	clr  %g2                                       
  {                                                                   
    count++;                                                          
    sc = sc->next;                                                    
40006884:	c2 00 40 00 	ld  [ %g1 ], %g1                               
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{                                                                     
  rtems_fdisk_segment_ctl* sc = queue->head;                          
  uint32_t                 count = 0;                                 
                                                                      
  while (sc)                                                          
40006888:	80 a0 60 00 	cmp  %g1, 0                                    
4000688c:	12 bf ff fe 	bne  40006884 <rtems_fdisk_ioctl+0xc30>        
40006890:	84 00 a0 01 	inc  %g2                                       
  /*                                                                  
   * Is it time to compact the disk ?                                 
   *                                                                  
   * We override the background compaction configruation.             
   */                                                                 
  if (rtems_fdisk_segment_count_queue (&fd->available) <=             
40006894:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
40006898:	80 a0 40 02 	cmp  %g1, %g2                                  
4000689c:	1a 80 00 de 	bcc  40006c14 <rtems_fdisk_ioctl+0xfc0>        
400068a0:	01 00 00 00 	nop                                            
{                                                                     
  if (queue->head)                                                    
  {                                                                   
    rtems_fdisk_segment_ctl* sc = queue->head;                        
                                                                      
    queue->head = sc->next;                                           
400068a4:	c2 07 00 00 	ld  [ %i4 ], %g1                               
    if (!queue->head)                                                 
400068a8:	80 a0 60 00 	cmp  %g1, 0                                    
400068ac:	02 80 00 d8 	be  40006c0c <rtems_fdisk_ioctl+0xfb8>         
400068b0:	c2 27 60 34 	st  %g1, [ %i5 + 0x34 ]                        
      queue->tail = 0;                                                
                                                                      
    queue->count--;                                                   
400068b4:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        
400068b8:	82 00 7f ff 	add  %g1, -1, %g1                              
400068bc:	c2 27 60 3c 	st  %g1, [ %i5 + 0x3c ]                        
      return ENOSPC;                                                  
    }                                                                 
  }                                                                   
                                                                      
#if RTEMS_FDISK_TRACE                                                 
  if (fd->info_level >= 3)                                            
400068c0:	c2 07 60 6c 	ld  [ %i5 + 0x6c ], %g1                        
400068c4:	80 a0 60 02 	cmp  %g1, 2                                    
400068c8:	18 80 00 b8 	bgu  40006ba8 <rtems_fdisk_ioctl+0xf54>        <== NEVER TAKEN
400068cc:	c0 27 00 00 	clr  [ %i4 ]                                   
   * Find the next avaliable page in the segment.                     
   */                                                                 
                                                                      
  pd = sc->page_descriptors;                                          
                                                                      
  for (page = 0; page < sc->pages; page++, pd++)                      
400068d0:	c6 07 20 14 	ld  [ %i4 + 0x14 ], %g3                        
400068d4:	80 a0 e0 00 	cmp  %g3, 0                                    
400068d8:	02 80 00 83 	be  40006ae4 <rtems_fdisk_ioctl+0xe90>         <== NEVER TAKEN
400068dc:	f6 07 20 10 	ld  [ %i4 + 0x10 ], %i3                        
400068e0:	10 80 00 05 	b  400068f4 <rtems_fdisk_ioctl+0xca0>          
400068e4:	b0 10 20 00 	clr  %i0                                       
400068e8:	80 a6 00 03 	cmp  %i0, %g3                                  
400068ec:	02 80 00 7e 	be  40006ae4 <rtems_fdisk_ioctl+0xe90>         <== NEVER TAKEN
400068f0:	b6 06 e0 08 	add  %i3, 8, %i3                               
static bool                                                           
rtems_fdisk_page_desc_erased (const rtems_fdisk_page_desc* pd)        
{                                                                     
  return ((pd->crc == 0xffff) &&                                      
          (pd->flags == 0xffff) &&                                    
          (pd->block == 0xffffffff)) ? true : false;                  
400068f4:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
400068f8:	80 a0 7f ff 	cmp  %g1, -1                                   
400068fc:	32 bf ff fb 	bne,a   400068e8 <rtems_fdisk_ioctl+0xc94>     
40006900:	b0 06 20 01 	inc  %i0                                       
40006904:	c2 06 e0 04 	ld  [ %i3 + 4 ], %g1                           
40006908:	80 a0 7f ff 	cmp  %g1, -1                                   
4000690c:	32 bf ff f7 	bne,a   400068e8 <rtems_fdisk_ioctl+0xc94>     <== NEVER TAKEN
40006910:	b0 06 20 01 	inc  %i0                                       <== NOT EXECUTED
                                                                      
  for (page = 0; page < sc->pages; page++, pd++)                      
  {                                                                   
    if (rtems_fdisk_page_desc_erased (pd))                            
    {                                                                 
      pd->crc   = rtems_fdisk_page_checksum (buffer, fd->block_size); 
40006914:	de 07 60 14 	ld  [ %i5 + 0x14 ], %o7                        
rtems_fdisk_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++)                           
40006918:	80 a3 e0 00 	cmp  %o7, 0                                    
4000691c:	02 80 00 e0 	be  40006c9c <rtems_fdisk_ioctl+0x1048>        <== NEVER TAKEN
40006920:	15 10 00 d3 	sethi  %hi(0x40034c00), %o2                    
40006924:	03 10 01 26 	sethi  %hi(0x40049800), %g1                    
 * @param req IOCTL request code.                                     
 * @param argp IOCTL argument.                                        
 * @retval The IOCTL return value                                     
 */                                                                   
static int                                                            
rtems_fdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)   
40006928:	9e 06 80 0f 	add  %i2, %o7, %o7                             
4000692c:	da 00 60 e0 	ld  [ %g1 + 0xe0 ], %o5                        
 * Calculate the checksum of a page in a segment.                     
 */                                                                   
static uint16_t                                                       
rtems_fdisk_page_checksum (const uint8_t* buffer, uint32_t page_size) 
{                                                                     
  uint16_t cs = 0xffff;                                               
40006930:	84 10 3f ff 	mov  -1, %g2                                   
 * @param req IOCTL request code.                                     
 * @param argp IOCTL argument.                                        
 * @retval The IOCTL return value                                     
 */                                                                   
static int                                                            
rtems_fdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)   
40006934:	82 10 00 1a 	mov  %i2, %g1                                  
{                                                                     
  uint16_t cs = 0xffff;                                               
  uint32_t i;                                                         
                                                                      
  for (i = 0; i < page_size; i++, buffer++)                           
    cs = rtems_fdisk_calc_crc16 (cs, *buffer);                        
40006938:	c8 08 40 00 	ldub  [ %g1 ], %g4                             
4000693c:	84 08 a0 ff 	and  %g2, 0xff, %g2                            
rtems_fdisk_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++)                           
40006940:	82 00 60 01 	inc  %g1                                       
    cs = rtems_fdisk_calc_crc16 (cs, *buffer);                        
40006944:	84 18 80 04 	xor  %g2, %g4, %g2                             
rtems_fdisk_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++)                           
40006948:	80 a0 40 0f 	cmp  %g1, %o7                                  
    cs = rtems_fdisk_calc_crc16 (cs, *buffer);                        
4000694c:	85 28 a0 01 	sll  %g2, 1, %g2                               
rtems_fdisk_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++)                           
40006950:	12 bf ff fa 	bne  40006938 <rtems_fdisk_ioctl+0xce4>        
40006954:	c4 13 40 02 	lduh  [ %o5 + %g2 ], %g2                       
40006958:	83 28 a0 10 	sll  %g2, 0x10, %g1                            
4000695c:	83 30 60 10 	srl  %g1, 0x10, %g1                            
 * Set the flags. Setting means clear the bit to 0.                   
 */                                                                   
static void                                                           
rtems_fdisk_page_desc_set_flags (rtems_fdisk_page_desc* pd, uint16_t flags)
{                                                                     
  pd->flags &= ~flags;                                                
40006960:	c8 16 e0 02 	lduh  [ %i3 + 2 ], %g4                         
                                                                      
  for (page = 0; page < sc->pages; page++, pd++)                      
  {                                                                   
    if (rtems_fdisk_page_desc_erased (pd))                            
    {                                                                 
      pd->crc   = rtems_fdisk_page_checksum (buffer, fd->block_size); 
40006964:	c4 36 c0 00 	sth  %g2, [ %i3 ]                              
      pd->block = block;                                              
40006968:	ee 26 e0 04 	st  %l7, [ %i3 + 4 ]                           
                                                                      
      bc->segment = sc;                                               
4000696c:	f8 24 c0 12 	st  %i4, [ %l3 + %l2 ]                         
      bc->page    = page;                                             
                                                                      
      rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_ACTIVE);  
                                                                      
#if RTEMS_FDISK_TRACE                                                 
      rtems_fdisk_info (fd, " write:%d=>%02d-%03d-%03d: write: " \    
40006970:	c4 07 00 00 	ld  [ %i4 ], %g2                               
    {                                                                 
      pd->crc   = rtems_fdisk_page_checksum (buffer, fd->block_size); 
      pd->block = block;                                              
                                                                      
      bc->segment = sc;                                               
      bc->page    = page;                                             
40006974:	f0 24 60 04 	st  %i0, [ %l1 + 4 ]                           
 * Set the flags. Setting means clear the bit to 0.                   
 */                                                                   
static void                                                           
rtems_fdisk_page_desc_set_flags (rtems_fdisk_page_desc* pd, uint16_t flags)
{                                                                     
  pd->flags &= ~flags;                                                
40006978:	88 09 3f fe 	and  %g4, -2, %g4                              
4000697c:	c8 36 e0 02 	sth  %g4, [ %i3 + 2 ]                          
      bc->page    = page;                                             
                                                                      
      rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_ACTIVE);  
                                                                      
#if RTEMS_FDISK_TRACE                                                 
      rtems_fdisk_info (fd, " write:%d=>%02d-%03d-%03d: write: " \    
40006980:	d6 07 20 08 	ld  [ %i4 + 8 ], %o3                           
40006984:	d8 07 20 0c 	ld  [ %i4 + 0xc ], %o4                         
40006988:	e4 07 20 1c 	ld  [ %i4 + 0x1c ], %l2                        
4000698c:	d0 07 20 20 	ld  [ %i4 + 0x20 ], %o0                        
40006990:	80 a0 a0 00 	cmp  %g2, 0                                    
40006994:	02 80 00 bf 	be  40006c90 <rtems_fdisk_ioctl+0x103c>        <== ALWAYS TAKEN
40006998:	de 07 20 24 	ld  [ %i4 + 0x24 ], %o7                        
4000699c:	05 10 00 d1 	sethi  %hi(0x40034400), %g2                    <== NOT EXECUTED
400069a0:	84 10 a0 08 	or  %g2, 8, %g2	! 40034408 <__FUNCTION__.6193+0x340><== NOT EXECUTED
400069a4:	89 29 20 10 	sll  %g4, 0x10, %g4                            
400069a8:	89 31 20 10 	srl  %g4, 0x10, %g4                            
400069ac:	94 10 00 17 	mov  %l7, %o2                                  
400069b0:	9a 10 00 18 	mov  %i0, %o5                                  
400069b4:	c6 23 a0 5c 	st  %g3, [ %sp + 0x5c ]                        
400069b8:	e4 23 a0 60 	st  %l2, [ %sp + 0x60 ]                        
400069bc:	d0 23 a0 64 	st  %o0, [ %sp + 0x64 ]                        
400069c0:	de 23 a0 68 	st  %o7, [ %sp + 0x68 ]                        
400069c4:	c4 23 a0 6c 	st  %g2, [ %sp + 0x6c ]                        
400069c8:	c8 23 a0 70 	st  %g4, [ %sp + 0x70 ]                        
400069cc:	c2 23 a0 74 	st  %g1, [ %sp + 0x74 ]                        
400069d0:	13 10 00 d2 	sethi  %hi(0x40034800), %o1                    
400069d4:	ee 23 a0 78 	st  %l7, [ %sp + 0x78 ]                        
400069d8:	92 12 63 18 	or  %o1, 0x318, %o1                            
400069dc:	7f ff f7 83 	call  400047e8 <rtems_fdisk_info>              
400069e0:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
      /*                                                              
       * We use the segment page offset not the page number used in the
       * driver. This skips the page descriptors.                     
       */                                                             
      ret = rtems_fdisk_seg_write_page (fd, sc, page + sc->pages_desc, buffer);
400069e4:	d4 07 20 18 	ld  [ %i4 + 0x18 ], %o2                        
400069e8:	90 10 00 1d 	mov  %i5, %o0                                  
400069ec:	92 10 00 1c 	mov  %i4, %o1                                  
400069f0:	94 06 00 0a 	add  %i0, %o2, %o2                             
400069f4:	7f ff f8 3b 	call  40004ae0 <rtems_fdisk_seg_write_page>    
400069f8:	96 10 00 1a 	mov  %i2, %o3                                  
      if (ret)                                                        
400069fc:	a4 92 20 00 	orcc  %o0, 0, %l2                              
40006a00:	22 80 00 78 	be,a   40006be0 <rtems_fdisk_ioctl+0xf8c>      <== ALWAYS TAKEN
40006a04:	90 10 00 1d 	mov  %i5, %o0                                  
      {                                                               
#if RTEMS_FDISK_TRACE                                                 
        rtems_fdisk_info (fd, "write-block:%02d-%03d-%03d: write page failed: " \
40006a08:	e2 07 20 08 	ld  [ %i4 + 8 ], %l1                           <== NOT EXECUTED
40006a0c:	40 00 79 a6 	call  400250a4 <strerror>                      <== NOT EXECUTED
40006a10:	f6 07 20 0c 	ld  [ %i4 + 0xc ], %i3                         <== NOT EXECUTED
40006a14:	13 10 00 d2 	sethi  %hi(0x40034800), %o1                    <== NOT EXECUTED
40006a18:	9a 10 00 08 	mov  %o0, %o5                                  <== NOT EXECUTED
40006a1c:	e4 23 a0 5c 	st  %l2, [ %sp + 0x5c ]                        <== NOT EXECUTED
40006a20:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40006a24:	92 12 63 68 	or  %o1, 0x368, %o1                            <== NOT EXECUTED
40006a28:	94 10 00 11 	mov  %l1, %o2                                  <== NOT EXECUTED
40006a2c:	96 10 00 1b 	mov  %i3, %o3                                  <== NOT EXECUTED
40006a30:	7f ff f7 6e 	call  400047e8 <rtems_fdisk_info>              <== NOT EXECUTED
40006a34:	98 10 00 18 	mov  %i0, %o4                                  <== NOT EXECUTED
        {                                                             
          sc->pages_active++;                                         
        }                                                             
      }                                                               
                                                                      
      rtems_fdisk_queue_segment (fd, sc);                             
40006a38:	90 10 00 1d 	mov  %i5, %o0                                  
40006a3c:	7f ff f9 0f 	call  40004e78 <rtems_fdisk_queue_segment>     
40006a40:	92 10 00 1c 	mov  %i4, %o1                                  
static bool                                                           
rtems_fdisk_is_erased_blocks_starvation (rtems_flashdisk* fd)         
{                                                                     
  bool starvation = fd->erased_blocks < fd->starvation_threshold;     
                                                                      
  if (starvation)                                                     
40006a44:	c4 07 60 28 	ld  [ %i5 + 0x28 ], %g2                        
40006a48:	c2 07 60 24 	ld  [ %i5 + 0x24 ], %g1                        
40006a4c:	80 a0 80 01 	cmp  %g2, %g1                                  
40006a50:	1a 80 00 08 	bcc  40006a70 <rtems_fdisk_ioctl+0xe1c>        
40006a54:	80 a4 a0 00 	cmp  %l2, 0                                    
    fd->starvations++;                                                
40006a58:	c2 07 60 70 	ld  [ %i5 + 0x70 ], %g1                        
      }                                                               
                                                                      
      rtems_fdisk_queue_segment (fd, sc);                             
                                                                      
      if (rtems_fdisk_is_erased_blocks_starvation (fd))               
        rtems_fdisk_compact (fd);                                     
40006a5c:	90 10 00 1d 	mov  %i5, %o0                                  
rtems_fdisk_is_erased_blocks_starvation (rtems_flashdisk* fd)         
{                                                                     
  bool starvation = fd->erased_blocks < fd->starvation_threshold;     
                                                                      
  if (starvation)                                                     
    fd->starvations++;                                                
40006a60:	82 00 60 01 	inc  %g1                                       
      }                                                               
                                                                      
      rtems_fdisk_queue_segment (fd, sc);                             
                                                                      
      if (rtems_fdisk_is_erased_blocks_starvation (fd))               
        rtems_fdisk_compact (fd);                                     
40006a64:	7f ff fa d1 	call  400055a8 <rtems_fdisk_compact>           
40006a68:	c2 27 60 70 	st  %g1, [ %i5 + 0x70 ]                        
    fb = sg->length / fd->block_size;                                 
    data = sg->buffer;                                                
    for (b = 0; b < fb; b++, data += fd->block_size)                  
    {                                                                 
      ret = rtems_fdisk_write_block (fd, sg->block + b, data);        
      if (ret)                                                        
40006a6c:	80 a4 a0 00 	cmp  %l2, 0                                    
40006a70:	32 80 01 72 	bne,a   40007038 <rtems_fdisk_ioctl+0x13e4>    <== NEVER TAKEN
40006a74:	f4 07 bf ec 	ld  [ %fp + -20 ], %i2                         <== NOT EXECUTED
    uint8_t* data;                                                    
    uint32_t fb;                                                      
    uint32_t b;                                                       
    fb = sg->length / fd->block_size;                                 
    data = sg->buffer;                                                
    for (b = 0; b < fb; b++, data += fd->block_size)                  
40006a78:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
40006a7c:	b2 06 60 01 	inc  %i1                                       
40006a80:	b4 06 80 01 	add  %i2, %g1, %i2                             
40006a84:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
40006a88:	80 a6 40 01 	cmp  %i1, %g1                                  
40006a8c:	32 bf fe fc 	bne,a   4000667c <rtems_fdisk_ioctl+0xa28>     <== NEVER TAKEN
40006a90:	ee 05 3f f0 	ld  [ %l4 + -16 ], %l7                         <== NOT EXECUTED
40006a94:	c4 07 bf ec 	ld  [ %fp + -20 ], %g2                         
40006a98:	ec 07 bf dc 	ld  [ %fp + -36 ], %l6                         
40006a9c:	f8 00 a0 10 	ld  [ %g2 + 0x10 ], %i4                        
40006aa0:	a8 05 20 10 	add  %l4, 0x10, %l4                            
40006aa4:	10 bf fe e8 	b  40006644 <rtems_fdisk_ioctl+0x9f0>          
40006aa8:	ac 05 a0 01 	inc  %l6                                       
40006aac:	f4 07 bf ec 	ld  [ %fp + -20 ], %i2                         <== NOT EXECUTED
40006ab0:	ea 07 bf e8 	ld  [ %fp + -24 ], %l5                         <== NOT EXECUTED
   * Broken out to allow info messages when testing.                  
   */                                                                 
                                                                      
  if (block >= (fd->block_count - fd->unavail_blocks))                
  {                                                                   
    rtems_fdisk_error ("write-block: block out of range: %d", block); 
40006ab4:	92 10 00 17 	mov  %l7, %o1                                  <== NOT EXECUTED
40006ab8:	7f ff f8 48 	call  40004bd8 <rtems_fdisk_error>             <== NOT EXECUTED
40006abc:	90 12 21 b8 	or  %o0, 0x1b8, %o0                            <== NOT EXECUTED
      if (ret)                                                        
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
40006ac0:	92 10 20 1b 	mov  0x1b, %o1                                 <== NOT EXECUTED
static inline void rtems_blkdev_request_done(                         
  rtems_blkdev_request *req,                                          
  rtems_status_code status                                            
)                                                                     
{                                                                     
  (*req->done)(req, status);                                          
40006ac4:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1                           
40006ac8:	9f c0 40 00 	call  %g1                                      
40006acc:	90 10 00 1a 	mov  %i2, %o0                                  
40006ad0:	c4 04 20 d8 	ld  [ %l0 + 0xd8 ], %g2                        
            case RTEMS_BLKDEV_REQ_READ:                               
              errno = rtems_fdisk_read (&rtems_flashdisks[minor], r); 
              break;                                                  
                                                                      
            case RTEMS_BLKDEV_REQ_WRITE:                              
              errno = rtems_fdisk_write (&rtems_flashdisks[minor], r);
40006ad4:	c2 07 bf e0 	ld  [ %fp + -32 ], %g1                         
40006ad8:	84 00 80 15 	add  %g2, %l5, %g2                             
              break;                                                  
40006adc:	10 bf fd 43 	b  40005fe8 <rtems_fdisk_ioctl+0x394>          
40006ae0:	c0 20 40 00 	clr  [ %g1 ]                                   
                                                                      
      return ret;                                                     
    }                                                                 
  }                                                                   
                                                                      
  rtems_fdisk_error ("write-block: no erased page descs in segment: %d-%d",
40006ae4:	d2 07 20 08 	ld  [ %i4 + 8 ], %o1                           <== NOT EXECUTED
40006ae8:	d4 07 20 0c 	ld  [ %i4 + 0xc ], %o2                         <== NOT EXECUTED
40006aec:	f4 07 bf ec 	ld  [ %fp + -20 ], %i2                         <== NOT EXECUTED
40006af0:	ea 07 bf e8 	ld  [ %fp + -24 ], %l5                         <== NOT EXECUTED
40006af4:	11 10 00 d2 	sethi  %hi(0x40034800), %o0                    <== NOT EXECUTED
40006af8:	7f ff f8 38 	call  40004bd8 <rtems_fdisk_error>             <== NOT EXECUTED
40006afc:	90 12 23 e0 	or  %o0, 0x3e0, %o0	! 40034be0 <__FUNCTION__.6193+0xb18><== NOT EXECUTED
                     sc->device, sc->segment);                        
                                                                      
  sc->failed = true;                                                  
40006b00:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
  rtems_fdisk_queue_segment (fd, sc);                                 
40006b04:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40006b08:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
40006b0c:	7f ff f8 db 	call  40004e78 <rtems_fdisk_queue_segment>     <== NOT EXECUTED
40006b10:	c2 27 20 28 	st  %g1, [ %i4 + 0x28 ]                        <== NOT EXECUTED
      if (ret)                                                        
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
40006b14:	10 bf ff ec 	b  40006ac4 <rtems_fdisk_ioctl+0xe70>          <== NOT EXECUTED
40006b18:	92 10 20 1b 	mov  0x1b, %o1                                 <== NOT EXECUTED
                         sc->device, sc->segment, page,               
                         flash_flags, page_desc->flags);              
      return ret;                                                     
    }                                                                 
  }                                                                   
  return rtems_fdisk_seg_write (fd, sc, offset,                       
40006b1c:	90 10 00 1d 	mov  %i5, %o0                                  
40006b20:	92 10 00 1c 	mov  %i4, %o1                                  
40006b24:	94 10 00 15 	mov  %l5, %o2                                  
40006b28:	96 06 20 02 	add  %i0, 2, %o3                               
40006b2c:	7f ff f7 b6 	call  40004a04 <rtems_fdisk_seg_write>         
40006b30:	98 10 20 02 	mov  2, %o4                                    
                                                                      
    rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_USED);      
                                                                      
    ret = rtems_fdisk_seg_write_page_desc_flags (fd, sc, bc->page, pd);
                                                                      
    if (ret)                                                          
40006b34:	b6 92 20 00 	orcc  %o0, 0, %i3                              
40006b38:	22 bf ff 40 	be,a   40006838 <rtems_fdisk_ioctl+0xbe4>      <== ALWAYS TAKEN
40006b3c:	c4 07 20 1c 	ld  [ %i4 + 0x1c ], %g2                        
    {                                                                 
#if RTEMS_FDISK_TRACE                                                 
      rtems_fdisk_info (fd, " write:%02d-%03d-%03d: "      \          
40006b40:	d4 07 20 08 	ld  [ %i4 + 8 ], %o2                           <== NOT EXECUTED
40006b44:	ea 07 20 0c 	ld  [ %i4 + 0xc ], %l5                         <== NOT EXECUTED
40006b48:	f0 04 60 04 	ld  [ %l1 + 4 ], %i0                           <== NOT EXECUTED
40006b4c:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
40006b50:	40 00 79 55 	call  400250a4 <strerror>                      <== NOT EXECUTED
40006b54:	d4 27 bf c8 	st  %o2, [ %fp + -56 ]                         <== NOT EXECUTED
40006b58:	d4 07 bf c8 	ld  [ %fp + -56 ], %o2                         <== NOT EXECUTED
40006b5c:	9a 10 00 08 	mov  %o0, %o5                                  <== NOT EXECUTED
40006b60:	f6 23 a0 5c 	st  %i3, [ %sp + 0x5c ]                        <== NOT EXECUTED
40006b64:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40006b68:	13 10 00 d2 	sethi  %hi(0x40034800), %o1                    <== NOT EXECUTED
40006b6c:	96 10 00 15 	mov  %l5, %o3                                  <== NOT EXECUTED
40006b70:	92 12 62 b0 	or  %o1, 0x2b0, %o1                            <== NOT EXECUTED
40006b74:	7f ff f7 1d 	call  400047e8 <rtems_fdisk_info>              <== NOT EXECUTED
40006b78:	98 10 00 18 	mov  %i0, %o4                                  <== NOT EXECUTED
    /*                                                                
     * If possible reuse this segment. This will mean the segment     
     * needs to be removed from the available list and placed         
     * back if space is still available.                              
     */                                                               
    rtems_fdisk_queue_segment (fd, sc);                               
40006b7c:	10 bf ff 35 	b  40006850 <rtems_fdisk_ioctl+0xbfc>          <== NOT EXECUTED
40006b80:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
     */                                                               
    if (rtems_fdisk_seg_verify_page (fd, sc->device, sc->segment,     
                                     bc->page + sc->pages_desc, buffer) == 0)
    {                                                                 
#if RTEMS_FDISK_TRACE                                                 
      rtems_fdisk_info (fd, "write-block:%d=>%02d-%03d-%03d: page verified",
40006b84:	d8 07 20 0c 	ld  [ %i4 + 0xc ], %o4                         
40006b88:	da 04 60 04 	ld  [ %l1 + 4 ], %o5                           
40006b8c:	90 10 00 1d 	mov  %i5, %o0                                  
40006b90:	13 10 00 d2 	sethi  %hi(0x40034800), %o1                    
40006b94:	94 10 00 17 	mov  %l7, %o2                                  
40006b98:	7f ff f7 14 	call  400047e8 <rtems_fdisk_info>              
40006b9c:	92 12 62 30 	or  %o1, 0x230, %o1                            
    uint8_t* data;                                                    
    uint32_t fb;                                                      
    uint32_t b;                                                       
    fb = sg->length / fd->block_size;                                 
    data = sg->buffer;                                                
    for (b = 0; b < fb; b++, data += fd->block_size)                  
40006ba0:	10 bf ff b7 	b  40006a7c <rtems_fdisk_ioctl+0xe28>          
40006ba4:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
                                                                      
#if RTEMS_FDISK_TRACE                                                 
  if (fd->info_level >= 3)                                            
  {                                                                   
    char queues[5];                                                   
    rtems_fdisk_queue_status (fd, sc, queues);                        
40006ba8:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40006bac:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
40006bb0:	7f ff f6 b0 	call  40004670 <rtems_fdisk_queue_status>      <== NOT EXECUTED
40006bb4:	94 07 bf f8 	add  %fp, -8, %o2                              <== NOT EXECUTED
    rtems_fdisk_info (fd, " write:%d=>%02d-%03d: queue check: %s",    
40006bb8:	d6 07 20 08 	ld  [ %i4 + 8 ], %o3                           <== NOT EXECUTED
40006bbc:	d8 07 20 0c 	ld  [ %i4 + 0xc ], %o4                         <== NOT EXECUTED
40006bc0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40006bc4:	13 10 00 d2 	sethi  %hi(0x40034800), %o1                    <== NOT EXECUTED
40006bc8:	94 10 00 17 	mov  %l7, %o2                                  <== NOT EXECUTED
40006bcc:	92 12 62 f0 	or  %o1, 0x2f0, %o1                            <== NOT EXECUTED
40006bd0:	7f ff f7 06 	call  400047e8 <rtems_fdisk_info>              <== NOT EXECUTED
40006bd4:	9a 07 bf f8 	add  %fp, -8, %o5                              <== NOT EXECUTED
   * Find the next avaliable page in the segment.                     
   */                                                                 
                                                                      
  pd = sc->page_descriptors;                                          
                                                                      
  for (page = 0; page < sc->pages; page++, pd++)                      
40006bd8:	10 bf ff 3f 	b  400068d4 <rtems_fdisk_ioctl+0xc80>          <== NOT EXECUTED
40006bdc:	c6 07 20 14 	ld  [ %i4 + 0x14 ], %g3                        <== NOT EXECUTED
                          strerror (ret), ret);                       
#endif                                                                
      }                                                               
      else                                                            
      {                                                               
        ret = rtems_fdisk_seg_write_page_desc (fd, sc, page, pd);     
40006be0:	92 10 00 1c 	mov  %i4, %o1                                  
40006be4:	94 10 00 18 	mov  %i0, %o2                                  
40006be8:	7f ff f7 ad 	call  40004a9c <rtems_fdisk_seg_write_page_desc>
40006bec:	96 10 00 1b 	mov  %i3, %o3                                  
        if (ret)                                                      
40006bf0:	a4 92 20 00 	orcc  %o0, 0, %l2                              
40006bf4:	32 80 00 19 	bne,a   40006c58 <rtems_fdisk_ioctl+0x1004>    <== NEVER TAKEN
40006bf8:	e6 07 20 08 	ld  [ %i4 + 8 ], %l3                           <== NOT EXECUTED
                            strerror (ret), ret);                     
#endif                                                                
        }                                                             
        else                                                          
        {                                                             
          sc->pages_active++;                                         
40006bfc:	c2 07 20 1c 	ld  [ %i4 + 0x1c ], %g1                        
40006c00:	82 00 60 01 	inc  %g1                                       
40006c04:	10 bf ff 8d 	b  40006a38 <rtems_fdisk_ioctl+0xde4>          
40006c08:	c2 27 20 1c 	st  %g1, [ %i4 + 0x1c ]                        
  {                                                                   
    rtems_fdisk_segment_ctl* sc = queue->head;                        
                                                                      
    queue->head = sc->next;                                           
    if (!queue->head)                                                 
      queue->tail = 0;                                                
40006c0c:	10 bf ff 2a 	b  400068b4 <rtems_fdisk_ioctl+0xc60>          
40006c10:	c0 27 60 38 	clr  [ %i5 + 0x38 ]                            
   *                                                                  
   * We override the background compaction configruation.             
   */                                                                 
  if (rtems_fdisk_segment_count_queue (&fd->available) <=             
      fd->avail_compact_segs)                                         
    rtems_fdisk_compact (fd);                                         
40006c14:	7f ff fa 65 	call  400055a8 <rtems_fdisk_compact>           
40006c18:	90 10 00 1d 	mov  %i5, %o0                                  
40006c1c:	f8 07 60 34 	ld  [ %i5 + 0x34 ], %i4                        
 * Pop the head of the segment control queue.                         
 */                                                                   
static rtems_fdisk_segment_ctl*                                       
rtems_fdisk_segment_queue_pop_head (rtems_fdisk_segment_ctl_queue* queue)
{                                                                     
  if (queue->head)                                                    
40006c20:	80 a7 20 00 	cmp  %i4, 0                                    
40006c24:	32 bf ff 21 	bne,a   400068a8 <rtems_fdisk_ioctl+0xc54>     <== ALWAYS TAKEN
40006c28:	c2 07 00 00 	ld  [ %i4 ], %g1                               
  {                                                                   
    /*                                                                
     * If compacting is configured for the background do it now       
     * to see if we can get some space back.                          
     */                                                               
    if ((fd->flags & RTEMS_FDISK_BACKGROUND_COMPACT))                 
40006c2c:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           <== NOT EXECUTED
40006c30:	80 88 60 02 	btst  2, %g1                                   <== NOT EXECUTED
40006c34:	12 80 01 06 	bne  4000704c <rtems_fdisk_ioctl+0x13f8>       <== NOT EXECUTED
40006c38:	01 00 00 00 	nop                                            <== NOT EXECUTED
40006c3c:	f4 07 bf ec 	ld  [ %fp + -20 ], %i2                         <== NOT EXECUTED
40006c40:	ea 07 bf e8 	ld  [ %fp + -24 ], %l5                         <== NOT EXECUTED
     */                                                               
    sc = rtems_fdisk_segment_queue_pop_head (&fd->available);         
                                                                      
    if (!sc)                                                          
    {                                                                 
      rtems_fdisk_error ("write-block: no available pages");          
40006c44:	11 10 00 d3 	sethi  %hi(0x40034c00), %o0                    <== NOT EXECUTED
40006c48:	7f ff f7 e4 	call  40004bd8 <rtems_fdisk_error>             <== NOT EXECUTED
40006c4c:	90 12 22 28 	or  %o0, 0x228, %o0	! 40034e28 <__FUNCTION__.6193+0xd60><== NOT EXECUTED
      if (ret)                                                        
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
40006c50:	10 bf ff 9d 	b  40006ac4 <rtems_fdisk_ioctl+0xe70>          <== NOT EXECUTED
40006c54:	92 10 20 1b 	mov  0x1b, %o1                                 <== NOT EXECUTED
      {                                                               
        ret = rtems_fdisk_seg_write_page_desc (fd, sc, page, pd);     
        if (ret)                                                      
        {                                                             
#if RTEMS_FDISK_TRACE                                                 
          rtems_fdisk_info (fd, "write-block:%02d-%03d-%03d: "  \     
40006c58:	f0 07 20 0c 	ld  [ %i4 + 0xc ], %i0                         <== NOT EXECUTED
40006c5c:	40 00 79 12 	call  400250a4 <strerror>                      <== NOT EXECUTED
40006c60:	f6 04 60 04 	ld  [ %l1 + 4 ], %i3                           <== NOT EXECUTED
40006c64:	13 10 00 d2 	sethi  %hi(0x40034800), %o1                    <== NOT EXECUTED
40006c68:	9a 10 00 08 	mov  %o0, %o5                                  <== NOT EXECUTED
40006c6c:	e4 23 a0 5c 	st  %l2, [ %sp + 0x5c ]                        <== NOT EXECUTED
40006c70:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40006c74:	92 12 63 a0 	or  %o1, 0x3a0, %o1                            <== NOT EXECUTED
40006c78:	94 10 00 13 	mov  %l3, %o2                                  <== NOT EXECUTED
40006c7c:	96 10 00 18 	mov  %i0, %o3                                  <== NOT EXECUTED
40006c80:	7f ff f6 da 	call  400047e8 <rtems_fdisk_info>              <== NOT EXECUTED
40006c84:	98 10 00 1b 	mov  %i3, %o4                                  <== NOT EXECUTED
        {                                                             
          sc->pages_active++;                                         
        }                                                             
      }                                                               
                                                                      
      rtems_fdisk_queue_segment (fd, sc);                             
40006c88:	10 bf ff 6d 	b  40006a3c <rtems_fdisk_ioctl+0xde8>          <== NOT EXECUTED
40006c8c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
      bc->page    = page;                                             
                                                                      
      rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_ACTIVE);  
                                                                      
#if RTEMS_FDISK_TRACE                                                 
      rtems_fdisk_info (fd, " write:%d=>%02d-%03d-%03d: write: " \    
40006c90:	05 10 00 d1 	sethi  %hi(0x40034400), %g2                    
40006c94:	10 bf ff 44 	b  400069a4 <rtems_fdisk_ioctl+0xd50>          
40006c98:	84 10 a0 10 	or  %g2, 0x10, %g2	! 40034410 <__FUNCTION__.6193+0x348>
 * Calculate the checksum of a page in a segment.                     
 */                                                                   
static uint16_t                                                       
rtems_fdisk_page_checksum (const uint8_t* buffer, uint32_t page_size) 
{                                                                     
  uint16_t cs = 0xffff;                                               
40006c9c:	84 10 3f ff 	mov  -1, %g2                                   <== NOT EXECUTED
  uint32_t i;                                                         
                                                                      
  for (i = 0; i < page_size; i++, buffer++)                           
40006ca0:	10 bf ff 30 	b  40006960 <rtems_fdisk_ioctl+0xd0c>          <== NOT EXECUTED
40006ca4:	c2 02 a2 c4 	ld  [ %o2 + 0x2c4 ], %g1                       <== NOT EXECUTED
                                                                      
  count = 0;                                                          
  for (device = 0; device < fd->device_count; device++)               
    count += fd->devices[device].segment_count;                       
                                                                      
  rtems_fdisk_printf (fd, "Queue total\t%ld of %ld, %s", total, count,
40006ca8:	19 10 00 d2 	sethi  %hi(0x40034800), %o4                    
40006cac:	10 bf fd 90 	b  400062ec <rtems_fdisk_ioctl+0x698>          
40006cb0:	98 13 20 18 	or  %o4, 0x18, %o4	! 40034818 <__FUNCTION__.6193+0x750>
        else                                                          
        {                                                             
          switch (r->req)                                             
          {                                                           
            case RTEMS_BLKDEV_REQ_READ:                               
              errno = rtems_fdisk_read (&rtems_flashdisks[minor], r); 
40006cb4:	40 00 6f 21 	call  40022938 <__errno>                       
40006cb8:	b0 06 a0 18 	add  %i2, 0x18, %i0                            
40006cbc:	f8 04 20 d8 	ld  [ %l0 + 0xd8 ], %i4                        
40006cc0:	fa 06 a0 10 	ld  [ %i2 + 0x10 ], %i5                        
40006cc4:	d0 27 bf e8 	st  %o0, [ %fp + -24 ]                         
40006cc8:	b8 07 00 15 	add  %i4, %l5, %i4                             
{                                                                     
  rtems_blkdev_sg_buffer* sg = req->bufs;                             
  uint32_t                buf;                                        
  int                     ret = 0;                                    
                                                                      
  for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)       
40006ccc:	a6 10 20 00 	clr  %l3                                       
40006cd0:	ea 27 bf ec 	st  %l5, [ %fp + -20 ]                         
40006cd4:	80 a4 c0 1d 	cmp  %l3, %i5                                  
40006cd8:	1a 80 00 a5 	bcc  40006f6c <rtems_fdisk_ioctl+0x1318>       
40006cdc:	ea 07 bf ec 	ld  [ %fp + -20 ], %l5                         
  {                                                                   
    uint8_t* data;                                                    
    uint32_t fb;                                                      
    uint32_t b;                                                       
    fb = sg->length / fd->block_size;                                 
40006ce0:	d0 06 20 04 	ld  [ %i0 + 4 ], %o0                           
40006ce4:	7f ff ee 6f 	call  400026a0 <.udiv>                         
40006ce8:	d2 07 20 14 	ld  [ %i4 + 0x14 ], %o1                        
    data = sg->buffer;                                                
40006cec:	f2 06 20 08 	ld  [ %i0 + 8 ], %i1                           
    for (b = 0; b < fb; b++, data += fd->block_size)                  
40006cf0:	80 a2 20 00 	cmp  %o0, 0                                    
40006cf4:	02 80 00 9b 	be  40006f60 <rtems_fdisk_ioctl+0x130c>        <== NEVER TAKEN
40006cf8:	a8 10 00 08 	mov  %o0, %l4                                  
40006cfc:	a4 10 20 00 	clr  %l2                                       
    {                                                                 
      ret = rtems_fdisk_read_block (fd, sg->block + b, data);         
40006d00:	f6 06 00 00 	ld  [ %i0 ], %i3                               
  rtems_fdisk_block_ctl*   bc;                                        
  rtems_fdisk_segment_ctl* sc;                                        
  rtems_fdisk_page_desc*   pd;                                        
                                                                      
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_info (fd, "read-block:%d", block);                      
40006d04:	90 10 00 1c 	mov  %i4, %o0                                  
    uint32_t b;                                                       
    fb = sg->length / fd->block_size;                                 
    data = sg->buffer;                                                
    for (b = 0; b < fb; b++, data += fd->block_size)                  
    {                                                                 
      ret = rtems_fdisk_read_block (fd, sg->block + b, data);         
40006d08:	b6 04 80 1b 	add  %l2, %i3, %i3                             
  rtems_fdisk_block_ctl*   bc;                                        
  rtems_fdisk_segment_ctl* sc;                                        
  rtems_fdisk_page_desc*   pd;                                        
                                                                      
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_info (fd, "read-block:%d", block);                      
40006d0c:	13 10 00 d2 	sethi  %hi(0x40034800), %o1                    
40006d10:	94 10 00 1b 	mov  %i3, %o2                                  
40006d14:	7f ff f6 b5 	call  400047e8 <rtems_fdisk_info>              
40006d18:	92 12 60 28 	or  %o1, 0x28, %o1                             
                                                                      
  /*                                                                  
   * Broken out to allow info messages when testing.                  
   */                                                                 
                                                                      
  if (block >= (fd->block_count - fd->unavail_blocks))                
40006d1c:	c4 07 20 1c 	ld  [ %i4 + 0x1c ], %g2                        
40006d20:	c2 07 20 20 	ld  [ %i4 + 0x20 ], %g1                        
40006d24:	82 20 80 01 	sub  %g2, %g1, %g1                             
40006d28:	80 a6 c0 01 	cmp  %i3, %g1                                  
40006d2c:	1a 80 00 74 	bcc  40006efc <rtems_fdisk_ioctl+0x12a8>       <== NEVER TAKEN
40006d30:	83 2e e0 03 	sll  %i3, 3, %g1                               
  {                                                                   
    rtems_fdisk_error ("read-block: block out of range: %d", block);  
    return EIO;                                                       
  }                                                                   
                                                                      
  bc = &fd->blocks[block];                                            
40006d34:	ea 07 20 18 	ld  [ %i4 + 0x18 ], %l5                        
                                                                      
  if (!bc->segment)                                                   
40006d38:	fa 05 40 01 	ld  [ %l5 + %g1 ], %i5                         
40006d3c:	80 a7 60 00 	cmp  %i5, 0                                    
40006d40:	02 80 00 79 	be  40006f24 <rtems_fdisk_ioctl+0x12d0>        
40006d44:	aa 05 40 01 	add  %l5, %g1, %l5                             
    memset (buffer, 0xff, fd->block_size);                            
    return 0;                                                         
  }                                                                   
                                                                      
  sc = fd->blocks[block].segment;                                     
  pd = &sc->page_descriptors[bc->page];                               
40006d48:	da 05 60 04 	ld  [ %l5 + 4 ], %o5                           
40006d4c:	ec 07 60 10 	ld  [ %i5 + 0x10 ], %l6                        
                                                                      
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_info (fd,                                               
40006d50:	c2 07 40 00 	ld  [ %i5 ], %g1                               
    memset (buffer, 0xff, fd->block_size);                            
    return 0;                                                         
  }                                                                   
                                                                      
  sc = fd->blocks[block].segment;                                     
  pd = &sc->page_descriptors[bc->page];                               
40006d54:	a3 2b 60 03 	sll  %o5, 3, %l1                               
                                                                      
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_info (fd,                                               
40006d58:	d6 07 60 08 	ld  [ %i5 + 8 ], %o3                           
    memset (buffer, 0xff, fd->block_size);                            
    return 0;                                                         
  }                                                                   
                                                                      
  sc = fd->blocks[block].segment;                                     
  pd = &sc->page_descriptors[bc->page];                               
40006d5c:	ae 05 80 11 	add  %l6, %l1, %l7                             
                                                                      
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_info (fd,                                               
40006d60:	d8 07 60 0c 	ld  [ %i5 + 0xc ], %o4                         
40006d64:	de 07 60 14 	ld  [ %i5 + 0x14 ], %o7                        
40006d68:	c8 07 60 1c 	ld  [ %i5 + 0x1c ], %g4                        
40006d6c:	c6 07 60 20 	ld  [ %i5 + 0x20 ], %g3                        
40006d70:	80 a0 60 00 	cmp  %g1, 0                                    
40006d74:	02 80 00 69 	be  40006f18 <rtems_fdisk_ioctl+0x12c4>        
40006d78:	c4 07 60 24 	ld  [ %i5 + 0x24 ], %g2                        
40006d7c:	15 10 00 d1 	sethi  %hi(0x40034400), %o2                    
40006d80:	82 12 a0 08 	or  %o2, 8, %g1	! 40034408 <__FUNCTION__.6193+0x340>
40006d84:	de 23 a0 5c 	st  %o7, [ %sp + 0x5c ]                        
40006d88:	c8 23 a0 60 	st  %g4, [ %sp + 0x60 ]                        
40006d8c:	c6 23 a0 64 	st  %g3, [ %sp + 0x64 ]                        
40006d90:	c4 23 a0 68 	st  %g2, [ %sp + 0x68 ]                        
40006d94:	c2 23 a0 6c 	st  %g1, [ %sp + 0x6c ]                        
40006d98:	c2 15 e0 02 	lduh  [ %l7 + 2 ], %g1                         
40006d9c:	90 10 00 1c 	mov  %i4, %o0                                  
40006da0:	c2 23 a0 70 	st  %g1, [ %sp + 0x70 ]                        
40006da4:	c2 15 80 11 	lduh  [ %l6 + %l1 ], %g1                       
40006da8:	13 10 00 d2 	sethi  %hi(0x40034800), %o1                    
40006dac:	c2 23 a0 74 	st  %g1, [ %sp + 0x74 ]                        
40006db0:	c2 05 e0 04 	ld  [ %l7 + 4 ], %g1                           
40006db4:	92 12 60 88 	or  %o1, 0x88, %o1                             
40006db8:	c2 23 a0 78 	st  %g1, [ %sp + 0x78 ]                        
40006dbc:	7f ff f6 8b 	call  400047e8 <rtems_fdisk_info>              
40006dc0:	94 10 00 1b 	mov  %i3, %o2                                  
 * only set a flag by changing it from 1 to 0.                        
 */                                                                   
static bool                                                           
rtems_fdisk_page_desc_flags_set (rtems_fdisk_page_desc* pd, uint16_t flags)
{                                                                     
  return (pd->flags & flags) == 0 ? true : false;                     
40006dc4:	c2 15 e0 02 	lduh  [ %l7 + 2 ], %g1                         
                    sc->pages, sc->pages_active, sc->pages_used, sc->pages_bad,
                    sc->next ? "set" : "null",                        
                    pd->flags, pd->crc, pd->block);                   
#endif                                                                
                                                                      
  if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_ACTIVE))  
40006dc8:	80 88 60 01 	btst  1, %g1                                   
40006dcc:	12 80 00 15 	bne  40006e20 <rtems_fdisk_ioctl+0x11cc>       <== NEVER TAKEN
40006dd0:	80 88 60 02 	btst  2, %g1                                   
  {                                                                   
    if (rtems_fdisk_page_desc_flags_clear (pd, RTEMS_FDISK_PAGE_USED))
40006dd4:	12 80 00 1e 	bne  40006e4c <rtems_fdisk_ioctl+0x11f8>       <== ALWAYS TAKEN
40006dd8:	92 10 00 1b 	mov  %i3, %o1                                  
40006ddc:	a2 10 00 15 	mov  %l5, %l1                                  <== NOT EXECUTED
      rtems_fdisk_error ("read-block: crc failure: %d: buffer:%04x page:%04x",
                         block, cs, pd->crc);                         
    }                                                                 
    else                                                              
    {                                                                 
      rtems_fdisk_error ("read-block: block points to used page: %d: %d-%d-%d",
40006de0:	d4 07 60 08 	ld  [ %i5 + 8 ], %o2                           <== NOT EXECUTED
40006de4:	d6 07 60 0c 	ld  [ %i5 + 0xc ], %o3                         <== NOT EXECUTED
40006de8:	d8 04 60 04 	ld  [ %l1 + 4 ], %o4                           <== NOT EXECUTED
40006dec:	11 10 00 d2 	sethi  %hi(0x40034800), %o0                    <== NOT EXECUTED
40006df0:	ea 07 bf ec 	ld  [ %fp + -20 ], %l5                         <== NOT EXECUTED
40006df4:	7f ff f7 79 	call  40004bd8 <rtems_fdisk_error>             <== NOT EXECUTED
40006df8:	90 12 21 40 	or  %o0, 0x140, %o0                            <== NOT EXECUTED
      if (ret)                                                        
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
40006dfc:	92 10 20 1b 	mov  0x1b, %o1                                 <== NOT EXECUTED
40006e00:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1                           
40006e04:	9f c0 40 00 	call  %g1                                      
40006e08:	90 10 00 1a 	mov  %i2, %o0                                  
40006e0c:	c4 04 20 d8 	ld  [ %l0 + 0xd8 ], %g2                        
        else                                                          
        {                                                             
          switch (r->req)                                             
          {                                                           
            case RTEMS_BLKDEV_REQ_READ:                               
              errno = rtems_fdisk_read (&rtems_flashdisks[minor], r); 
40006e10:	c2 07 bf e8 	ld  [ %fp + -24 ], %g1                         
40006e14:	84 00 80 15 	add  %g2, %l5, %g2                             
              break;                                                  
40006e18:	10 bf fc 74 	b  40005fe8 <rtems_fdisk_ioctl+0x394>          
40006e1c:	c0 20 40 00 	clr  [ %g1 ]                                   
40006e20:	a2 10 00 15 	mov  %l5, %l1                                  <== NOT EXECUTED
                         block, sc->device, sc->segment, bc->page);   
    }                                                                 
  }                                                                   
  else                                                                
  {                                                                   
    rtems_fdisk_error ("read-block: block page not active: %d: %d-%d-%d",
40006e24:	d4 07 60 08 	ld  [ %i5 + 8 ], %o2                           <== NOT EXECUTED
40006e28:	d6 07 60 0c 	ld  [ %i5 + 0xc ], %o3                         <== NOT EXECUTED
40006e2c:	d8 04 60 04 	ld  [ %l1 + 4 ], %o4                           <== NOT EXECUTED
40006e30:	ea 07 bf ec 	ld  [ %fp + -20 ], %l5                         <== NOT EXECUTED
40006e34:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
40006e38:	11 10 00 d2 	sethi  %hi(0x40034800), %o0                    <== NOT EXECUTED
40006e3c:	7f ff f7 67 	call  40004bd8 <rtems_fdisk_error>             <== NOT EXECUTED
40006e40:	90 12 21 78 	or  %o0, 0x178, %o0	! 40034978 <__FUNCTION__.6193+0x8b0><== NOT EXECUTED
      if (ret)                                                        
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
40006e44:	10 bf ff ef 	b  40006e00 <rtems_fdisk_ioctl+0x11ac>         <== NOT EXECUTED
40006e48:	92 10 20 1b 	mov  0x1b, %o1                                 <== NOT EXECUTED
                           rtems_fdisk_segment_ctl* sc,               
                           uint32_t                 page,             
                           void*                    buffer)           
{                                                                     
  return rtems_fdisk_seg_read (fd, sc,                                
                               page * fd->block_size, buffer, fd->block_size);
40006e4c:	ee 07 20 14 	ld  [ %i4 + 0x14 ], %l7                        
                                                                      
      /*                                                              
       * We use the segment page offset not the page number used in the
       * driver. This skips the page descriptors.                     
       */                                                             
      int ret = rtems_fdisk_seg_read_page (fd, sc,                    
40006e50:	c2 05 60 04 	ld  [ %l5 + 4 ], %g1                           
40006e54:	d0 07 60 18 	ld  [ %i5 + 0x18 ], %o0                        
rtems_fdisk_seg_read_page (const rtems_flashdisk*   fd,               
                           rtems_fdisk_segment_ctl* sc,               
                           uint32_t                 page,             
                           void*                    buffer)           
{                                                                     
  return rtems_fdisk_seg_read (fd, sc,                                
40006e58:	92 10 00 17 	mov  %l7, %o1                                  
40006e5c:	7f ff ed d7 	call  400025b8 <.umul>                         
40006e60:	90 02 00 01 	add  %o0, %g1, %o0                             
40006e64:	92 10 00 1d 	mov  %i5, %o1                                  
40006e68:	94 10 00 08 	mov  %o0, %o2                                  
40006e6c:	96 10 00 19 	mov  %i1, %o3                                  
40006e70:	90 10 00 1c 	mov  %i4, %o0                                  
40006e74:	7f ff f6 a1 	call  400048f8 <rtems_fdisk_seg_read>          
40006e78:	98 10 00 17 	mov  %l7, %o4                                  
       * driver. This skips the page descriptors.                     
       */                                                             
      int ret = rtems_fdisk_seg_read_page (fd, sc,                    
                                           bc->page + sc->pages_desc, buffer);
                                                                      
      if (ret)                                                        
40006e7c:	84 92 20 00 	orcc  %o0, 0, %g2                              
40006e80:	32 80 00 3d 	bne,a   40006f74 <rtems_fdisk_ioctl+0x1320>    <== NEVER TAKEN
40006e84:	f2 07 60 08 	ld  [ %i5 + 8 ], %i1                           <== NOT EXECUTED
                          strerror (ret), ret);                       
#endif                                                                
        return ret;                                                   
      }                                                               
                                                                      
      cs = rtems_fdisk_page_checksum (buffer, fd->block_size);        
40006e88:	c2 07 20 14 	ld  [ %i4 + 0x14 ], %g1                        
rtems_fdisk_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++)                           
40006e8c:	80 a0 60 00 	cmp  %g1, 0                                    
40006e90:	22 80 00 0f 	be,a   40006ecc <rtems_fdisk_ioctl+0x1278>     <== NEVER TAKEN
40006e94:	84 10 3f ff 	mov  -1, %g2                                   <== NOT EXECUTED
40006e98:	05 10 01 26 	sethi  %hi(0x40049800), %g2                    
 * @param req IOCTL request code.                                     
 * @param argp IOCTL argument.                                        
 * @retval The IOCTL return value                                     
 */                                                                   
static int                                                            
rtems_fdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)   
40006e9c:	88 06 40 01 	add  %i1, %g1, %g4                             
40006ea0:	fa 00 a0 e0 	ld  [ %g2 + 0xe0 ], %i5                        
40006ea4:	86 10 00 19 	mov  %i1, %g3                                  
 * Calculate the checksum of a page in a segment.                     
 */                                                                   
static uint16_t                                                       
rtems_fdisk_page_checksum (const uint8_t* buffer, uint32_t page_size) 
{                                                                     
  uint16_t cs = 0xffff;                                               
40006ea8:	84 10 3f ff 	mov  -1, %g2                                   
  uint32_t i;                                                         
                                                                      
  for (i = 0; i < page_size; i++, buffer++)                           
    cs = rtems_fdisk_calc_crc16 (cs, *buffer);                        
40006eac:	de 08 c0 00 	ldub  [ %g3 ], %o7                             
40006eb0:	84 08 a0 ff 	and  %g2, 0xff, %g2                            
rtems_fdisk_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++)                           
40006eb4:	86 00 e0 01 	inc  %g3                                       
    cs = rtems_fdisk_calc_crc16 (cs, *buffer);                        
40006eb8:	84 18 80 0f 	xor  %g2, %o7, %g2                             
rtems_fdisk_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++)                           
40006ebc:	80 a0 c0 04 	cmp  %g3, %g4                                  
    cs = rtems_fdisk_calc_crc16 (cs, *buffer);                        
40006ec0:	85 28 a0 01 	sll  %g2, 1, %g2                               
rtems_fdisk_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++)                           
40006ec4:	12 bf ff fa 	bne  40006eac <rtems_fdisk_ioctl+0x1258>       
40006ec8:	c4 17 40 02 	lduh  [ %i5 + %g2 ], %g2                       
        return ret;                                                   
      }                                                               
                                                                      
      cs = rtems_fdisk_page_checksum (buffer, fd->block_size);        
                                                                      
      if (cs == pd->crc)                                              
40006ecc:	d6 15 80 11 	lduh  [ %l6 + %l1 ], %o3                       
40006ed0:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
40006ed4:	95 30 a0 10 	srl  %g2, 0x10, %o2                            
40006ed8:	80 a2 80 0b 	cmp  %o2, %o3                                  
40006edc:	02 80 00 1c 	be  40006f4c <rtems_fdisk_ioctl+0x12f8>        <== ALWAYS TAKEN
40006ee0:	ea 07 bf ec 	ld  [ %fp + -20 ], %l5                         
        return 0;                                                     
                                                                      
      rtems_fdisk_error ("read-block: crc failure: %d: buffer:%04x page:%04x",
40006ee4:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
40006ee8:	11 10 00 d2 	sethi  %hi(0x40034800), %o0                    <== NOT EXECUTED
40006eec:	7f ff f7 3b 	call  40004bd8 <rtems_fdisk_error>             <== NOT EXECUTED
40006ef0:	90 12 21 08 	or  %o0, 0x108, %o0	! 40034908 <__FUNCTION__.6193+0x840><== NOT EXECUTED
      if (ret)                                                        
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
40006ef4:	10 bf ff c3 	b  40006e00 <rtems_fdisk_ioctl+0x11ac>         <== NOT EXECUTED
40006ef8:	92 10 20 1b 	mov  0x1b, %o1                                 <== NOT EXECUTED
40006efc:	ea 07 bf ec 	ld  [ %fp + -20 ], %l5                         <== NOT EXECUTED
   * Broken out to allow info messages when testing.                  
   */                                                                 
                                                                      
  if (block >= (fd->block_count - fd->unavail_blocks))                
  {                                                                   
    rtems_fdisk_error ("read-block: block out of range: %d", block);  
40006f00:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
40006f04:	11 10 00 d2 	sethi  %hi(0x40034800), %o0                    <== NOT EXECUTED
40006f08:	7f ff f7 34 	call  40004bd8 <rtems_fdisk_error>             <== NOT EXECUTED
40006f0c:	90 12 20 38 	or  %o0, 0x38, %o0	! 40034838 <__FUNCTION__.6193+0x770><== NOT EXECUTED
      if (ret)                                                        
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
40006f10:	10 bf ff bc 	b  40006e00 <rtems_fdisk_ioctl+0x11ac>         <== NOT EXECUTED
40006f14:	92 10 20 1b 	mov  0x1b, %o1                                 <== NOT EXECUTED
                                                                      
  sc = fd->blocks[block].segment;                                     
  pd = &sc->page_descriptors[bc->page];                               
                                                                      
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_info (fd,                                               
40006f18:	15 10 00 d1 	sethi  %hi(0x40034400), %o2                    
40006f1c:	10 bf ff 9a 	b  40006d84 <rtems_fdisk_ioctl+0x1130>         
40006f20:	82 12 a0 10 	or  %o2, 0x10, %g1	! 40034410 <__FUNCTION__.6193+0x348>
  bc = &fd->blocks[block];                                            
                                                                      
  if (!bc->segment)                                                   
  {                                                                   
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_info (fd, "read-block: no segment mapping: %d", block);
40006f24:	94 10 00 1b 	mov  %i3, %o2                                  
40006f28:	13 10 00 d2 	sethi  %hi(0x40034800), %o1                    
40006f2c:	90 10 00 1c 	mov  %i4, %o0                                  
40006f30:	7f ff f6 2e 	call  400047e8 <rtems_fdisk_info>              
40006f34:	92 12 60 60 	or  %o1, 0x60, %o1                             
#endif                                                                
    memset (buffer, 0xff, fd->block_size);                            
40006f38:	d4 07 20 14 	ld  [ %i4 + 0x14 ], %o2                        
40006f3c:	90 10 00 19 	mov  %i1, %o0                                  
40006f40:	40 00 73 91 	call  40023d84 <memset>                        
40006f44:	92 10 20 ff 	mov  0xff, %o1                                 
40006f48:	c2 07 20 14 	ld  [ %i4 + 0x14 ], %g1                        
    uint8_t* data;                                                    
    uint32_t fb;                                                      
    uint32_t b;                                                       
    fb = sg->length / fd->block_size;                                 
    data = sg->buffer;                                                
    for (b = 0; b < fb; b++, data += fd->block_size)                  
40006f4c:	a4 04 a0 01 	inc  %l2                                       
40006f50:	80 a4 80 14 	cmp  %l2, %l4                                  
40006f54:	12 bf ff 6b 	bne  40006d00 <rtems_fdisk_ioctl+0x10ac>       <== NEVER TAKEN
40006f58:	b2 06 40 01 	add  %i1, %g1, %i1                             
40006f5c:	fa 06 a0 10 	ld  [ %i2 + 0x10 ], %i5                        
{                                                                     
  rtems_blkdev_sg_buffer* sg = req->bufs;                             
  uint32_t                buf;                                        
  int                     ret = 0;                                    
                                                                      
  for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)       
40006f60:	a6 04 e0 01 	inc  %l3                                       
40006f64:	10 bf ff 5c 	b  40006cd4 <rtems_fdisk_ioctl+0x1080>         
40006f68:	b0 06 20 10 	add  %i0, 0x10, %i0                            
      if (ret)                                                        
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
40006f6c:	10 bf ff a5 	b  40006e00 <rtems_fdisk_ioctl+0x11ac>         
40006f70:	92 10 20 00 	clr  %o1                                       
                                           bc->page + sc->pages_desc, buffer);
                                                                      
      if (ret)                                                        
      {                                                               
#if RTEMS_FDISK_TRACE                                                 
        rtems_fdisk_info (fd,                                         
40006f74:	f6 07 60 0c 	ld  [ %i5 + 0xc ], %i3                         <== NOT EXECUTED
40006f78:	a2 10 00 15 	mov  %l5, %l1                                  <== NOT EXECUTED
40006f7c:	ea 07 bf ec 	ld  [ %fp + -20 ], %l5                         <== NOT EXECUTED
40006f80:	fa 04 60 04 	ld  [ %l1 + 4 ], %i5                           <== NOT EXECUTED
40006f84:	40 00 78 48 	call  400250a4 <strerror>                      <== NOT EXECUTED
40006f88:	c4 27 bf d0 	st  %g2, [ %fp + -48 ]                         <== NOT EXECUTED
40006f8c:	c4 07 bf d0 	ld  [ %fp + -48 ], %g2                         <== NOT EXECUTED
40006f90:	9a 10 00 08 	mov  %o0, %o5                                  <== NOT EXECUTED
40006f94:	c4 23 a0 5c 	st  %g2, [ %sp + 0x5c ]                        <== NOT EXECUTED
40006f98:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
40006f9c:	13 10 00 d2 	sethi  %hi(0x40034800), %o1                    <== NOT EXECUTED
40006fa0:	94 10 00 19 	mov  %i1, %o2                                  <== NOT EXECUTED
40006fa4:	92 12 60 d0 	or  %o1, 0xd0, %o1                             <== NOT EXECUTED
40006fa8:	96 10 00 1b 	mov  %i3, %o3                                  <== NOT EXECUTED
40006fac:	7f ff f6 0f 	call  400047e8 <rtems_fdisk_info>              <== NOT EXECUTED
40006fb0:	98 10 00 1d 	mov  %i5, %o4                                  <== NOT EXECUTED
      if (ret)                                                        
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
40006fb4:	10 bf ff 93 	b  40006e00 <rtems_fdisk_ioctl+0x11ac>         <== NOT EXECUTED
40006fb8:	92 10 20 1b 	mov  0x1b, %o1                                 <== NOT EXECUTED
                                                                      
  ret = rtems_fdisk_erase_flash (fd);                                 
                                                                      
  if (ret == 0)                                                       
  {                                                                   
    for (device = 0; device < fd->device_count; device++)             
40006fbc:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40006fc0:	02 bf fc 59 	be  40006124 <rtems_fdisk_ioctl+0x4d0>         <== NOT EXECUTED
40006fc4:	c4 04 20 d8 	ld  [ %l0 + 0xd8 ], %g2                        <== NOT EXECUTED
    {                                                                 
      if (!fd->devices[device].segments)                              
40006fc8:	c2 07 60 2c 	ld  [ %i5 + 0x2c ], %g1                        <== NOT EXECUTED
40006fcc:	c2 00 40 00 	ld  [ %g1 ], %g1                               <== NOT EXECUTED
40006fd0:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40006fd4:	02 bf fc 54 	be  40006124 <rtems_fdisk_ioctl+0x4d0>         <== NOT EXECUTED
40006fd8:	90 10 20 0c 	mov  0xc, %o0                                  <== NOT EXECUTED
40006fdc:	b6 10 20 0c 	mov  0xc, %i3                                  <== NOT EXECUTED
40006fe0:	10 80 00 0b 	b  4000700c <rtems_fdisk_ioctl+0x13b8>         <== NOT EXECUTED
40006fe4:	b8 10 20 00 	clr  %i4                                       <== NOT EXECUTED
                                                                      
  ret = rtems_fdisk_erase_flash (fd);                                 
                                                                      
  if (ret == 0)                                                       
  {                                                                   
    for (device = 0; device < fd->device_count; device++)             
40006fe8:	b8 07 20 01 	inc  %i4                                       <== NOT EXECUTED
40006fec:	80 a7 00 01 	cmp  %i4, %g1                                  <== NOT EXECUTED
40006ff0:	1a bf fc 4d 	bcc  40006124 <rtems_fdisk_ioctl+0x4d0>        <== NOT EXECUTED
40006ff4:	c4 04 20 d8 	ld  [ %l0 + 0xd8 ], %g2                        <== NOT EXECUTED
    {                                                                 
      if (!fd->devices[device].segments)                              
40006ff8:	c2 07 60 2c 	ld  [ %i5 + 0x2c ], %g1                        <== NOT EXECUTED
40006ffc:	c2 00 40 1b 	ld  [ %g1 + %i3 ], %g1                         <== NOT EXECUTED
40007000:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40007004:	02 80 00 0b 	be  40007030 <rtems_fdisk_ioctl+0x13dc>        <== NOT EXECUTED
40007008:	b6 06 e0 0c 	add  %i3, 0xc, %i3                             <== NOT EXECUTED
        return ENOMEM;                                                
                                                                      
      ret = rtems_fdisk_recover_block_mappings (fd);                  
4000700c:	7f ff fa 1d 	call  40005880 <rtems_fdisk_recover_block_mappings><== NOT EXECUTED
40007010:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
      if (ret)                                                        
40007014:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40007018:	22 bf ff f4 	be,a   40006fe8 <rtems_fdisk_ioctl+0x1394>     <== NOT EXECUTED
4000701c:	c2 07 60 30 	ld  [ %i5 + 0x30 ], %g1                        <== NOT EXECUTED
40007020:	10 bf fc 41 	b  40006124 <rtems_fdisk_ioctl+0x4d0>          <== NOT EXECUTED
40007024:	c4 04 20 d8 	ld  [ %l0 + 0xd8 ], %g2                        <== NOT EXECUTED
 */                                                                   
static int                                                            
rtems_fdisk_erase_flash (const rtems_flashdisk* fd)                   
{                                                                     
  uint32_t device;                                                    
  for (device = 0; device < fd->device_count; device++)               
40007028:	10 bf fc 3e 	b  40006120 <rtems_fdisk_ioctl+0x4cc>          <== NOT EXECUTED
4000702c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
  if (ret == 0)                                                       
  {                                                                   
    for (device = 0; device < fd->device_count; device++)             
    {                                                                 
      if (!fd->devices[device].segments)                              
        return ENOMEM;                                                
40007030:	10 bf fc 3c 	b  40006120 <rtems_fdisk_ioctl+0x4cc>          <== NOT EXECUTED
40007034:	90 10 20 0c 	mov  0xc, %o0                                  <== NOT EXECUTED
40007038:	10 bf fe a2 	b  40006ac0 <rtems_fdisk_ioctl+0xe6c>          <== NOT EXECUTED
4000703c:	ea 07 bf e8 	ld  [ %fp + -24 ], %l5                         <== NOT EXECUTED
40007040:	ea 07 bf e8 	ld  [ %fp + -24 ], %l5                         
      if (ret)                                                        
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
40007044:	10 bf fe a0 	b  40006ac4 <rtems_fdisk_ioctl+0xe70>          
40007048:	92 10 20 00 	clr  %o1                                       
    /*                                                                
     * If compacting is configured for the background do it now       
     * to see if we can get some space back.                          
     */                                                               
    if ((fd->flags & RTEMS_FDISK_BACKGROUND_COMPACT))                 
      rtems_fdisk_compact (fd);                                       
4000704c:	7f ff f9 57 	call  400055a8 <rtems_fdisk_compact>           <== NOT EXECUTED
40007050:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 * Pop the head of the segment control queue.                         
 */                                                                   
static rtems_fdisk_segment_ctl*                                       
rtems_fdisk_segment_queue_pop_head (rtems_fdisk_segment_ctl_queue* queue)
{                                                                     
  if (queue->head)                                                    
40007054:	f8 07 60 34 	ld  [ %i5 + 0x34 ], %i4                        <== NOT EXECUTED
40007058:	80 a7 20 00 	cmp  %i4, 0                                    <== NOT EXECUTED
4000705c:	32 bf fe 13 	bne,a   400068a8 <rtems_fdisk_ioctl+0xc54>     <== NOT EXECUTED
40007060:	c2 07 00 00 	ld  [ %i4 ], %g1                               <== NOT EXECUTED
40007064:	10 bf fe f7 	b  40006c40 <rtems_fdisk_ioctl+0xfec>          <== NOT EXECUTED
40007068:	f4 07 bf ec 	ld  [ %fp + -20 ], %i2                         <== NOT EXECUTED
                                                                      

40004e78 <rtems_fdisk_queue_segment>: * @param fd The flash disk control table. * @param sc The segment control table to be reallocated */ static void rtems_fdisk_queue_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc) {
40004e78:	9d e3 bf 90 	save  %sp, -112, %sp                           
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_info (fd, " queue-seg:%02d-%03d: p=%d a=%d u=%d b=%d f=%s n=%s",
40004e7c:	c2 06 60 28 	ld  [ %i1 + 0x28 ], %g1                        
 * @param fd The flash disk control table.                            
 * @param sc The segment control table to be reallocated              
 */                                                                   
static void                                                           
rtems_fdisk_queue_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc)
{                                                                     
40004e80:	b4 10 00 19 	mov  %i1, %i2                                  
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_info (fd, " queue-seg:%02d-%03d: p=%d a=%d u=%d b=%d f=%s n=%s",
40004e84:	d4 06 60 08 	ld  [ %i1 + 8 ], %o2                           
40004e88:	d6 06 60 0c 	ld  [ %i1 + 0xc ], %o3                         
40004e8c:	d8 06 60 14 	ld  [ %i1 + 0x14 ], %o4                        
40004e90:	da 06 60 1c 	ld  [ %i1 + 0x1c ], %o5                        
40004e94:	c8 06 60 20 	ld  [ %i1 + 0x20 ], %g4                        
40004e98:	80 a0 60 00 	cmp  %g1, 0                                    
40004e9c:	02 80 00 2b 	be  40004f48 <rtems_fdisk_queue_segment+0xd0>  <== ALWAYS TAKEN
40004ea0:	c6 06 60 24 	ld  [ %i1 + 0x24 ], %g3                        
40004ea4:	c4 06 80 00 	ld  [ %i2 ], %g2                               <== NOT EXECUTED
40004ea8:	03 10 00 d0 	sethi  %hi(0x40034000), %g1                    <== NOT EXECUTED
40004eac:	80 a0 a0 00 	cmp  %g2, 0                                    <== NOT EXECUTED
40004eb0:	02 80 00 2b 	be  40004f5c <rtems_fdisk_queue_segment+0xe4>  <== NOT EXECUTED
40004eb4:	82 10 63 f8 	or  %g1, 0x3f8, %g1                            <== NOT EXECUTED
40004eb8:	05 10 00 d1 	sethi  %hi(0x40034400), %g2                    
40004ebc:	84 10 a0 08 	or  %g2, 8, %g2	! 40034408 <__FUNCTION__.6193+0x340>
40004ec0:	c2 23 a0 64 	st  %g1, [ %sp + 0x64 ]                        
40004ec4:	c8 23 a0 5c 	st  %g4, [ %sp + 0x5c ]                        
40004ec8:	c6 23 a0 60 	st  %g3, [ %sp + 0x60 ]                        
40004ecc:	c4 23 a0 68 	st  %g2, [ %sp + 0x68 ]                        
40004ed0:	90 10 00 18 	mov  %i0, %o0                                  
40004ed4:	13 10 00 d1 	sethi  %hi(0x40034400), %o1                    
40004ed8:	7f ff fe 44 	call  400047e8 <rtems_fdisk_info>              
40004edc:	92 12 60 18 	or  %o1, 0x18, %o1	! 40034418 <__FUNCTION__.6193+0x350>
                                                                      
  /*                                                                  
   * If the segment has failed then check the failed queue and append 
   * if not failed.                                                   
   */                                                                 
  if (sc->failed)                                                     
40004ee0:	c2 06 a0 28 	ld  [ %i2 + 0x28 ], %g1                        
40004ee4:	80 a0 60 00 	cmp  %g1, 0                                    
40004ee8:	22 80 00 2c 	be,a   40004f98 <rtems_fdisk_queue_segment+0x120><== ALWAYS TAKEN
40004eec:	92 10 00 1a 	mov  %i2, %o1                                  
 */                                                                   
static bool                                                           
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
                                   rtems_fdisk_segment_ctl*       sc) 
{                                                                     
  rtems_fdisk_segment_ctl*  it = queue->head;                         
40004ef0:	c2 06 20 58 	ld  [ %i0 + 0x58 ], %g1                        <== NOT EXECUTED
                                                                      
  while (it)                                                          
40004ef4:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40004ef8:	02 80 00 89 	be  4000511c <rtems_fdisk_queue_segment+0x2a4> <== NOT EXECUTED
40004efc:	80 a6 80 01 	cmp  %i2, %g1                                  <== NOT EXECUTED
  {                                                                   
    if (it == sc)                                                     
40004f00:	32 80 00 06 	bne,a   40004f18 <rtems_fdisk_queue_segment+0xa0><== NOT EXECUTED
40004f04:	c2 00 40 00 	ld  [ %g1 ], %g1                               <== NOT EXECUTED
40004f08:	30 80 00 89 	b,a   4000512c <rtems_fdisk_queue_segment+0x2b4><== NOT EXECUTED
40004f0c:	02 80 00 88 	be  4000512c <rtems_fdisk_queue_segment+0x2b4> <== NOT EXECUTED
40004f10:	01 00 00 00 	nop                                            <== NOT EXECUTED
      return true;                                                    
    it = it->next;                                                    
40004f14:	c2 00 40 00 	ld  [ %g1 ], %g1                               <== NOT EXECUTED
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
                                   rtems_fdisk_segment_ctl*       sc) 
{                                                                     
  rtems_fdisk_segment_ctl*  it = queue->head;                         
                                                                      
  while (it)                                                          
40004f18:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40004f1c:	12 bf ff fc 	bne  40004f0c <rtems_fdisk_queue_segment+0x94> <== NOT EXECUTED
40004f20:	80 a6 80 01 	cmp  %i2, %g1                                  <== NOT EXECUTED
  {                                                                   
    sc->next = 0;                                                     
                                                                      
    if (queue->head)                                                  
    {                                                                 
      queue->tail->next = sc;                                         
40004f24:	c2 06 20 5c 	ld  [ %i0 + 0x5c ], %g1                        <== NOT EXECUTED
rtems_fdisk_segment_queue_push_tail (rtems_fdisk_segment_ctl_queue* queue,
                                     rtems_fdisk_segment_ctl*       sc)
{                                                                     
  if (sc)                                                             
  {                                                                   
    sc->next = 0;                                                     
40004f28:	c0 26 80 00 	clr  [ %i2 ]                                   <== NOT EXECUTED
                                                                      
    if (queue->head)                                                  
    {                                                                 
      queue->tail->next = sc;                                         
40004f2c:	f4 20 40 00 	st  %i2, [ %g1 ]                               <== NOT EXECUTED
      queue->tail       = sc;                                         
40004f30:	f4 26 20 5c 	st  %i2, [ %i0 + 0x5c ]                        <== NOT EXECUTED
    else                                                              
    {                                                                 
      queue->head = queue->tail = sc;                                 
    }                                                                 
                                                                      
    queue->count++;                                                   
40004f34:	c2 06 20 60 	ld  [ %i0 + 0x60 ], %g1                        <== NOT EXECUTED
40004f38:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
40004f3c:	c2 26 20 60 	st  %g1, [ %i0 + 0x60 ]                        <== NOT EXECUTED
40004f40:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40004f44:	81 e8 00 00 	restore                                        <== NOT EXECUTED
 */                                                                   
static void                                                           
rtems_fdisk_queue_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc)
{                                                                     
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_info (fd, " queue-seg:%02d-%03d: p=%d a=%d u=%d b=%d f=%s n=%s",
40004f48:	c4 06 80 00 	ld  [ %i2 ], %g2                               
40004f4c:	03 10 00 d1 	sethi  %hi(0x40034400), %g1                    
40004f50:	80 a0 a0 00 	cmp  %g2, 0                                    
40004f54:	12 bf ff d9 	bne  40004eb8 <rtems_fdisk_queue_segment+0x40> 
40004f58:	82 10 60 00 	mov  %g1, %g1                                  
40004f5c:	05 10 00 d1 	sethi  %hi(0x40034400), %g2                    
40004f60:	84 10 a0 10 	or  %g2, 0x10, %g2	! 40034410 <__FUNCTION__.6193+0x348>
40004f64:	c2 23 a0 64 	st  %g1, [ %sp + 0x64 ]                        
40004f68:	c8 23 a0 5c 	st  %g4, [ %sp + 0x5c ]                        
40004f6c:	c6 23 a0 60 	st  %g3, [ %sp + 0x60 ]                        
40004f70:	c4 23 a0 68 	st  %g2, [ %sp + 0x68 ]                        
40004f74:	90 10 00 18 	mov  %i0, %o0                                  
40004f78:	13 10 00 d1 	sethi  %hi(0x40034400), %o1                    
40004f7c:	7f ff fe 1b 	call  400047e8 <rtems_fdisk_info>              
40004f80:	92 12 60 18 	or  %o1, 0x18, %o1	! 40034418 <__FUNCTION__.6193+0x350>
                                                                      
  /*                                                                  
   * If the segment has failed then check the failed queue and append 
   * if not failed.                                                   
   */                                                                 
  if (sc->failed)                                                     
40004f84:	c2 06 a0 28 	ld  [ %i2 + 0x28 ], %g1                        
40004f88:	80 a0 60 00 	cmp  %g1, 0                                    
40004f8c:	32 bf ff da 	bne,a   40004ef4 <rtems_fdisk_queue_segment+0x7c><== NEVER TAKEN
40004f90:	c2 06 20 58 	ld  [ %i0 + 0x58 ], %g1                        <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * Remove the queue from the available or used queue.               
   */                                                                 
  rtems_fdisk_segment_queue_remove (&fd->available, sc);              
40004f94:	92 10 00 1a 	mov  %i2, %o1                                  
40004f98:	b8 06 20 34 	add  %i0, 0x34, %i4                            
40004f9c:	7f ff fd 94 	call  400045ec <rtems_fdisk_segment_queue_remove>
40004fa0:	90 10 00 1c 	mov  %i4, %o0                                  
  rtems_fdisk_segment_queue_remove (&fd->used, sc);                   
40004fa4:	b6 06 20 40 	add  %i0, 0x40, %i3                            
40004fa8:	92 10 00 1a 	mov  %i2, %o1                                  
40004fac:	7f ff fd 90 	call  400045ec <rtems_fdisk_segment_queue_remove>
40004fb0:	90 10 00 1b 	mov  %i3, %o0                                  
 * active, used and bad pages.                                        
 */                                                                   
static uint32_t                                                       
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)   
{                                                                     
  return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
40004fb4:	c6 06 a0 1c 	ld  [ %i2 + 0x1c ], %g3                        
40004fb8:	fa 06 a0 14 	ld  [ %i2 + 0x14 ], %i5                        
40004fbc:	c2 06 a0 20 	ld  [ %i2 + 0x20 ], %g1                        
40004fc0:	c4 06 a0 24 	ld  [ %i2 + 0x24 ], %g2                        
40004fc4:	88 00 40 03 	add  %g1, %g3, %g4                             
40004fc8:	84 01 00 02 	add  %g4, %g2, %g2                             
   * If they are and the driver has been configured to background     
   * erase place the segment on the used queue. If not configured     
   * to background erase perform the erase now.                       
   *                                                                  
   */                                                                 
  if (rtems_fdisk_seg_pages_available (sc) == 0)                      
40004fcc:	80 a7 40 02 	cmp  %i5, %g2                                  
40004fd0:	02 80 00 29 	be  40005074 <rtems_fdisk_queue_segment+0x1fc> 
40004fd4:	80 a0 e0 00 	cmp  %g3, 0                                    
     * bit is cleared for that segment. When 32 erasers               
     * has occurred the page is re-written to the flash               
     * with all the counters updated with the number of               
     * bits cleared and all bits set back to 1.                       
     */                                                               
    rtems_fdisk_segment_ctl* seg = fd->available.head;                
40004fd8:	f2 06 20 34 	ld  [ %i0 + 0x34 ], %i1                        
                                                                      
    while (seg)                                                       
40004fdc:	80 a6 60 00 	cmp  %i1, 0                                    
40004fe0:	22 80 00 57 	be,a   4000513c <rtems_fdisk_queue_segment+0x2c4>
40004fe4:	c0 26 80 00 	clr  [ %i2 ]                                   
 *                                                                    
 * @param fd The flash disk control table.                            
 * @param sc The segment control table to be reallocated              
 */                                                                   
static void                                                           
rtems_fdisk_queue_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc)
40004fe8:	f6 06 60 20 	ld  [ %i1 + 0x20 ], %i3                        
40004fec:	c2 06 60 24 	ld  [ %i1 + 0x24 ], %g1                        
 * active, used and bad pages.                                        
 */                                                                   
static uint32_t                                                       
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)   
{                                                                     
  return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
40004ff0:	c8 06 60 14 	ld  [ %i1 + 0x14 ], %g4                        
40004ff4:	c6 06 60 1c 	ld  [ %i1 + 0x1c ], %g3                        
40004ff8:	ba 27 40 02 	sub  %i5, %g2, %i5                             
 *                                                                    
 * @param fd The flash disk control table.                            
 * @param sc The segment control table to be reallocated              
 */                                                                   
static void                                                           
rtems_fdisk_queue_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc)
40004ffc:	82 06 c0 01 	add  %i3, %g1, %g1                             
 * active, used and bad pages.                                        
 */                                                                   
static uint32_t                                                       
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)   
{                                                                     
  return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
40005000:	82 21 00 01 	sub  %g4, %g1, %g1                             
40005004:	82 20 40 03 	sub  %g1, %g3, %g1                             
     */                                                               
    rtems_fdisk_segment_ctl* seg = fd->available.head;                
                                                                      
    while (seg)                                                       
    {                                                                 
      if (rtems_fdisk_seg_pages_available (sc) <                      
40005008:	80 a7 40 01 	cmp  %i5, %g1                                  
4000500c:	3a 80 00 0e 	bcc,a   40005044 <rtems_fdisk_queue_segment+0x1cc>
40005010:	f2 06 40 00 	ld  [ %i1 ], %i1                               
        break;                                                        
      seg = seg->next;                                                
    }                                                                 
                                                                      
    if (seg)                                                          
      rtems_fdisk_segment_queue_insert_before (&fd->available, seg, sc);
40005014:	7f ff ff 6f 	call  40004dd0 <rtems_fdisk_segment_queue_insert_before>
40005018:	91 e8 00 1c 	restore  %g0, %i4, %o0                         
 *                                                                    
 * @param fd The flash disk control table.                            
 * @param sc The segment control table to be reallocated              
 */                                                                   
static void                                                           
rtems_fdisk_queue_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc)
4000501c:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
 * active, used and bad pages.                                        
 */                                                                   
static uint32_t                                                       
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)   
{                                                                     
  return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
40005020:	c6 06 60 14 	ld  [ %i1 + 0x14 ], %g3                        
40005024:	c4 06 60 1c 	ld  [ %i1 + 0x1c ], %g2                        
 *                                                                    
 * @param fd The flash disk control table.                            
 * @param sc The segment control table to be reallocated              
 */                                                                   
static void                                                           
rtems_fdisk_queue_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc)
40005028:	82 01 00 01 	add  %g4, %g1, %g1                             
 * active, used and bad pages.                                        
 */                                                                   
static uint32_t                                                       
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)   
{                                                                     
  return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
4000502c:	82 20 c0 01 	sub  %g3, %g1, %g1                             
40005030:	82 20 40 02 	sub  %g1, %g2, %g1                             
     */                                                               
    rtems_fdisk_segment_ctl* seg = fd->available.head;                
                                                                      
    while (seg)                                                       
    {                                                                 
      if (rtems_fdisk_seg_pages_available (sc) <                      
40005034:	80 a7 40 01 	cmp  %i5, %g1                                  
40005038:	0a bf ff f7 	bcs  40005014 <rtems_fdisk_queue_segment+0x19c><== NEVER TAKEN
4000503c:	01 00 00 00 	nop                                            
          rtems_fdisk_seg_pages_available (seg))                      
        break;                                                        
      seg = seg->next;                                                
40005040:	f2 06 40 00 	ld  [ %i1 ], %i1                               
     * with all the counters updated with the number of               
     * bits cleared and all bits set back to 1.                       
     */                                                               
    rtems_fdisk_segment_ctl* seg = fd->available.head;                
                                                                      
    while (seg)                                                       
40005044:	80 a6 60 00 	cmp  %i1, 0                                    
40005048:	32 bf ff f5 	bne,a   4000501c <rtems_fdisk_queue_segment+0x1a4>
4000504c:	c8 06 60 24 	ld  [ %i1 + 0x24 ], %g4                        
  {                                                                   
    sc->next = 0;                                                     
                                                                      
    if (queue->head)                                                  
    {                                                                 
      queue->tail->next = sc;                                         
40005050:	c2 06 20 38 	ld  [ %i0 + 0x38 ], %g1                        
rtems_fdisk_segment_queue_push_tail (rtems_fdisk_segment_ctl_queue* queue,
                                     rtems_fdisk_segment_ctl*       sc)
{                                                                     
  if (sc)                                                             
  {                                                                   
    sc->next = 0;                                                     
40005054:	c0 26 80 00 	clr  [ %i2 ]                                   
                                                                      
    if (queue->head)                                                  
    {                                                                 
      queue->tail->next = sc;                                         
40005058:	f4 20 40 00 	st  %i2, [ %g1 ]                               
      queue->tail       = sc;                                         
4000505c:	f4 26 20 38 	st  %i2, [ %i0 + 0x38 ]                        
    else                                                              
    {                                                                 
      queue->head = queue->tail = sc;                                 
    }                                                                 
                                                                      
    queue->count++;                                                   
40005060:	c2 06 20 3c 	ld  [ %i0 + 0x3c ], %g1                        
40005064:	82 00 60 01 	inc  %g1                                       
40005068:	c2 26 20 3c 	st  %g1, [ %i0 + 0x3c ]                        
4000506c:	81 c7 e0 08 	ret                                            
40005070:	81 e8 00 00 	restore                                        
   * to background erase perform the erase now.                       
   *                                                                  
   */                                                                 
  if (rtems_fdisk_seg_pages_available (sc) == 0)                      
  {                                                                   
    if (sc->pages_active)                                             
40005074:	22 80 00 1b 	be,a   400050e0 <rtems_fdisk_queue_segment+0x268><== NEVER TAKEN
40005078:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           <== NOT EXECUTED
      /*                                                              
       * Keep the used queue sorted by the most number of used        
       * pages. When we compact we want to move the pages into        
       * a new segment and cover more than one segment.               
       */                                                             
      rtems_fdisk_segment_ctl* seg = fd->used.head;                   
4000507c:	f2 06 20 40 	ld  [ %i0 + 0x40 ], %i1                        
                                                                      
      while (seg)                                                     
40005080:	80 a6 60 00 	cmp  %i1, 0                                    
40005084:	22 80 00 36 	be,a   4000515c <rtems_fdisk_queue_segment+0x2e4>
40005088:	c0 26 80 00 	clr  [ %i2 ]                                   
      {                                                               
        if (sc->pages_used > seg->pages_used)                         
4000508c:	c4 06 60 20 	ld  [ %i1 + 0x20 ], %g2                        
40005090:	80 a0 40 02 	cmp  %g1, %g2                                  
40005094:	28 80 00 07 	bleu,a   400050b0 <rtems_fdisk_queue_segment+0x238>
40005098:	f2 06 40 00 	ld  [ %i1 ], %i1                               
4000509c:	30 80 00 26 	b,a   40005134 <rtems_fdisk_queue_segment+0x2bc>
400050a0:	80 a0 80 01 	cmp  %g2, %g1                                  
400050a4:	0a 80 00 24 	bcs  40005134 <rtems_fdisk_queue_segment+0x2bc>
400050a8:	01 00 00 00 	nop                                            
          break;                                                      
        seg = seg->next;                                              
400050ac:	f2 06 40 00 	ld  [ %i1 ], %i1                               
       * pages. When we compact we want to move the pages into        
       * a new segment and cover more than one segment.               
       */                                                             
      rtems_fdisk_segment_ctl* seg = fd->used.head;                   
                                                                      
      while (seg)                                                     
400050b0:	80 a6 60 00 	cmp  %i1, 0                                    
400050b4:	32 bf ff fb 	bne,a   400050a0 <rtems_fdisk_queue_segment+0x228>
400050b8:	c4 06 60 20 	ld  [ %i1 + 0x20 ], %g2                        
  {                                                                   
    sc->next = 0;                                                     
                                                                      
    if (queue->head)                                                  
    {                                                                 
      queue->tail->next = sc;                                         
400050bc:	c2 06 20 44 	ld  [ %i0 + 0x44 ], %g1                        
rtems_fdisk_segment_queue_push_tail (rtems_fdisk_segment_ctl_queue* queue,
                                     rtems_fdisk_segment_ctl*       sc)
{                                                                     
  if (sc)                                                             
  {                                                                   
    sc->next = 0;                                                     
400050c0:	c0 26 80 00 	clr  [ %i2 ]                                   
                                                                      
    if (queue->head)                                                  
    {                                                                 
      queue->tail->next = sc;                                         
400050c4:	f4 20 40 00 	st  %i2, [ %g1 ]                               
      queue->tail       = sc;                                         
400050c8:	f4 26 20 44 	st  %i2, [ %i0 + 0x44 ]                        
    else                                                              
    {                                                                 
      queue->head = queue->tail = sc;                                 
    }                                                                 
                                                                      
    queue->count++;                                                   
400050cc:	c2 06 20 48 	ld  [ %i0 + 0x48 ], %g1                        
400050d0:	82 00 60 01 	inc  %g1                                       
400050d4:	c2 26 20 48 	st  %g1, [ %i0 + 0x48 ]                        
400050d8:	81 c7 e0 08 	ret                                            
400050dc:	81 e8 00 00 	restore                                        
      else                                                            
        rtems_fdisk_segment_queue_push_tail (&fd->used, sc);          
    }                                                                 
    else                                                              
    {                                                                 
      if ((fd->flags & RTEMS_FDISK_BACKGROUND_ERASE))                 
400050e0:	80 88 60 01 	btst  1, %g1                                   <== NOT EXECUTED
400050e4:	02 80 00 19 	be  40005148 <rtems_fdisk_queue_segment+0x2d0> <== NOT EXECUTED
400050e8:	01 00 00 00 	nop                                            <== NOT EXECUTED
{                                                                     
  if (sc)                                                             
  {                                                                   
    sc->next = 0;                                                     
                                                                      
    if (queue->head)                                                  
400050ec:	c2 06 20 4c 	ld  [ %i0 + 0x4c ], %g1                        <== NOT EXECUTED
400050f0:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
400050f4:	02 80 00 17 	be  40005150 <rtems_fdisk_queue_segment+0x2d8> <== NOT EXECUTED
400050f8:	c0 26 80 00 	clr  [ %i2 ]                                   <== NOT EXECUTED
    {                                                                 
      queue->tail->next = sc;                                         
400050fc:	c2 06 20 50 	ld  [ %i0 + 0x50 ], %g1                        <== NOT EXECUTED
40005100:	f4 20 40 00 	st  %i2, [ %g1 ]                               <== NOT EXECUTED
      queue->tail       = sc;                                         
40005104:	f4 26 20 50 	st  %i2, [ %i0 + 0x50 ]                        <== NOT EXECUTED
    else                                                              
    {                                                                 
      queue->head = queue->tail = sc;                                 
    }                                                                 
                                                                      
    queue->count++;                                                   
40005108:	c2 06 20 54 	ld  [ %i0 + 0x54 ], %g1                        <== NOT EXECUTED
4000510c:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
40005110:	c2 26 20 54 	st  %g1, [ %i0 + 0x54 ]                        <== NOT EXECUTED
40005114:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40005118:	81 e8 00 00 	restore                                        <== NOT EXECUTED
rtems_fdisk_segment_queue_push_tail (rtems_fdisk_segment_ctl_queue* queue,
                                     rtems_fdisk_segment_ctl*       sc)
{                                                                     
  if (sc)                                                             
  {                                                                   
    sc->next = 0;                                                     
4000511c:	c0 26 80 00 	clr  [ %i2 ]                                   <== NOT EXECUTED
      queue->tail->next = sc;                                         
      queue->tail       = sc;                                         
    }                                                                 
    else                                                              
    {                                                                 
      queue->head = queue->tail = sc;                                 
40005120:	f4 26 20 5c 	st  %i2, [ %i0 + 0x5c ]                        <== NOT EXECUTED
40005124:	10 bf ff 84 	b  40004f34 <rtems_fdisk_queue_segment+0xbc>   <== NOT EXECUTED
40005128:	f4 26 20 58 	st  %i2, [ %i0 + 0x58 ]                        <== NOT EXECUTED
4000512c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40005130:	81 e8 00 00 	restore                                        <== NOT EXECUTED
          break;                                                      
        seg = seg->next;                                              
      }                                                               
                                                                      
      if (seg)                                                        
        rtems_fdisk_segment_queue_insert_before (&fd->used, seg, sc); 
40005134:	7f ff ff 27 	call  40004dd0 <rtems_fdisk_segment_queue_insert_before>
40005138:	91 e8 00 1b 	restore  %g0, %i3, %o0                         
      queue->tail->next = sc;                                         
      queue->tail       = sc;                                         
    }                                                                 
    else                                                              
    {                                                                 
      queue->head = queue->tail = sc;                                 
4000513c:	f4 26 20 38 	st  %i2, [ %i0 + 0x38 ]                        
40005140:	10 bf ff c8 	b  40005060 <rtems_fdisk_queue_segment+0x1e8>  
40005144:	f4 26 20 34 	st  %i2, [ %i0 + 0x34 ]                        
    else                                                              
    {                                                                 
      if ((fd->flags & RTEMS_FDISK_BACKGROUND_ERASE))                 
        rtems_fdisk_segment_queue_push_tail (&fd->erase, sc);         
      else                                                            
        rtems_fdisk_erase_segment (fd, sc);                           
40005148:	7f ff fe c3 	call  40004c54 <rtems_fdisk_erase_segment>     <== NOT EXECUTED
4000514c:	93 e8 00 1a 	restore  %g0, %i2, %o1                         <== NOT EXECUTED
      queue->tail->next = sc;                                         
      queue->tail       = sc;                                         
    }                                                                 
    else                                                              
    {                                                                 
      queue->head = queue->tail = sc;                                 
40005150:	f4 26 20 50 	st  %i2, [ %i0 + 0x50 ]                        <== NOT EXECUTED
40005154:	10 bf ff ed 	b  40005108 <rtems_fdisk_queue_segment+0x290>  <== NOT EXECUTED
40005158:	f4 26 20 4c 	st  %i2, [ %i0 + 0x4c ]                        <== NOT EXECUTED
4000515c:	f4 26 20 44 	st  %i2, [ %i0 + 0x44 ]                        
40005160:	10 bf ff db 	b  400050cc <rtems_fdisk_queue_segment+0x254>  
40005164:	f4 26 20 40 	st  %i2, [ %i0 + 0x40 ]                        
                                                                      

40004670 <rtems_fdisk_queue_status>: */ static bool rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue, rtems_fdisk_segment_ctl* sc) { rtems_fdisk_segment_ctl* it = queue->head;
40004670:	c2 02 20 34 	ld  [ %o0 + 0x34 ], %g1                        
                                                                      
  while (it)                                                          
40004674:	80 a0 60 00 	cmp  %g1, 0                                    
40004678:	12 80 00 07 	bne  40004694 <rtems_fdisk_queue_status+0x24>  <== ALWAYS TAKEN
4000467c:	80 a2 40 01 	cmp  %o1, %g1                                  
static void                                                           
rtems_fdisk_queue_status (rtems_flashdisk*         fd,                
                          rtems_fdisk_segment_ctl* sc,                
                          char                     queues[5])         
{                                                                     
  queues[0] = rtems_fdisk_segment_queue_present (&fd->available, sc) ? 'A' : '-';
40004680:	10 80 00 0a 	b  400046a8 <rtems_fdisk_queue_status+0x38>    <== NOT EXECUTED
40004684:	82 10 20 2d 	mov  0x2d, %g1                                 <== NOT EXECUTED
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
                                   rtems_fdisk_segment_ctl*       sc) 
{                                                                     
  rtems_fdisk_segment_ctl*  it = queue->head;                         
                                                                      
  while (it)                                                          
40004688:	80 a0 60 00 	cmp  %g1, 0                                    
4000468c:	02 80 00 06 	be  400046a4 <rtems_fdisk_queue_status+0x34>   <== ALWAYS TAKEN
40004690:	80 a2 40 01 	cmp  %o1, %g1                                  
  {                                                                   
    if (it == sc)                                                     
40004694:	32 bf ff fd 	bne,a   40004688 <rtems_fdisk_queue_status+0x18>
40004698:	c2 00 40 00 	ld  [ %g1 ], %g1                               
static void                                                           
rtems_fdisk_queue_status (rtems_flashdisk*         fd,                
                          rtems_fdisk_segment_ctl* sc,                
                          char                     queues[5])         
{                                                                     
  queues[0] = rtems_fdisk_segment_queue_present (&fd->available, sc) ? 'A' : '-';
4000469c:	10 80 00 03 	b  400046a8 <rtems_fdisk_queue_status+0x38>    
400046a0:	82 10 20 41 	mov  0x41, %g1                                 
400046a4:	82 10 20 2d 	mov  0x2d, %g1                                 
400046a8:	c2 2a 80 00 	stb  %g1, [ %o2 ]                              
 */                                                                   
static bool                                                           
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
                                   rtems_fdisk_segment_ctl*       sc) 
{                                                                     
  rtems_fdisk_segment_ctl*  it = queue->head;                         
400046ac:	c2 02 20 40 	ld  [ %o0 + 0x40 ], %g1                        
                                                                      
  while (it)                                                          
400046b0:	80 a0 60 00 	cmp  %g1, 0                                    
400046b4:	12 80 00 07 	bne  400046d0 <rtems_fdisk_queue_status+0x60>  <== ALWAYS TAKEN
400046b8:	80 a2 40 01 	cmp  %o1, %g1                                  
rtems_fdisk_queue_status (rtems_flashdisk*         fd,                
                          rtems_fdisk_segment_ctl* sc,                
                          char                     queues[5])         
{                                                                     
  queues[0] = rtems_fdisk_segment_queue_present (&fd->available, sc) ? 'A' : '-';
  queues[1] = rtems_fdisk_segment_queue_present (&fd->used, sc)      ? 'U' : '-';
400046bc:	10 80 00 0a 	b  400046e4 <rtems_fdisk_queue_status+0x74>    <== NOT EXECUTED
400046c0:	82 10 20 2d 	mov  0x2d, %g1                                 <== NOT EXECUTED
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
                                   rtems_fdisk_segment_ctl*       sc) 
{                                                                     
  rtems_fdisk_segment_ctl*  it = queue->head;                         
                                                                      
  while (it)                                                          
400046c4:	80 a0 60 00 	cmp  %g1, 0                                    
400046c8:	02 80 00 06 	be  400046e0 <rtems_fdisk_queue_status+0x70>   
400046cc:	80 a2 40 01 	cmp  %o1, %g1                                  
  {                                                                   
    if (it == sc)                                                     
400046d0:	32 bf ff fd 	bne,a   400046c4 <rtems_fdisk_queue_status+0x54>
400046d4:	c2 00 40 00 	ld  [ %g1 ], %g1                               
rtems_fdisk_queue_status (rtems_flashdisk*         fd,                
                          rtems_fdisk_segment_ctl* sc,                
                          char                     queues[5])         
{                                                                     
  queues[0] = rtems_fdisk_segment_queue_present (&fd->available, sc) ? 'A' : '-';
  queues[1] = rtems_fdisk_segment_queue_present (&fd->used, sc)      ? 'U' : '-';
400046d8:	10 80 00 03 	b  400046e4 <rtems_fdisk_queue_status+0x74>    
400046dc:	82 10 20 55 	mov  0x55, %g1                                 
400046e0:	82 10 20 2d 	mov  0x2d, %g1                                 
400046e4:	c2 2a a0 01 	stb  %g1, [ %o2 + 1 ]                          
 */                                                                   
static bool                                                           
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
                                   rtems_fdisk_segment_ctl*       sc) 
{                                                                     
  rtems_fdisk_segment_ctl*  it = queue->head;                         
400046e8:	c2 02 20 4c 	ld  [ %o0 + 0x4c ], %g1                        
                                                                      
  while (it)                                                          
400046ec:	80 a0 60 00 	cmp  %g1, 0                                    
400046f0:	12 80 00 07 	bne  4000470c <rtems_fdisk_queue_status+0x9c>  <== NEVER TAKEN
400046f4:	80 a2 40 01 	cmp  %o1, %g1                                  
                          rtems_fdisk_segment_ctl* sc,                
                          char                     queues[5])         
{                                                                     
  queues[0] = rtems_fdisk_segment_queue_present (&fd->available, sc) ? 'A' : '-';
  queues[1] = rtems_fdisk_segment_queue_present (&fd->used, sc)      ? 'U' : '-';
  queues[2] = rtems_fdisk_segment_queue_present (&fd->erase, sc)     ? 'E' : '-';
400046f8:	10 80 00 0a 	b  40004720 <rtems_fdisk_queue_status+0xb0>    
400046fc:	82 10 20 2d 	mov  0x2d, %g1                                 
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
                                   rtems_fdisk_segment_ctl*       sc) 
{                                                                     
  rtems_fdisk_segment_ctl*  it = queue->head;                         
                                                                      
  while (it)                                                          
40004700:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40004704:	02 80 00 06 	be  4000471c <rtems_fdisk_queue_status+0xac>   <== NOT EXECUTED
40004708:	80 a2 40 01 	cmp  %o1, %g1                                  <== NOT EXECUTED
  {                                                                   
    if (it == sc)                                                     
4000470c:	32 bf ff fd 	bne,a   40004700 <rtems_fdisk_queue_status+0x90><== NOT EXECUTED
40004710:	c2 00 40 00 	ld  [ %g1 ], %g1                               <== NOT EXECUTED
                          rtems_fdisk_segment_ctl* sc,                
                          char                     queues[5])         
{                                                                     
  queues[0] = rtems_fdisk_segment_queue_present (&fd->available, sc) ? 'A' : '-';
  queues[1] = rtems_fdisk_segment_queue_present (&fd->used, sc)      ? 'U' : '-';
  queues[2] = rtems_fdisk_segment_queue_present (&fd->erase, sc)     ? 'E' : '-';
40004714:	10 80 00 03 	b  40004720 <rtems_fdisk_queue_status+0xb0>    <== NOT EXECUTED
40004718:	82 10 20 45 	mov  0x45, %g1                                 <== NOT EXECUTED
4000471c:	82 10 20 2d 	mov  0x2d, %g1                                 <== NOT EXECUTED
40004720:	c2 2a a0 02 	stb  %g1, [ %o2 + 2 ]                          
 */                                                                   
static bool                                                           
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
                                   rtems_fdisk_segment_ctl*       sc) 
{                                                                     
  rtems_fdisk_segment_ctl*  it = queue->head;                         
40004724:	c2 02 20 58 	ld  [ %o0 + 0x58 ], %g1                        
                                                                      
  while (it)                                                          
40004728:	80 a0 60 00 	cmp  %g1, 0                                    
4000472c:	12 80 00 07 	bne  40004748 <rtems_fdisk_queue_status+0xd8>  <== NEVER TAKEN
40004730:	80 a2 40 01 	cmp  %o1, %g1                                  
                          char                     queues[5])         
{                                                                     
  queues[0] = rtems_fdisk_segment_queue_present (&fd->available, sc) ? 'A' : '-';
  queues[1] = rtems_fdisk_segment_queue_present (&fd->used, sc)      ? 'U' : '-';
  queues[2] = rtems_fdisk_segment_queue_present (&fd->erase, sc)     ? 'E' : '-';
  queues[3] = rtems_fdisk_segment_queue_present (&fd->failed, sc)    ? 'F' : '-';
40004734:	10 80 00 0c 	b  40004764 <rtems_fdisk_queue_status+0xf4>    
40004738:	82 10 20 2d 	mov  0x2d, %g1                                 
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
                                   rtems_fdisk_segment_ctl*       sc) 
{                                                                     
  rtems_fdisk_segment_ctl*  it = queue->head;                         
                                                                      
  while (it)                                                          
4000473c:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40004740:	02 80 00 08 	be  40004760 <rtems_fdisk_queue_status+0xf0>   <== NOT EXECUTED
40004744:	80 a2 40 01 	cmp  %o1, %g1                                  <== NOT EXECUTED
  {                                                                   
    if (it == sc)                                                     
40004748:	32 bf ff fd 	bne,a   4000473c <rtems_fdisk_queue_status+0xcc><== NOT EXECUTED
4000474c:	c2 00 40 00 	ld  [ %g1 ], %g1                               <== NOT EXECUTED
                          char                     queues[5])         
{                                                                     
  queues[0] = rtems_fdisk_segment_queue_present (&fd->available, sc) ? 'A' : '-';
  queues[1] = rtems_fdisk_segment_queue_present (&fd->used, sc)      ? 'U' : '-';
  queues[2] = rtems_fdisk_segment_queue_present (&fd->erase, sc)     ? 'E' : '-';
  queues[3] = rtems_fdisk_segment_queue_present (&fd->failed, sc)    ? 'F' : '-';
40004750:	82 10 20 46 	mov  0x46, %g1                                 <== NOT EXECUTED
  queues[4] = '\0';                                                   
40004754:	c0 2a a0 04 	clrb  [ %o2 + 4 ]                              <== NOT EXECUTED
40004758:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
4000475c:	c2 2a a0 03 	stb  %g1, [ %o2 + 3 ]                          <== NOT EXECUTED
                          char                     queues[5])         
{                                                                     
  queues[0] = rtems_fdisk_segment_queue_present (&fd->available, sc) ? 'A' : '-';
  queues[1] = rtems_fdisk_segment_queue_present (&fd->used, sc)      ? 'U' : '-';
  queues[2] = rtems_fdisk_segment_queue_present (&fd->erase, sc)     ? 'E' : '-';
  queues[3] = rtems_fdisk_segment_queue_present (&fd->failed, sc)    ? 'F' : '-';
40004760:	82 10 20 2d 	mov  0x2d, %g1                                 <== NOT EXECUTED
  queues[4] = '\0';                                                   
40004764:	c0 2a a0 04 	clrb  [ %o2 + 4 ]                              
40004768:	81 c3 e0 08 	retl                                           
4000476c:	c2 2a a0 03 	stb  %g1, [ %o2 + 3 ]                          
                                                                      

40005880 <rtems_fdisk_recover_block_mappings>: /** * Recover the block mappings from the devices. */ static int rtems_fdisk_recover_block_mappings (rtems_flashdisk* fd) {
40005880:	9d e3 bf 90 	save  %sp, -112, %sp                           
  rtems_fdisk_segment_queue_init (&fd->failed);                       
                                                                      
  /*                                                                  
   * Clear the lock mappings.                                         
   */                                                                 
  memset (fd->blocks, 0, fd->block_count * sizeof (rtems_fdisk_block_ctl));
40005884:	d4 06 20 1c 	ld  [ %i0 + 0x1c ], %o2                        
40005888:	d0 06 20 18 	ld  [ %i0 + 0x18 ], %o0                        
 * Initialise the segment control queue.                              
 */                                                                   
static void                                                           
rtems_fdisk_segment_queue_init (rtems_fdisk_segment_ctl_queue* queue) 
{                                                                     
  queue->head = queue->tail = 0;                                      
4000588c:	c0 26 20 38 	clr  [ %i0 + 0x38 ]                            
40005890:	c0 26 20 34 	clr  [ %i0 + 0x34 ]                            
  queue->count = 0;                                                   
40005894:	c0 26 20 3c 	clr  [ %i0 + 0x3c ]                            
 * Initialise the segment control queue.                              
 */                                                                   
static void                                                           
rtems_fdisk_segment_queue_init (rtems_fdisk_segment_ctl_queue* queue) 
{                                                                     
  queue->head = queue->tail = 0;                                      
40005898:	c0 26 20 44 	clr  [ %i0 + 0x44 ]                            
4000589c:	c0 26 20 40 	clr  [ %i0 + 0x40 ]                            
  queue->count = 0;                                                   
400058a0:	c0 26 20 48 	clr  [ %i0 + 0x48 ]                            
 * Initialise the segment control queue.                              
 */                                                                   
static void                                                           
rtems_fdisk_segment_queue_init (rtems_fdisk_segment_ctl_queue* queue) 
{                                                                     
  queue->head = queue->tail = 0;                                      
400058a4:	c0 26 20 50 	clr  [ %i0 + 0x50 ]                            
400058a8:	c0 26 20 4c 	clr  [ %i0 + 0x4c ]                            
  queue->count = 0;                                                   
400058ac:	c0 26 20 54 	clr  [ %i0 + 0x54 ]                            
 * Initialise the segment control queue.                              
 */                                                                   
static void                                                           
rtems_fdisk_segment_queue_init (rtems_fdisk_segment_ctl_queue* queue) 
{                                                                     
  queue->head = queue->tail = 0;                                      
400058b0:	c0 26 20 5c 	clr  [ %i0 + 0x5c ]                            
400058b4:	c0 26 20 58 	clr  [ %i0 + 0x58 ]                            
  queue->count = 0;                                                   
400058b8:	c0 26 20 60 	clr  [ %i0 + 0x60 ]                            
  rtems_fdisk_segment_queue_init (&fd->failed);                       
                                                                      
  /*                                                                  
   * Clear the lock mappings.                                         
   */                                                                 
  memset (fd->blocks, 0, fd->block_count * sizeof (rtems_fdisk_block_ctl));
400058bc:	92 10 20 00 	clr  %o1                                       
400058c0:	40 00 79 31 	call  40023d84 <memset>                        
400058c4:	95 2a a0 03 	sll  %o2, 3, %o2                               
  /*                                                                  
   * Scan each segment or each device recovering the valid pages.     
   */                                                                 
  fd->erased_blocks = 0;                                              
  fd->starvation_threshold = 0;                                       
  for (device = 0; device < fd->device_count; device++)               
400058c8:	c6 06 20 30 	ld  [ %i0 + 0x30 ], %g3                        
  memset (fd->blocks, 0, fd->block_count * sizeof (rtems_fdisk_block_ctl));
                                                                      
  /*                                                                  
   * Scan each segment or each device recovering the valid pages.     
   */                                                                 
  fd->erased_blocks = 0;                                              
400058cc:	c0 26 20 28 	clr  [ %i0 + 0x28 ]                            
  fd->starvation_threshold = 0;                                       
400058d0:	c0 26 20 24 	clr  [ %i0 + 0x24 ]                            
  for (device = 0; device < fd->device_count; device++)               
400058d4:	80 a0 e0 00 	cmp  %g3, 0                                    
400058d8:	02 80 00 82 	be  40005ae0 <rtems_fdisk_recover_block_mappings+0x260><== NEVER TAKEN
400058dc:	ae 10 00 18 	mov  %i0, %l7                                  
400058e0:	c4 06 20 2c 	ld  [ %i0 + 0x2c ], %g2                        
      rtems_fdisk_page_desc*          pd;                             
      uint32_t                        page;                           
      int                             ret;                            
                                                                      
#if RTEMS_FDISK_TRACE                                                 
      rtems_fdisk_info (fd, "recover-block-mappings:%02d-%03d", device, segment);
400058e4:	25 10 00 d1 	sethi  %hi(0x40034400), %l2                    
            ++fd->erased_blocks;                                      
          }                                                           
          else                                                        
          {                                                           
#if RTEMS_FDISK_TRACE                                                 
            rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",      
400058e8:	29 10 00 d1 	sethi  %hi(0x40034400), %l4                    
            ret = rtems_fdisk_seg_write_page_desc (fd, sc,            
                                                   page, pd);         
                                                                      
            if (ret)                                                  
            {                                                         
              rtems_fdisk_error ("forcing page to used failed: %d-%d-%d",
400058ec:	2d 10 00 d1 	sethi  %hi(0x40034400), %l6                    
               * each block so we can tell which is the later block when
               * duplicates appear. A power down with a failed wirte could cause
               * a duplicate.                                         
               */                                                     
              const rtems_fdisk_segment_ctl* bsc = fd->blocks[pd->block].segment;
              rtems_fdisk_error ("duplicate block: %d-%d-%d: " \      
400058f0:	27 10 00 d1 	sethi  %hi(0x40034400), %l3                    
          else if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_ACTIVE))
          {                                                           
            if (pd->block >= fd->block_count)                         
            {                                                         
#if RTEMS_FDISK_TRACE                                                 
              rtems_fdisk_warning (fd,                                
400058f4:	2b 10 00 d1 	sethi  %hi(0x40034400), %l5                    
  /*                                                                  
   * Scan each segment or each device recovering the valid pages.     
   */                                                                 
  fd->erased_blocks = 0;                                              
  fd->starvation_threshold = 0;                                       
  for (device = 0; device < fd->device_count; device++)               
400058f8:	a2 10 20 00 	clr  %l1                                       
400058fc:	b2 10 20 00 	clr  %i1                                       
      rtems_fdisk_page_desc*          pd;                             
      uint32_t                        page;                           
      int                             ret;                            
                                                                      
#if RTEMS_FDISK_TRACE                                                 
      rtems_fdisk_info (fd, "recover-block-mappings:%02d-%03d", device, segment);
40005900:	a4 14 a3 00 	or  %l2, 0x300, %l2                            
            ++fd->erased_blocks;                                      
          }                                                           
          else                                                        
          {                                                           
#if RTEMS_FDISK_TRACE                                                 
            rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",      
40005904:	a8 15 23 70 	or  %l4, 0x370, %l4                            
            ret = rtems_fdisk_seg_write_page_desc (fd, sc,            
                                                   page, pd);         
                                                                      
            if (ret)                                                  
            {                                                         
              rtems_fdisk_error ("forcing page to used failed: %d-%d-%d",
40005908:	ac 15 a3 90 	or  %l6, 0x390, %l6                            
               * each block so we can tell which is the later block when
               * duplicates appear. A power down with a failed wirte could cause
               * a duplicate.                                         
               */                                                     
              const rtems_fdisk_segment_ctl* bsc = fd->blocks[pd->block].segment;
              rtems_fdisk_error ("duplicate block: %d-%d-%d: " \      
4000590c:	a6 14 e3 e8 	or  %l3, 0x3e8, %l3                            
          else if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_ACTIVE))
          {                                                           
            if (pd->block >= fd->block_count)                         
            {                                                         
#if RTEMS_FDISK_TRACE                                                 
              rtems_fdisk_warning (fd,                                
40005910:	aa 15 63 b8 	or  %l5, 0x3b8, %l5                            
  fd->erased_blocks = 0;                                              
  fd->starvation_threshold = 0;                                       
  for (device = 0; device < fd->device_count; device++)               
  {                                                                   
    uint32_t segment;                                                 
    for (segment = 0; segment < fd->devices[device].segment_count; segment++)
40005914:	82 00 80 11 	add  %g2, %l1, %g1                             
40005918:	c8 00 60 04 	ld  [ %g1 + 4 ], %g4                           
4000591c:	a0 10 20 00 	clr  %l0                                       
40005920:	80 a1 20 00 	cmp  %g4, 0                                    
40005924:	02 80 00 6b 	be  40005ad0 <rtems_fdisk_recover_block_mappings+0x250><== NEVER TAKEN
40005928:	b4 10 20 00 	clr  %i2                                       
    {                                                                 
      rtems_fdisk_segment_ctl*        sc = &fd->devices[device].segments[segment];
4000592c:	f6 00 40 00 	ld  [ %g1 ], %i3                               
      rtems_fdisk_page_desc*          pd;                             
      uint32_t                        page;                           
      int                             ret;                            
                                                                      
#if RTEMS_FDISK_TRACE                                                 
      rtems_fdisk_info (fd, "recover-block-mappings:%02d-%03d", device, segment);
40005930:	94 10 00 19 	mov  %i1, %o2                                  
  for (device = 0; device < fd->device_count; device++)               
  {                                                                   
    uint32_t segment;                                                 
    for (segment = 0; segment < fd->devices[device].segment_count; segment++)
    {                                                                 
      rtems_fdisk_segment_ctl*        sc = &fd->devices[device].segments[segment];
40005934:	b6 06 c0 10 	add  %i3, %l0, %i3                             
      const rtems_fdisk_segment_desc* sd = sc->descriptor;            
40005938:	fa 06 e0 04 	ld  [ %i3 + 4 ], %i5                           
      rtems_fdisk_page_desc*          pd;                             
      uint32_t                        page;                           
      int                             ret;                            
                                                                      
#if RTEMS_FDISK_TRACE                                                 
      rtems_fdisk_info (fd, "recover-block-mappings:%02d-%03d", device, segment);
4000593c:	96 10 00 1a 	mov  %i2, %o3                                  
40005940:	92 10 00 12 	mov  %l2, %o1                                  
40005944:	7f ff fb a9 	call  400047e8 <rtems_fdisk_info>              
40005948:	90 10 00 17 	mov  %l7, %o0                                  
 */                                                                   
static uint32_t                                                       
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,     
                              uint32_t                        page_size)
{                                                                     
  return sd->size / page_size;                                        
4000594c:	d0 07 60 08 	ld  [ %i5 + 8 ], %o0                           
                                                                      
#if RTEMS_FDISK_TRACE                                                 
      rtems_fdisk_info (fd, "recover-block-mappings:%02d-%03d", device, segment);
#endif                                                                
                                                                      
      sc->pages_desc = rtems_fdisk_page_desc_pages (sd, fd->block_size);
40005950:	f8 05 e0 14 	ld  [ %l7 + 0x14 ], %i4                        
 */                                                                   
static uint32_t                                                       
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,     
                              uint32_t                        page_size)
{                                                                     
  return sd->size / page_size;                                        
40005954:	7f ff f3 53 	call  400026a0 <.udiv>                         
40005958:	92 10 00 1c 	mov  %i4, %o1                                  
rtems_fdisk_page_desc_pages (const rtems_fdisk_segment_desc* sd,      
                             uint32_t                        page_size)
{                                                                     
  uint32_t pages = rtems_fdisk_pages_in_segment (sd, page_size);      
  uint32_t bytes = pages * sizeof (rtems_fdisk_page_desc);            
  return ((bytes - 1) / page_size) + 1;                               
4000595c:	92 10 00 1c 	mov  %i4, %o1                                  
 */                                                                   
static uint32_t                                                       
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,     
                              uint32_t                        page_size)
{                                                                     
  return sd->size / page_size;                                        
40005960:	ba 10 00 08 	mov  %o0, %i5                                  
static uint32_t                                                       
rtems_fdisk_page_desc_pages (const rtems_fdisk_segment_desc* sd,      
                             uint32_t                        page_size)
{                                                                     
  uint32_t pages = rtems_fdisk_pages_in_segment (sd, page_size);      
  uint32_t bytes = pages * sizeof (rtems_fdisk_page_desc);            
40005964:	91 2a 20 03 	sll  %o0, 3, %o0                               
  return ((bytes - 1) / page_size) + 1;                               
40005968:	7f ff f3 4e 	call  400026a0 <.udiv>                         
4000596c:	90 02 3f ff 	add  %o0, -1, %o0                              
#endif                                                                
                                                                      
      sc->pages_desc = rtems_fdisk_page_desc_pages (sd, fd->block_size);
      sc->pages =                                                     
        rtems_fdisk_pages_in_segment (sd, fd->block_size) - sc->pages_desc;
      if (sc->pages > fd->starvation_threshold)                       
40005970:	c4 05 e0 24 	ld  [ %l7 + 0x24 ], %g2                        
rtems_fdisk_page_desc_pages (const rtems_fdisk_segment_desc* sd,      
                             uint32_t                        page_size)
{                                                                     
  uint32_t pages = rtems_fdisk_pages_in_segment (sd, page_size);      
  uint32_t bytes = pages * sizeof (rtems_fdisk_page_desc);            
  return ((bytes - 1) / page_size) + 1;                               
40005974:	90 02 20 01 	inc  %o0                                       
      rtems_fdisk_info (fd, "recover-block-mappings:%02d-%03d", device, segment);
#endif                                                                
                                                                      
      sc->pages_desc = rtems_fdisk_page_desc_pages (sd, fd->block_size);
      sc->pages =                                                     
        rtems_fdisk_pages_in_segment (sd, fd->block_size) - sc->pages_desc;
40005978:	82 27 40 08 	sub  %i5, %o0, %g1                             
                                                                      
#if RTEMS_FDISK_TRACE                                                 
      rtems_fdisk_info (fd, "recover-block-mappings:%02d-%03d", device, segment);
#endif                                                                
                                                                      
      sc->pages_desc = rtems_fdisk_page_desc_pages (sd, fd->block_size);
4000597c:	d0 26 e0 18 	st  %o0, [ %i3 + 0x18 ]                        
      sc->pages =                                                     
        rtems_fdisk_pages_in_segment (sd, fd->block_size) - sc->pages_desc;
      if (sc->pages > fd->starvation_threshold)                       
40005980:	80 a0 40 02 	cmp  %g1, %g2                                  
40005984:	08 80 00 03 	bleu  40005990 <rtems_fdisk_recover_block_mappings+0x110>
40005988:	c2 26 e0 14 	st  %g1, [ %i3 + 0x14 ]                        
        fd->starvation_threshold = sc->pages;                         
4000598c:	c2 25 e0 24 	st  %g1, [ %l7 + 0x24 ]                        
      sc->pages_used   = 0;                                           
      sc->pages_bad    = 0;                                           
                                                                      
      sc->failed = false;                                             
                                                                      
      if (!sc->page_descriptors)                                      
40005990:	fa 06 e0 10 	ld  [ %i3 + 0x10 ], %i5                        
      sc->pages =                                                     
        rtems_fdisk_pages_in_segment (sd, fd->block_size) - sc->pages_desc;
      if (sc->pages > fd->starvation_threshold)                       
        fd->starvation_threshold = sc->pages;                         
                                                                      
      sc->pages_active = 0;                                           
40005994:	c0 26 e0 1c 	clr  [ %i3 + 0x1c ]                            
      sc->pages_used   = 0;                                           
40005998:	c0 26 e0 20 	clr  [ %i3 + 0x20 ]                            
      sc->pages_bad    = 0;                                           
4000599c:	c0 26 e0 24 	clr  [ %i3 + 0x24 ]                            
                                                                      
      sc->failed = false;                                             
400059a0:	c0 26 e0 28 	clr  [ %i3 + 0x28 ]                            
                                                                      
      if (!sc->page_descriptors)                                      
400059a4:	80 a7 60 00 	cmp  %i5, 0                                    
400059a8:	02 80 00 94 	be  40005bf8 <rtems_fdisk_recover_block_mappings+0x378><== ALWAYS TAKEN
400059ac:	92 10 00 1c 	mov  %i4, %o1                                  
400059b0:	7f ff f3 02 	call  400025b8 <.umul>                         <== NOT EXECUTED
400059b4:	01 00 00 00 	nop                                            <== NOT EXECUTED
400059b8:	98 10 00 08 	mov  %o0, %o4                                  <== NOT EXECUTED
       * descriptors.                                                 
       *                                                              
       * @todo It may be better to ask the driver to get these value  
       *       so NAND flash could be better supported.               
       */                                                             
      ret = rtems_fdisk_seg_read (fd, sc, 0, (void*) pd,              
400059bc:	90 10 00 17 	mov  %l7, %o0                                  
400059c0:	92 10 00 1b 	mov  %i3, %o1                                  
400059c4:	94 10 20 00 	clr  %o2                                       
400059c8:	7f ff fb cc 	call  400048f8 <rtems_fdisk_seg_read>          
400059cc:	96 10 00 1d 	mov  %i5, %o3                                  
                                  sc->pages_desc * fd->block_size);   
                                                                      
      if (ret)                                                        
400059d0:	b0 92 20 00 	orcc  %o0, 0, %i0                              
400059d4:	12 80 00 95 	bne  40005c28 <rtems_fdisk_recover_block_mappings+0x3a8><== NEVER TAKEN
400059d8:	01 00 00 00 	nop                                            
       * are active and how many are used.                            
       *                                                              
       * If the page is active see if the block is with-in range and  
       * if the block is a duplicate.                                 
       */                                                             
      for (page = 0; page < sc->pages; page++, pd++)                  
400059dc:	c4 06 e0 14 	ld  [ %i3 + 0x14 ], %g2                        
400059e0:	80 a0 a0 00 	cmp  %g2, 0                                    
400059e4:	12 80 00 0a 	bne  40005a0c <rtems_fdisk_recover_block_mappings+0x18c><== ALWAYS TAKEN
400059e8:	b8 10 20 00 	clr  %i4                                       
      }                                                               
                                                                      
      /*                                                              
       * Place the segment on to the correct queue.                   
       */                                                             
      rtems_fdisk_queue_segment (fd, sc);                             
400059ec:	10 80 00 2f 	b  40005aa8 <rtems_fdisk_recover_block_mappings+0x228><== NOT EXECUTED
400059f0:	90 10 00 17 	mov  %l7, %o0                                  <== NOT EXECUTED
        }                                                             
        else                                                          
        {                                                             
          if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_USED))
          {                                                           
            sc->pages_used++;                                         
400059f4:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
400059f8:	c2 26 e0 20 	st  %g1, [ %i3 + 0x20 ]                        <== NOT EXECUTED
       * are active and how many are used.                            
       *                                                              
       * If the page is active see if the block is with-in range and  
       * if the block is a duplicate.                                 
       */                                                             
      for (page = 0; page < sc->pages; page++, pd++)                  
400059fc:	b8 07 20 01 	inc  %i4                                       
40005a00:	80 a0 80 1c 	cmp  %g2, %i4                                  
40005a04:	08 80 00 28 	bleu  40005aa4 <rtems_fdisk_recover_block_mappings+0x224>
40005a08:	ba 07 60 08 	add  %i5, 8, %i5                               
static bool                                                           
rtems_fdisk_page_desc_erased (const rtems_fdisk_page_desc* pd)        
{                                                                     
  return ((pd->crc == 0xffff) &&                                      
          (pd->flags == 0xffff) &&                                    
          (pd->block == 0xffffffff)) ? true : false;                  
40005a0c:	c2 07 40 00 	ld  [ %i5 ], %g1                               
40005a10:	80 a0 7f ff 	cmp  %g1, -1                                   
40005a14:	22 80 00 35 	be,a   40005ae8 <rtems_fdisk_recover_block_mappings+0x268><== ALWAYS TAKEN
40005a18:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
 * only set a flag by changing it from 1 to 0.                        
 */                                                                   
static bool                                                           
rtems_fdisk_page_desc_flags_set (rtems_fdisk_page_desc* pd, uint16_t flags)
{                                                                     
  return (pd->flags & flags) == 0 ? true : false;                     
40005a1c:	c2 17 60 02 	lduh  [ %i5 + 2 ], %g1                         <== NOT EXECUTED
            sc->pages_used++;                                         
          }                                                           
        }                                                             
        else                                                          
        {                                                             
          if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_USED))
40005a20:	80 88 60 02 	btst  2, %g1                                   <== NOT EXECUTED
40005a24:	22 bf ff f4 	be,a   400059f4 <rtems_fdisk_recover_block_mappings+0x174><== NOT EXECUTED
40005a28:	c2 06 e0 20 	ld  [ %i3 + 0x20 ], %g1                        <== NOT EXECUTED
          {                                                           
            sc->pages_used++;                                         
          }                                                           
          else if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_ACTIVE))
40005a2c:	80 88 60 01 	btst  1, %g1                                   <== NOT EXECUTED
40005a30:	32 80 00 43 	bne,a   40005b3c <rtems_fdisk_recover_block_mappings+0x2bc><== NOT EXECUTED
40005a34:	c2 06 e0 24 	ld  [ %i3 + 0x24 ], %g1                        <== NOT EXECUTED
          {                                                           
            if (pd->block >= fd->block_count)                         
40005a38:	da 07 60 04 	ld  [ %i5 + 4 ], %o5                           <== NOT EXECUTED
40005a3c:	c2 05 e0 1c 	ld  [ %l7 + 0x1c ], %g1                        <== NOT EXECUTED
40005a40:	80 a3 40 01 	cmp  %o5, %g1                                  <== NOT EXECUTED
40005a44:	1a 80 00 57 	bcc  40005ba0 <rtems_fdisk_recover_block_mappings+0x320><== NOT EXECUTED
40005a48:	90 10 00 17 	mov  %l7, %o0                                  <== NOT EXECUTED
                                   "invalid block number: %d-%d-%d: block: %d",
                                   device, segment, page, pd->block); 
#endif                                                                
              sc->pages_bad++;                                        
            }                                                         
            else if (fd->blocks[pd->block].segment)                   
40005a4c:	c6 05 e0 18 	ld  [ %l7 + 0x18 ], %g3                        <== NOT EXECUTED
40005a50:	9b 2b 60 03 	sll  %o5, 3, %o5                               <== NOT EXECUTED
40005a54:	c2 00 c0 0d 	ld  [ %g3 + %o5 ], %g1                         <== NOT EXECUTED
40005a58:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40005a5c:	02 80 00 5b 	be  40005bc8 <rtems_fdisk_recover_block_mappings+0x348><== NOT EXECUTED
40005a60:	88 00 c0 0d 	add  %g3, %o5, %g4                             <== NOT EXECUTED
               * each block so we can tell which is the later block when
               * duplicates appear. A power down with a failed wirte could cause
               * a duplicate.                                         
               */                                                     
              const rtems_fdisk_segment_ctl* bsc = fd->blocks[pd->block].segment;
              rtems_fdisk_error ("duplicate block: %d-%d-%d: " \      
40005a64:	d2 00 60 08 	ld  [ %g1 + 8 ], %o1                           <== NOT EXECUTED
40005a68:	d4 00 60 0c 	ld  [ %g1 + 0xc ], %o2                         <== NOT EXECUTED
40005a6c:	d6 01 20 04 	ld  [ %g4 + 4 ], %o3                           <== NOT EXECUTED
40005a70:	90 10 00 13 	mov  %l3, %o0                                  <== NOT EXECUTED
40005a74:	f8 23 a0 5c 	st  %i4, [ %sp + 0x5c ]                        <== NOT EXECUTED
40005a78:	98 10 00 19 	mov  %i1, %o4                                  <== NOT EXECUTED
40005a7c:	7f ff fc 57 	call  40004bd8 <rtems_fdisk_error>             <== NOT EXECUTED
40005a80:	9a 10 00 1a 	mov  %i2, %o5                                  <== NOT EXECUTED
                                 "duplicate: %d-%d-%d",               
                                 bsc->device, bsc->segment,           
                                 fd->blocks[pd->block].page,          
                                 device, segment, page);              
              sc->pages_bad++;                                        
40005a84:	c2 06 e0 24 	ld  [ %i3 + 0x24 ], %g1                        <== NOT EXECUTED
40005a88:	c4 06 e0 14 	ld  [ %i3 + 0x14 ], %g2                        <== NOT EXECUTED
40005a8c:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
40005a90:	c2 26 e0 24 	st  %g1, [ %i3 + 0x24 ]                        <== NOT EXECUTED
       * are active and how many are used.                            
       *                                                              
       * If the page is active see if the block is with-in range and  
       * if the block is a duplicate.                                 
       */                                                             
      for (page = 0; page < sc->pages; page++, pd++)                  
40005a94:	b8 07 20 01 	inc  %i4                                       <== NOT EXECUTED
40005a98:	80 a0 80 1c 	cmp  %g2, %i4                                  <== NOT EXECUTED
40005a9c:	18 bf ff dc 	bgu  40005a0c <rtems_fdisk_recover_block_mappings+0x18c><== NOT EXECUTED
40005aa0:	ba 07 60 08 	add  %i5, 8, %i5                               <== NOT EXECUTED
      }                                                               
                                                                      
      /*                                                              
       * Place the segment on to the correct queue.                   
       */                                                             
      rtems_fdisk_queue_segment (fd, sc);                             
40005aa4:	90 10 00 17 	mov  %l7, %o0                                  
40005aa8:	7f ff fc f4 	call  40004e78 <rtems_fdisk_queue_segment>     
40005aac:	92 10 00 1b 	mov  %i3, %o1                                  
  fd->erased_blocks = 0;                                              
  fd->starvation_threshold = 0;                                       
  for (device = 0; device < fd->device_count; device++)               
  {                                                                   
    uint32_t segment;                                                 
    for (segment = 0; segment < fd->devices[device].segment_count; segment++)
40005ab0:	c4 05 e0 2c 	ld  [ %l7 + 0x2c ], %g2                        
40005ab4:	b4 06 a0 01 	inc  %i2                                       
40005ab8:	82 00 80 11 	add  %g2, %l1, %g1                             
40005abc:	c6 00 60 04 	ld  [ %g1 + 4 ], %g3                           
40005ac0:	80 a0 c0 1a 	cmp  %g3, %i2                                  
40005ac4:	18 bf ff 9a 	bgu  4000592c <rtems_fdisk_recover_block_mappings+0xac>
40005ac8:	a0 04 20 30 	add  %l0, 0x30, %l0                            
40005acc:	c6 05 e0 30 	ld  [ %l7 + 0x30 ], %g3                        
  /*                                                                  
   * Scan each segment or each device recovering the valid pages.     
   */                                                                 
  fd->erased_blocks = 0;                                              
  fd->starvation_threshold = 0;                                       
  for (device = 0; device < fd->device_count; device++)               
40005ad0:	b2 06 60 01 	inc  %i1                                       
40005ad4:	80 a0 c0 19 	cmp  %g3, %i1                                  
40005ad8:	18 bf ff 8f 	bgu  40005914 <rtems_fdisk_recover_block_mappings+0x94><== NEVER TAKEN
40005adc:	a2 04 60 0c 	add  %l1, 0xc, %l1                             
       */                                                             
      rtems_fdisk_queue_segment (fd, sc);                             
    }                                                                 
  }                                                                   
                                                                      
  return 0;                                                           
40005ae0:	81 c7 e0 08 	ret                                            
40005ae4:	91 e8 20 00 	restore  %g0, 0, %o0                           
static bool                                                           
rtems_fdisk_page_desc_erased (const rtems_fdisk_page_desc* pd)        
{                                                                     
  return ((pd->crc == 0xffff) &&                                      
          (pd->flags == 0xffff) &&                                    
          (pd->block == 0xffffffff)) ? true : false;                  
40005ae8:	80 a0 7f ff 	cmp  %g1, -1                                   
40005aec:	32 bf ff cd 	bne,a   40005a20 <rtems_fdisk_recover_block_mappings+0x1a0><== NEVER TAKEN
40005af0:	c2 17 60 02 	lduh  [ %i5 + 2 ], %g1                         <== NOT EXECUTED
rtems_fdisk_seg_blank_check_page (const rtems_flashdisk*   fd,        
                                  rtems_fdisk_segment_ctl* sc,        
                                  uint32_t                 page)      
{                                                                     
  return rtems_fdisk_seg_blank_check (fd, sc,                         
                                      page * fd->block_size, fd->block_size);
40005af4:	f0 05 e0 14 	ld  [ %l7 + 0x14 ], %i0                        
        if (rtems_fdisk_page_desc_erased (pd))                        
        {                                                             
          /*                                                          
           * Is the page erased ?                                     
           */                                                         
          ret = rtems_fdisk_seg_blank_check_page (fd, sc,             
40005af8:	d0 06 e0 18 	ld  [ %i3 + 0x18 ], %o0                        
static int                                                            
rtems_fdisk_seg_blank_check_page (const rtems_flashdisk*   fd,        
                                  rtems_fdisk_segment_ctl* sc,        
                                  uint32_t                 page)      
{                                                                     
  return rtems_fdisk_seg_blank_check (fd, sc,                         
40005afc:	92 10 00 18 	mov  %i0, %o1                                  
40005b00:	7f ff f2 ae 	call  400025b8 <.umul>                         
40005b04:	90 07 00 08 	add  %i4, %o0, %o0                             
40005b08:	92 10 00 1b 	mov  %i3, %o1                                  
40005b0c:	94 10 00 08 	mov  %o0, %o2                                  
40005b10:	96 10 00 18 	mov  %i0, %o3                                  
40005b14:	7f ff fb 9b 	call  40004980 <rtems_fdisk_seg_blank_check>   
40005b18:	90 10 00 17 	mov  %l7, %o0                                  
           * Is the page erased ?                                     
           */                                                         
          ret = rtems_fdisk_seg_blank_check_page (fd, sc,             
                                                  page + sc->pages_desc);
                                                                      
          if (ret == 0)                                               
40005b1c:	80 a2 20 00 	cmp  %o0, 0                                    
40005b20:	32 80 00 0a 	bne,a   40005b48 <rtems_fdisk_recover_block_mappings+0x2c8><== NEVER TAKEN
40005b24:	da 07 60 04 	ld  [ %i5 + 4 ], %o5                           <== NOT EXECUTED
          {                                                           
            ++fd->erased_blocks;                                      
40005b28:	c2 05 e0 28 	ld  [ %l7 + 0x28 ], %g1                        
40005b2c:	c4 06 e0 14 	ld  [ %i3 + 0x14 ], %g2                        
40005b30:	82 00 60 01 	inc  %g1                                       
40005b34:	10 bf ff b2 	b  400059fc <rtems_fdisk_recover_block_mappings+0x17c>
40005b38:	c2 25 e0 28 	st  %g1, [ %l7 + 0x28 ]                        
               */                                                     
              sc->pages_active++;                                     
            }                                                         
          }                                                           
          else                                                        
            sc->pages_bad++;                                          
40005b3c:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
40005b40:	10 bf ff af 	b  400059fc <rtems_fdisk_recover_block_mappings+0x17c><== NOT EXECUTED
40005b44:	c2 26 e0 24 	st  %g1, [ %i3 + 0x24 ]                        <== NOT EXECUTED
            ++fd->erased_blocks;                                      
          }                                                           
          else                                                        
          {                                                           
#if RTEMS_FDISK_TRACE                                                 
            rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",      
40005b48:	92 10 00 14 	mov  %l4, %o1                                  <== NOT EXECUTED
40005b4c:	94 10 00 19 	mov  %i1, %o2                                  <== NOT EXECUTED
40005b50:	96 10 00 1a 	mov  %i2, %o3                                  <== NOT EXECUTED
40005b54:	98 10 00 1c 	mov  %i4, %o4                                  <== NOT EXECUTED
40005b58:	7f ff fb fe 	call  40004b50 <rtems_fdisk_warning>           <== NOT EXECUTED
40005b5c:	90 10 00 17 	mov  %l7, %o0                                  <== NOT EXECUTED
 * Set the flags. Setting means clear the bit to 0.                   
 */                                                                   
static void                                                           
rtems_fdisk_page_desc_set_flags (rtems_fdisk_page_desc* pd, uint16_t flags)
{                                                                     
  pd->flags &= ~flags;                                                
40005b60:	c2 17 60 02 	lduh  [ %i5 + 2 ], %g1                         <== NOT EXECUTED
            rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",      
                                 device, segment, page, pd->block);   
#endif                                                                
            rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_USED);
                                                                      
            ret = rtems_fdisk_seg_write_page_desc (fd, sc,            
40005b64:	90 10 00 17 	mov  %l7, %o0                                  <== NOT EXECUTED
 * Set the flags. Setting means clear the bit to 0.                   
 */                                                                   
static void                                                           
rtems_fdisk_page_desc_set_flags (rtems_fdisk_page_desc* pd, uint16_t flags)
{                                                                     
  pd->flags &= ~flags;                                                
40005b68:	82 08 7f fd 	and  %g1, -3, %g1                              <== NOT EXECUTED
            rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",      
                                 device, segment, page, pd->block);   
#endif                                                                
            rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_USED);
                                                                      
            ret = rtems_fdisk_seg_write_page_desc (fd, sc,            
40005b6c:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
 * Set the flags. Setting means clear the bit to 0.                   
 */                                                                   
static void                                                           
rtems_fdisk_page_desc_set_flags (rtems_fdisk_page_desc* pd, uint16_t flags)
{                                                                     
  pd->flags &= ~flags;                                                
40005b70:	c2 37 60 02 	sth  %g1, [ %i5 + 2 ]                          <== NOT EXECUTED
            rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",      
                                 device, segment, page, pd->block);   
#endif                                                                
            rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_USED);
                                                                      
            ret = rtems_fdisk_seg_write_page_desc (fd, sc,            
40005b74:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
40005b78:	7f ff fb c9 	call  40004a9c <rtems_fdisk_seg_write_page_desc><== NOT EXECUTED
40005b7c:	96 10 00 1d 	mov  %i5, %o3                                  <== NOT EXECUTED
                                                   page, pd);         
                                                                      
            if (ret)                                                  
40005b80:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40005b84:	12 80 00 17 	bne  40005be0 <rtems_fdisk_recover_block_mappings+0x360><== NOT EXECUTED
40005b88:	90 10 00 16 	mov  %l6, %o0                                  <== NOT EXECUTED
            {                                                         
              rtems_fdisk_error ("forcing page to used failed: %d-%d-%d",
                                 device, segment, page);              
            }                                                         
                                                                      
            sc->pages_used++;                                         
40005b8c:	c2 06 e0 20 	ld  [ %i3 + 0x20 ], %g1                        <== NOT EXECUTED
40005b90:	c4 06 e0 14 	ld  [ %i3 + 0x14 ], %g2                        <== NOT EXECUTED
40005b94:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
40005b98:	10 bf ff 99 	b  400059fc <rtems_fdisk_recover_block_mappings+0x17c><== NOT EXECUTED
40005b9c:	c2 26 e0 20 	st  %g1, [ %i3 + 0x20 ]                        <== NOT EXECUTED
          else if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_ACTIVE))
          {                                                           
            if (pd->block >= fd->block_count)                         
            {                                                         
#if RTEMS_FDISK_TRACE                                                 
              rtems_fdisk_warning (fd,                                
40005ba0:	92 10 00 15 	mov  %l5, %o1                                  <== NOT EXECUTED
40005ba4:	94 10 00 19 	mov  %i1, %o2                                  <== NOT EXECUTED
40005ba8:	96 10 00 1a 	mov  %i2, %o3                                  <== NOT EXECUTED
40005bac:	7f ff fb e9 	call  40004b50 <rtems_fdisk_warning>           <== NOT EXECUTED
40005bb0:	98 10 00 1c 	mov  %i4, %o4                                  <== NOT EXECUTED
                                   "invalid block number: %d-%d-%d: block: %d",
                                   device, segment, page, pd->block); 
#endif                                                                
              sc->pages_bad++;                                        
40005bb4:	c2 06 e0 24 	ld  [ %i3 + 0x24 ], %g1                        <== NOT EXECUTED
40005bb8:	c4 06 e0 14 	ld  [ %i3 + 0x14 ], %g2                        <== NOT EXECUTED
40005bbc:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
40005bc0:	10 bf ff 8f 	b  400059fc <rtems_fdisk_recover_block_mappings+0x17c><== NOT EXECUTED
40005bc4:	c2 26 e0 24 	st  %g1, [ %i3 + 0x24 ]                        <== NOT EXECUTED
              fd->blocks[pd->block].page    = page;                   
                                                                      
              /*                                                      
               * The page is active.                                  
               */                                                     
              sc->pages_active++;                                     
40005bc8:	c2 06 e0 1c 	ld  [ %i3 + 0x1c ], %g1                        <== NOT EXECUTED
            {                                                         
              /**                                                     
               * @todo                                                
               * Add start up crc checks here.                        
               */                                                     
              fd->blocks[pd->block].segment = sc;                     
40005bcc:	f6 20 c0 0d 	st  %i3, [ %g3 + %o5 ]                         <== NOT EXECUTED
              fd->blocks[pd->block].page    = page;                   
40005bd0:	f8 21 20 04 	st  %i4, [ %g4 + 4 ]                           <== NOT EXECUTED
                                                                      
              /*                                                      
               * The page is active.                                  
               */                                                     
              sc->pages_active++;                                     
40005bd4:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
40005bd8:	10 bf ff 89 	b  400059fc <rtems_fdisk_recover_block_mappings+0x17c><== NOT EXECUTED
40005bdc:	c2 26 e0 1c 	st  %g1, [ %i3 + 0x1c ]                        <== NOT EXECUTED
            ret = rtems_fdisk_seg_write_page_desc (fd, sc,            
                                                   page, pd);         
                                                                      
            if (ret)                                                  
            {                                                         
              rtems_fdisk_error ("forcing page to used failed: %d-%d-%d",
40005be0:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
40005be4:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
40005be8:	7f ff fb fc 	call  40004bd8 <rtems_fdisk_error>             <== NOT EXECUTED
40005bec:	96 10 00 1c 	mov  %i4, %o3                                  <== NOT EXECUTED
                                 device, segment, page);              
            }                                                         
                                                                      
            sc->pages_used++;                                         
40005bf0:	10 bf ff e8 	b  40005b90 <rtems_fdisk_recover_block_mappings+0x310><== NOT EXECUTED
40005bf4:	c2 06 e0 20 	ld  [ %i3 + 0x20 ], %g1                        <== NOT EXECUTED
      sc->pages_bad    = 0;                                           
                                                                      
      sc->failed = false;                                             
                                                                      
      if (!sc->page_descriptors)                                      
        sc->page_descriptors = malloc (sc->pages_desc * fd->block_size);
40005bf8:	7f ff f2 70 	call  400025b8 <.umul>                         
40005bfc:	01 00 00 00 	nop                                            
40005c00:	40 00 0a 6f 	call  400085bc <malloc>                        
40005c04:	d0 27 bf fc 	st  %o0, [ %fp + -4 ]                          
40005c08:	d0 26 e0 10 	st  %o0, [ %i3 + 0x10 ]                        
40005c0c:	ba 10 00 08 	mov  %o0, %i5                                  
                                                                      
      if (!sc->page_descriptors)                                      
40005c10:	80 a2 20 00 	cmp  %o0, 0                                    
40005c14:	12 bf ff 6a 	bne  400059bc <rtems_fdisk_recover_block_mappings+0x13c><== ALWAYS TAKEN
40005c18:	d8 07 bf fc 	ld  [ %fp + -4 ], %o4                          
        rtems_fdisk_abort ("no memory for page descriptors");         
40005c1c:	11 10 00 d1 	sethi  %hi(0x40034400), %o0                    <== NOT EXECUTED
40005c20:	40 00 06 60 	call  400075a0 <rtems_fdisk_abort.constprop.1> <== NOT EXECUTED
40005c24:	90 12 22 e0 	or  %o0, 0x2e0, %o0	! 400346e0 <__FUNCTION__.6193+0x618><== NOT EXECUTED
      ret = rtems_fdisk_seg_read (fd, sc, 0, (void*) pd,              
                                  sc->pages_desc * fd->block_size);   
                                                                      
      if (ret)                                                        
      {                                                               
        rtems_fdisk_error ("recover-block-mappings:%02d-%03d: " \     
40005c28:	40 00 7d 1f 	call  400250a4 <strerror>                      <== NOT EXECUTED
40005c2c:	01 00 00 00 	nop                                            <== NOT EXECUTED
40005c30:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
40005c34:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
40005c38:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
40005c3c:	11 10 00 d1 	sethi  %hi(0x40034400), %o0                    <== NOT EXECUTED
40005c40:	98 10 00 18 	mov  %i0, %o4                                  <== NOT EXECUTED
40005c44:	7f ff fb e5 	call  40004bd8 <rtems_fdisk_error>             <== NOT EXECUTED
40005c48:	90 12 23 28 	or  %o0, 0x328, %o0                            <== NOT EXECUTED
                           "read page desc failed: %s (%d)",          
                           device, segment, strerror (ret), ret);     
        return ret;                                                   
40005c4c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40005c50:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40005168 <rtems_fdisk_recycle_segment>: static int rtems_fdisk_recycle_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* ssc, rtems_fdisk_segment_ctl* dsc, uint32_t *pages) {
40005168:	9d e3 bf 78 	save  %sp, -136, %sp                           
  int      ret;                                                       
  uint32_t spage;                                                     
  uint32_t used = 0;                                                  
  uint32_t active = 0;                                                
                                                                      
  for (spage = 0; spage < ssc->pages; spage++)                        
4000516c:	c6 06 60 14 	ld  [ %i1 + 0x14 ], %g3                        
40005170:	c0 27 bf f8 	clr  [ %fp + -8 ]                              
40005174:	80 a0 e0 00 	cmp  %g3, 0                                    
40005178:	02 80 00 7f 	be  40005374 <rtems_fdisk_recycle_segment+0x20c><== NEVER TAKEN
4000517c:	a4 10 20 00 	clr  %l2                                       
      /*                                                              
       * Get new destination segment if necessary.                    
       */                                                             
      dst_pages = rtems_fdisk_seg_pages_available (dsc);              
      if (dst_pages == 0)                                             
        dsc = rtems_fdisk_seg_most_available (&fd->available);        
40005180:	82 06 20 34 	add  %i0, 0x34, %g1                            
  int      ret;                                                       
  uint32_t spage;                                                     
  uint32_t used = 0;                                                  
  uint32_t active = 0;                                                
                                                                      
  for (spage = 0; spage < ssc->pages; spage++)                        
40005184:	b8 10 20 00 	clr  %i4                                       
      /*                                                              
       * Get new destination segment if necessary.                    
       */                                                             
      dst_pages = rtems_fdisk_seg_pages_available (dsc);              
      if (dst_pages == 0)                                             
        dsc = rtems_fdisk_seg_most_available (&fd->available);        
40005188:	c2 27 bf f4 	st  %g1, [ %fp + -12 ]                         
  uint32_t used = 0;                                                  
  uint32_t active = 0;                                                
                                                                      
  for (spage = 0; spage < ssc->pages; spage++)                        
  {                                                                   
    rtems_fdisk_page_desc* spd = &ssc->page_descriptors[spage];       
4000518c:	e2 06 60 10 	ld  [ %i1 + 0x10 ], %l1                        
      rtems_fdisk_segment_queue_push_tail (&fd->available, sc);       
  }                                                                   
}                                                                     
                                                                      
static int                                                            
rtems_fdisk_recycle_segment (rtems_flashdisk*         fd,             
40005190:	a1 2f 20 03 	sll  %i4, 3, %l0                               
                                                                      
  for (spage = 0; spage < ssc->pages; spage++)                        
  {                                                                   
    rtems_fdisk_page_desc* spd = &ssc->page_descriptors[spage];       
                                                                      
    if (!dsc && ssc->pages_active > 0)                                
40005194:	80 a6 a0 00 	cmp  %i2, 0                                    
40005198:	02 80 00 8d 	be  400053cc <rtems_fdisk_recycle_segment+0x264>
4000519c:	ac 04 40 10 	add  %l1, %l0, %l6                             
 * only set a flag by changing it from 1 to 0.                        
 */                                                                   
static bool                                                           
rtems_fdisk_page_desc_flags_set (rtems_fdisk_page_desc* pd, uint16_t flags)
{                                                                     
  return (pd->flags & flags) == 0 ? true : false;                     
400051a0:	c4 15 a0 02 	lduh  [ %l6 + 2 ], %g2                         
    {                                                                 
      rtems_fdisk_error ("recycle: no available dst segment");        
      return EIO;                                                     
    }                                                                 
                                                                      
    if (rtems_fdisk_page_desc_flags_set (spd, RTEMS_FDISK_PAGE_ACTIVE) &&
400051a4:	80 88 a0 01 	btst  1, %g2                                   
400051a8:	32 80 00 6b 	bne,a   40005354 <rtems_fdisk_recycle_segment+0x1ec><== NEVER TAKEN
400051ac:	c4 04 40 10 	ld  [ %l1 + %l0 ], %g2                         <== NOT EXECUTED
400051b0:	80 88 a0 02 	btst  2, %g2                                   
400051b4:	22 80 00 68 	be,a   40005354 <rtems_fdisk_recycle_segment+0x1ec>
400051b8:	c4 04 40 10 	ld  [ %l1 + %l0 ], %g2                         
rtems_fdisk_seg_next_available_page (rtems_fdisk_segment_ctl* sc)     
{                                                                     
  rtems_fdisk_page_desc* pd = &sc->page_descriptors[0];               
  uint32_t               page;                                        
                                                                      
  for (page = 0; page < sc->pages; page++, pd++)                      
400051bc:	de 06 a0 14 	ld  [ %i2 + 0x14 ], %o7                        
400051c0:	80 a3 e0 00 	cmp  %o7, 0                                    
400051c4:	02 80 00 8d 	be  400053f8 <rtems_fdisk_recycle_segment+0x290><== NEVER TAKEN
400051c8:	ee 06 a0 10 	ld  [ %i2 + 0x10 ], %l7                        
400051cc:	84 10 00 17 	mov  %l7, %g2                                  
400051d0:	10 80 00 05 	b  400051e4 <rtems_fdisk_recycle_segment+0x7c> 
400051d4:	ba 10 20 00 	clr  %i5                                       
400051d8:	80 a7 40 0f 	cmp  %i5, %o7                                  
400051dc:	02 80 00 87 	be  400053f8 <rtems_fdisk_recycle_segment+0x290><== NEVER TAKEN
400051e0:	84 00 a0 08 	add  %g2, 8, %g2                               
static bool                                                           
rtems_fdisk_page_desc_erased (const rtems_fdisk_page_desc* pd)        
{                                                                     
  return ((pd->crc == 0xffff) &&                                      
          (pd->flags == 0xffff) &&                                    
          (pd->block == 0xffffffff)) ? true : false;                  
400051e4:	c8 00 80 00 	ld  [ %g2 ], %g4                               
400051e8:	80 a1 3f ff 	cmp  %g4, -1                                   
400051ec:	32 bf ff fb 	bne,a   400051d8 <rtems_fdisk_recycle_segment+0x70>
400051f0:	ba 07 60 01 	inc  %i5                                       
400051f4:	c8 00 a0 04 	ld  [ %g2 + 4 ], %g4                           
400051f8:	80 a1 3f ff 	cmp  %g4, -1                                   
400051fc:	32 bf ff f7 	bne,a   400051d8 <rtems_fdisk_recycle_segment+0x70><== NEVER TAKEN
40005200:	ba 07 60 01 	inc  %i5                                       <== NOT EXECUTED
      uint32_t               dst_pages;                               
      rtems_fdisk_page_desc* dpd;                                     
      uint32_t               dpage;                                   
                                                                      
      dpage = rtems_fdisk_seg_next_available_page (dsc);              
      dpd   = &dsc->page_descriptors[dpage];                          
40005204:	83 2f 60 03 	sll  %i5, 3, %g1                               
40005208:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
                                                                      
      active++;                                                       
4000520c:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
                                                                      
      if (dpage >= dsc->pages)                                        
40005210:	80 a7 40 0f 	cmp  %i5, %o7                                  
      uint32_t               dpage;                                   
                                                                      
      dpage = rtems_fdisk_seg_next_available_page (dsc);              
      dpd   = &dsc->page_descriptors[dpage];                          
                                                                      
      active++;                                                       
40005214:	82 00 60 01 	inc  %g1                                       
40005218:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]                          
      uint32_t               dst_pages;                               
      rtems_fdisk_page_desc* dpd;                                     
      uint32_t               dpage;                                   
                                                                      
      dpage = rtems_fdisk_seg_next_available_page (dsc);              
      dpd   = &dsc->page_descriptors[dpage];                          
4000521c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
                                                                      
      active++;                                                       
                                                                      
      if (dpage >= dsc->pages)                                        
40005220:	1a 80 00 76 	bcc  400053f8 <rtems_fdisk_recycle_segment+0x290><== NEVER TAKEN
40005224:	a6 05 c0 01 	add  %l7, %g1, %l3                             
        rtems_fdisk_segment_queue_push_head (&fd->used, ssc);         
        return EIO;                                                   
      }                                                               
                                                                      
#if RTEMS_FDISK_TRACE                                                 
      rtems_fdisk_info (fd, "recycle: %02d-%03d-%03d=>%02d-%03d-%03d",
40005228:	da 06 a0 08 	ld  [ %i2 + 8 ], %o5                           
4000522c:	c4 06 a0 0c 	ld  [ %i2 + 0xc ], %g2                         
40005230:	d4 06 60 08 	ld  [ %i1 + 8 ], %o2                           
40005234:	d6 06 60 0c 	ld  [ %i1 + 0xc ], %o3                         
40005238:	98 10 00 1c 	mov  %i4, %o4                                  
4000523c:	c4 23 a0 5c 	st  %g2, [ %sp + 0x5c ]                        
40005240:	13 10 00 d1 	sethi  %hi(0x40034400), %o1                    
40005244:	fa 23 a0 60 	st  %i5, [ %sp + 0x60 ]                        
40005248:	92 12 60 a8 	or  %o1, 0xa8, %o1                             
4000524c:	7f ff fd 67 	call  400047e8 <rtems_fdisk_info>              
40005250:	90 10 00 18 	mov  %i0, %o0                                  
                        ssc->device, ssc->segment, spage,             
                        dsc->device, dsc->segment, dpage);            
#endif                                                                
      ret = rtems_fdisk_seg_copy_page (fd, ssc,                       
40005254:	c8 06 a0 18 	ld  [ %i2 + 0x18 ], %g4                        
                           rtems_fdisk_segment_ctl* dst_sc,           
                           uint32_t                 dst_page)         
{                                                                     
  int ret;                                                            
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_printf (fd, "  seg-copy-page: %02d-%03d~%03d=>%02d-%03d~%03d",
40005258:	da 06 a0 08 	ld  [ %i2 + 8 ], %o5                           
4000525c:	de 06 a0 0c 	ld  [ %i2 + 0xc ], %o7                         
#if RTEMS_FDISK_TRACE                                                 
      rtems_fdisk_info (fd, "recycle: %02d-%03d-%03d=>%02d-%03d-%03d",
                        ssc->device, ssc->segment, spage,             
                        dsc->device, dsc->segment, dpage);            
#endif                                                                
      ret = rtems_fdisk_seg_copy_page (fd, ssc,                       
40005260:	c4 06 60 18 	ld  [ %i1 + 0x18 ], %g2                        
                           rtems_fdisk_segment_ctl* dst_sc,           
                           uint32_t                 dst_page)         
{                                                                     
  int ret;                                                            
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_printf (fd, "  seg-copy-page: %02d-%03d~%03d=>%02d-%03d~%03d",
40005264:	d4 06 60 08 	ld  [ %i1 + 8 ], %o2                           
40005268:	d6 06 60 0c 	ld  [ %i1 + 0xc ], %o3                         
#if RTEMS_FDISK_TRACE                                                 
      rtems_fdisk_info (fd, "recycle: %02d-%03d-%03d=>%02d-%03d-%03d",
                        ssc->device, ssc->segment, spage,             
                        dsc->device, dsc->segment, dpage);            
#endif                                                                
      ret = rtems_fdisk_seg_copy_page (fd, ssc,                       
4000526c:	a8 07 00 02 	add  %i4, %g2, %l4                             
40005270:	aa 07 40 04 	add  %i5, %g4, %l5                             
                           rtems_fdisk_segment_ctl* dst_sc,           
                           uint32_t                 dst_page)         
{                                                                     
  int ret;                                                            
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_printf (fd, "  seg-copy-page: %02d-%03d~%03d=>%02d-%03d~%03d",
40005274:	de 23 a0 5c 	st  %o7, [ %sp + 0x5c ]                        
40005278:	98 10 00 14 	mov  %l4, %o4                                  
4000527c:	13 10 00 d1 	sethi  %hi(0x40034400), %o1                    
40005280:	ea 23 a0 60 	st  %l5, [ %sp + 0x60 ]                        
40005284:	92 12 60 d0 	or  %o1, 0xd0, %o1                             
40005288:	7f ff fd 7a 	call  40004870 <rtems_fdisk_printf>            
4000528c:	90 10 00 18 	mov  %i0, %o0                                  
                           rtems_fdisk_segment_ctl* sc,               
                           uint32_t                 page,             
                           void*                    buffer)           
{                                                                     
  return rtems_fdisk_seg_read (fd, sc,                                
                               page * fd->block_size, buffer, fd->block_size);
40005290:	d8 06 20 14 	ld  [ %i0 + 0x14 ], %o4                        
rtems_fdisk_seg_read_page (const rtems_flashdisk*   fd,               
                           rtems_fdisk_segment_ctl* sc,               
                           uint32_t                 page,             
                           void*                    buffer)           
{                                                                     
  return rtems_fdisk_seg_read (fd, sc,                                
40005294:	90 10 00 14 	mov  %l4, %o0                                  
40005298:	92 10 00 0c 	mov  %o4, %o1                                  
4000529c:	7f ff f4 c7 	call  400025b8 <.umul>                         
400052a0:	d8 27 bf ec 	st  %o4, [ %fp + -20 ]                         
400052a4:	d6 06 20 68 	ld  [ %i0 + 0x68 ], %o3                        
400052a8:	d8 07 bf ec 	ld  [ %fp + -20 ], %o4                         
400052ac:	94 10 00 08 	mov  %o0, %o2                                  
400052b0:	92 10 00 19 	mov  %i1, %o1                                  
400052b4:	7f ff fd 91 	call  400048f8 <rtems_fdisk_seg_read>          
400052b8:	90 10 00 18 	mov  %i0, %o0                                  
                      src_sc->device, src_sc->segment, src_page,      
                      dst_sc->device, dst_sc->segment, dst_page);     
#endif                                                                
  ret = rtems_fdisk_seg_read_page (fd, src_sc, src_page,              
                                   fd->copy_buffer);                  
  if (ret)                                                            
400052bc:	84 92 20 00 	orcc  %o0, 0, %g2                              
400052c0:	22 80 00 6a 	be,a   40005468 <rtems_fdisk_recycle_segment+0x300><== ALWAYS TAKEN
400052c4:	d6 06 20 68 	ld  [ %i0 + 0x68 ], %o3                        
                                       spage + ssc->pages_desc,       
                                       dsc,                           
                                       dpage + dsc->pages_desc);      
      if (ret)                                                        
      {                                                               
        rtems_fdisk_error ("recycle: %02d-%03d-%03d=>" \              
400052c8:	e2 06 a0 08 	ld  [ %i2 + 8 ], %l1                           <== NOT EXECUTED
400052cc:	e0 06 a0 0c 	ld  [ %i2 + 0xc ], %l0                         <== NOT EXECUTED
400052d0:	e4 06 60 0c 	ld  [ %i1 + 0xc ], %l2                         <== NOT EXECUTED
400052d4:	f6 06 60 08 	ld  [ %i1 + 8 ], %i3                           <== NOT EXECUTED
400052d8:	90 10 00 02 	mov  %g2, %o0                                  <== NOT EXECUTED
400052dc:	40 00 7f 72 	call  400250a4 <strerror>                      <== NOT EXECUTED
400052e0:	c4 27 bf f0 	st  %g2, [ %fp + -16 ]                         <== NOT EXECUTED
400052e4:	c4 07 bf f0 	ld  [ %fp + -16 ], %g2                         <== NOT EXECUTED
400052e8:	d0 23 a0 60 	st  %o0, [ %sp + 0x60 ]                        <== NOT EXECUTED
400052ec:	94 10 00 12 	mov  %l2, %o2                                  <== NOT EXECUTED
400052f0:	11 10 00 d1 	sethi  %hi(0x40034400), %o0                    <== NOT EXECUTED
400052f4:	96 10 00 1c 	mov  %i4, %o3                                  <== NOT EXECUTED
400052f8:	98 10 00 11 	mov  %l1, %o4                                  <== NOT EXECUTED
400052fc:	9a 10 00 10 	mov  %l0, %o5                                  <== NOT EXECUTED
40005300:	fa 23 a0 5c 	st  %i5, [ %sp + 0x5c ]                        <== NOT EXECUTED
40005304:	c4 23 a0 64 	st  %g2, [ %sp + 0x64 ]                        <== NOT EXECUTED
40005308:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
4000530c:	90 12 21 00 	or  %o0, 0x100, %o0                            <== NOT EXECUTED
                                             dsc,                     
                                             dpage, dpd);             
                                                                      
      if (ret)                                                        
      {                                                               
        rtems_fdisk_error ("recycle: %02d-%03d-%03d=>"   \            
40005310:	7f ff fe 32 	call  40004bd8 <rtems_fdisk_error>             <== NOT EXECUTED
40005314:	01 00 00 00 	nop                                            <== NOT EXECUTED
                           "%02d-%03d-%03d: copy pd failed: %s (%d)", 
                           ssc->device, ssc->segment, spage,          
                           dsc->device, dsc->segment, dpage,          
                           strerror (ret), ret);                      
        rtems_fdisk_queue_segment (fd, dsc);                          
40005318:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4000531c:	7f ff fe d7 	call  40004e78 <rtems_fdisk_queue_segment>     <== NOT EXECUTED
40005320:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
rtems_fdisk_segment_queue_push_head (rtems_fdisk_segment_ctl_queue* queue,
                                     rtems_fdisk_segment_ctl*       sc)
{                                                                     
  if (sc)                                                             
  {                                                                   
    sc->next = queue->head;                                           
40005324:	c6 06 20 40 	ld  [ %i0 + 0x40 ], %g3                        <== NOT EXECUTED
    queue->head = sc;                                                 
                                                                      
    if (queue->tail == 0)                                             
40005328:	c2 06 20 44 	ld  [ %i0 + 0x44 ], %g1                        <== NOT EXECUTED
rtems_fdisk_segment_queue_push_head (rtems_fdisk_segment_ctl_queue* queue,
                                     rtems_fdisk_segment_ctl*       sc)
{                                                                     
  if (sc)                                                             
  {                                                                   
    sc->next = queue->head;                                           
4000532c:	c6 26 40 00 	st  %g3, [ %i1 ]                               <== NOT EXECUTED
    queue->head = sc;                                                 
40005330:	f2 26 20 40 	st  %i1, [ %i0 + 0x40 ]                        <== NOT EXECUTED
                                                                      
    if (queue->tail == 0)                                             
40005334:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40005338:	02 80 00 98 	be  40005598 <rtems_fdisk_recycle_segment+0x430><== NOT EXECUTED
4000533c:	c4 07 bf f0 	ld  [ %fp + -16 ], %g2                         <== NOT EXECUTED
      queue->tail = sc;                                               
    queue->count++;                                                   
40005340:	c2 06 20 48 	ld  [ %i0 + 0x48 ], %g1                        <== NOT EXECUTED
40005344:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
40005348:	c2 26 20 48 	st  %g1, [ %i0 + 0x48 ]                        <== NOT EXECUTED
  }                                                                   
                                                                      
  ret = rtems_fdisk_erase_segment (fd, ssc);                          
                                                                      
  return ret;                                                         
}                                                                     
4000534c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40005350:	91 e8 00 02 	restore  %g0, %g2, %o0                         <== NOT EXECUTED
static bool                                                           
rtems_fdisk_page_desc_erased (const rtems_fdisk_page_desc* pd)        
{                                                                     
  return ((pd->crc == 0xffff) &&                                      
          (pd->flags == 0xffff) &&                                    
          (pd->block == 0xffffffff)) ? true : false;                  
40005354:	80 a0 bf ff 	cmp  %g2, -1                                   
40005358:	22 80 00 16 	be,a   400053b0 <rtems_fdisk_recycle_segment+0x248><== NEVER TAKEN
4000535c:	c2 05 a0 04 	ld  [ %l6 + 4 ], %g1                           <== NOT EXECUTED
    {                                                                 
      --fd->erased_blocks;                                            
    }                                                                 
    else                                                              
    {                                                                 
      used++;                                                         
40005360:	a4 04 a0 01 	inc  %l2                                       
  int      ret;                                                       
  uint32_t spage;                                                     
  uint32_t used = 0;                                                  
  uint32_t active = 0;                                                
                                                                      
  for (spage = 0; spage < ssc->pages; spage++)                        
40005364:	b8 07 20 01 	inc  %i4                                       
40005368:	80 a0 c0 1c 	cmp  %g3, %i4                                  
4000536c:	38 bf ff 89 	bgu,a   40005190 <rtems_fdisk_recycle_segment+0x28>
40005370:	e2 06 60 10 	ld  [ %i1 + 0x10 ], %l1                        
      used++;                                                         
    }                                                                 
  }                                                                   
                                                                      
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_printf (fd, "ssc end: %d-%d: p=%ld, a=%ld, u=%ld",      
40005374:	d4 06 60 08 	ld  [ %i1 + 8 ], %o2                           
40005378:	d6 06 60 0c 	ld  [ %i1 + 0xc ], %o3                         
4000537c:	da 07 bf f8 	ld  [ %fp + -8 ], %o5                          
40005380:	e4 23 a0 5c 	st  %l2, [ %sp + 0x5c ]                        
40005384:	90 10 00 18 	mov  %i0, %o0                                  
40005388:	13 10 00 d1 	sethi  %hi(0x40034400), %o1                    
4000538c:	98 10 00 1b 	mov  %i3, %o4                                  
40005390:	7f ff fd 38 	call  40004870 <rtems_fdisk_printf>            
40005394:	92 12 61 90 	or  %o1, 0x190, %o1                            
                      ssc->device, ssc->segment,                      
                      pages, active, used);                           
#endif                                                                
  if (ssc->pages_active != 0)                                         
40005398:	d2 06 60 1c 	ld  [ %i1 + 0x1c ], %o1                        
4000539c:	80 a2 60 00 	cmp  %o1, 0                                    
400053a0:	12 80 00 69 	bne  40005544 <rtems_fdisk_recycle_segment+0x3dc><== NEVER TAKEN
400053a4:	11 10 00 d1 	sethi  %hi(0x40034400), %o0                    
  {                                                                   
    rtems_fdisk_error ("compacting: ssc pages not 0: %d",             
                       ssc->pages_active);                            
  }                                                                   
                                                                      
  ret = rtems_fdisk_erase_segment (fd, ssc);                          
400053a8:	7f ff fe 2b 	call  40004c54 <rtems_fdisk_erase_segment>     
400053ac:	81 e8 00 00 	restore                                        
static bool                                                           
rtems_fdisk_page_desc_erased (const rtems_fdisk_page_desc* pd)        
{                                                                     
  return ((pd->crc == 0xffff) &&                                      
          (pd->flags == 0xffff) &&                                    
          (pd->block == 0xffffffff)) ? true : false;                  
400053b0:	80 a0 7f ff 	cmp  %g1, -1                                   <== NOT EXECUTED
400053b4:	32 bf ff ec 	bne,a   40005364 <rtems_fdisk_recycle_segment+0x1fc><== NOT EXECUTED
400053b8:	a4 04 a0 01 	inc  %l2                                       <== NOT EXECUTED
                                                                      
      (*pages)--;                                                     
    }                                                                 
    else if (rtems_fdisk_page_desc_erased (spd))                      
    {                                                                 
      --fd->erased_blocks;                                            
400053bc:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        <== NOT EXECUTED
400053c0:	82 00 7f ff 	add  %g1, -1, %g1                              <== NOT EXECUTED
400053c4:	10 bf ff e8 	b  40005364 <rtems_fdisk_recycle_segment+0x1fc><== NOT EXECUTED
400053c8:	c2 26 20 28 	st  %g1, [ %i0 + 0x28 ]                        <== NOT EXECUTED
                                                                      
  for (spage = 0; spage < ssc->pages; spage++)                        
  {                                                                   
    rtems_fdisk_page_desc* spd = &ssc->page_descriptors[spage];       
                                                                      
    if (!dsc && ssc->pages_active > 0)                                
400053cc:	c4 06 60 1c 	ld  [ %i1 + 0x1c ], %g2                        
400053d0:	80 a0 a0 00 	cmp  %g2, 0                                    
400053d4:	22 bf ff 74 	be,a   400051a4 <rtems_fdisk_recycle_segment+0x3c><== ALWAYS TAKEN
400053d8:	c4 15 a0 02 	lduh  [ %l6 + 2 ], %g2                         
    {                                                                 
      rtems_fdisk_error ("recycle: no available dst segment");        
      return EIO;                                                     
400053dc:	84 10 20 05 	mov  5, %g2                                    <== NOT EXECUTED
  {                                                                   
    rtems_fdisk_page_desc* spd = &ssc->page_descriptors[spage];       
                                                                      
    if (!dsc && ssc->pages_active > 0)                                
    {                                                                 
      rtems_fdisk_error ("recycle: no available dst segment");        
400053e0:	11 10 00 d1 	sethi  %hi(0x40034400), %o0                    <== NOT EXECUTED
400053e4:	c4 27 bf f0 	st  %g2, [ %fp + -16 ]                         <== NOT EXECUTED
400053e8:	7f ff fd fc 	call  40004bd8 <rtems_fdisk_error>             <== NOT EXECUTED
400053ec:	90 12 20 50 	or  %o0, 0x50, %o0                             <== NOT EXECUTED
      return EIO;                                                     
400053f0:	10 bf ff d7 	b  4000534c <rtems_fdisk_recycle_segment+0x1e4><== NOT EXECUTED
400053f4:	c4 07 bf f0 	ld  [ %fp + -16 ], %g2                         <== NOT EXECUTED
      rtems_fdisk_segment_queue_push_tail (&fd->available, sc);       
  }                                                                   
}                                                                     
                                                                      
static int                                                            
rtems_fdisk_recycle_segment (rtems_flashdisk*         fd,             
400053f8:	c4 06 a0 1c 	ld  [ %i2 + 0x1c ], %g2                        <== NOT EXECUTED
400053fc:	c2 06 a0 20 	ld  [ %i2 + 0x20 ], %g1                        <== NOT EXECUTED
40005400:	d6 06 a0 24 	ld  [ %i2 + 0x24 ], %o3                        <== NOT EXECUTED
                                                                      
      active++;                                                       
                                                                      
      if (dpage >= dsc->pages)                                        
      {                                                               
        rtems_fdisk_error ("recycle: %02d-%03d: " \                   
40005404:	d2 06 a0 08 	ld  [ %i2 + 8 ], %o1                           <== NOT EXECUTED
40005408:	d4 06 a0 0c 	ld  [ %i2 + 0xc ], %o2                         <== NOT EXECUTED
      rtems_fdisk_segment_queue_push_tail (&fd->available, sc);       
  }                                                                   
}                                                                     
                                                                      
static int                                                            
rtems_fdisk_recycle_segment (rtems_flashdisk*         fd,             
4000540c:	96 02 c0 02 	add  %o3, %g2, %o3                             <== NOT EXECUTED
                                                                      
      active++;                                                       
                                                                      
      if (dpage >= dsc->pages)                                        
      {                                                               
        rtems_fdisk_error ("recycle: %02d-%03d: " \                   
40005410:	11 10 00 d1 	sethi  %hi(0x40034400), %o0                    <== NOT EXECUTED
      rtems_fdisk_segment_queue_push_tail (&fd->available, sc);       
  }                                                                   
}                                                                     
                                                                      
static int                                                            
rtems_fdisk_recycle_segment (rtems_flashdisk*         fd,             
40005414:	96 02 c0 01 	add  %o3, %g1, %o3                             <== NOT EXECUTED
                                                                      
      active++;                                                       
                                                                      
      if (dpage >= dsc->pages)                                        
      {                                                               
        rtems_fdisk_error ("recycle: %02d-%03d: " \                   
40005418:	96 23 c0 0b 	sub  %o7, %o3, %o3                             <== NOT EXECUTED
4000541c:	7f ff fd ef 	call  40004bd8 <rtems_fdisk_error>             <== NOT EXECUTED
40005420:	90 12 20 78 	or  %o0, 0x78, %o0                             <== NOT EXECUTED
                           "no page desc available: %d",              
                           dsc->device, dsc->segment,                 
                           rtems_fdisk_seg_pages_available (dsc));    
        dsc->failed = true;                                           
40005424:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
        rtems_fdisk_queue_segment (fd, dsc);                          
40005428:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
      {                                                               
        rtems_fdisk_error ("recycle: %02d-%03d: " \                   
                           "no page desc available: %d",              
                           dsc->device, dsc->segment,                 
                           rtems_fdisk_seg_pages_available (dsc));    
        dsc->failed = true;                                           
4000542c:	c2 26 a0 28 	st  %g1, [ %i2 + 0x28 ]                        <== NOT EXECUTED
        rtems_fdisk_queue_segment (fd, dsc);                          
40005430:	7f ff fe 92 	call  40004e78 <rtems_fdisk_queue_segment>     <== NOT EXECUTED
40005434:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
rtems_fdisk_segment_queue_push_head (rtems_fdisk_segment_ctl_queue* queue,
                                     rtems_fdisk_segment_ctl*       sc)
{                                                                     
  if (sc)                                                             
  {                                                                   
    sc->next = queue->head;                                           
40005438:	c4 06 20 40 	ld  [ %i0 + 0x40 ], %g2                        <== NOT EXECUTED
    queue->head = sc;                                                 
                                                                      
    if (queue->tail == 0)                                             
4000543c:	c2 06 20 44 	ld  [ %i0 + 0x44 ], %g1                        <== NOT EXECUTED
rtems_fdisk_segment_queue_push_head (rtems_fdisk_segment_ctl_queue* queue,
                                     rtems_fdisk_segment_ctl*       sc)
{                                                                     
  if (sc)                                                             
  {                                                                   
    sc->next = queue->head;                                           
40005440:	c4 26 40 00 	st  %g2, [ %i1 ]                               <== NOT EXECUTED
    queue->head = sc;                                                 
                                                                      
    if (queue->tail == 0)                                             
40005444:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40005448:	02 80 00 56 	be  400055a0 <rtems_fdisk_recycle_segment+0x438><== NOT EXECUTED
4000544c:	f2 26 20 40 	st  %i1, [ %i0 + 0x40 ]                        <== NOT EXECUTED
      queue->tail = sc;                                               
    queue->count++;                                                   
40005450:	c2 06 20 48 	ld  [ %i0 + 0x48 ], %g1                        <== NOT EXECUTED
                           dsc->device, dsc->segment,                 
                           rtems_fdisk_seg_pages_available (dsc));    
        dsc->failed = true;                                           
        rtems_fdisk_queue_segment (fd, dsc);                          
        rtems_fdisk_segment_queue_push_head (&fd->used, ssc);         
        return EIO;                                                   
40005454:	84 10 20 05 	mov  5, %g2                                    <== NOT EXECUTED
    sc->next = queue->head;                                           
    queue->head = sc;                                                 
                                                                      
    if (queue->tail == 0)                                             
      queue->tail = sc;                                               
    queue->count++;                                                   
40005458:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
4000545c:	c2 26 20 48 	st  %g1, [ %i0 + 0x48 ]                        <== NOT EXECUTED
  }                                                                   
                                                                      
  ret = rtems_fdisk_erase_segment (fd, ssc);                          
                                                                      
  return ret;                                                         
}                                                                     
40005460:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40005464:	91 e8 00 02 	restore  %g0, %g2, %o0                         <== NOT EXECUTED
#endif                                                                
  ret = rtems_fdisk_seg_read_page (fd, src_sc, src_page,              
                                   fd->copy_buffer);                  
  if (ret)                                                            
    return ret;                                                       
  return rtems_fdisk_seg_write_page (fd, dst_sc, dst_page,            
40005468:	90 10 00 18 	mov  %i0, %o0                                  
4000546c:	92 10 00 1a 	mov  %i2, %o1                                  
40005470:	7f ff fd 9c 	call  40004ae0 <rtems_fdisk_seg_write_page>    
40005474:	94 10 00 15 	mov  %l5, %o2                                  
#endif                                                                
      ret = rtems_fdisk_seg_copy_page (fd, ssc,                       
                                       spage + ssc->pages_desc,       
                                       dsc,                           
                                       dpage + dsc->pages_desc);      
      if (ret)                                                        
40005478:	84 92 20 00 	orcc  %o0, 0, %g2                              
4000547c:	12 bf ff 93 	bne  400052c8 <rtems_fdisk_recycle_segment+0x160><== NEVER TAKEN
40005480:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
        rtems_fdisk_queue_segment (fd, dsc);                          
        rtems_fdisk_segment_queue_push_head (&fd->used, ssc);         
        return ret;                                                   
      }                                                               
                                                                      
      *dpd = *spd;                                                    
40005484:	c4 04 40 10 	ld  [ %l1 + %l0 ], %g2                         
                                                                      
      ret = rtems_fdisk_seg_write_page_desc (fd,                      
40005488:	90 10 00 18 	mov  %i0, %o0                                  
        rtems_fdisk_queue_segment (fd, dsc);                          
        rtems_fdisk_segment_queue_push_head (&fd->used, ssc);         
        return ret;                                                   
      }                                                               
                                                                      
      *dpd = *spd;                                                    
4000548c:	c4 25 c0 01 	st  %g2, [ %l7 + %g1 ]                         
40005490:	c4 05 a0 04 	ld  [ %l6 + 4 ], %g2                           
                                                                      
      ret = rtems_fdisk_seg_write_page_desc (fd,                      
40005494:	92 10 00 1a 	mov  %i2, %o1                                  
        rtems_fdisk_queue_segment (fd, dsc);                          
        rtems_fdisk_segment_queue_push_head (&fd->used, ssc);         
        return ret;                                                   
      }                                                               
                                                                      
      *dpd = *spd;                                                    
40005498:	c4 24 e0 04 	st  %g2, [ %l3 + 4 ]                           
                                                                      
      ret = rtems_fdisk_seg_write_page_desc (fd,                      
4000549c:	94 10 00 1d 	mov  %i5, %o2                                  
400054a0:	7f ff fd 7f 	call  40004a9c <rtems_fdisk_seg_write_page_desc>
400054a4:	96 10 00 13 	mov  %l3, %o3                                  
                                             dsc,                     
                                             dpage, dpd);             
                                                                      
      if (ret)                                                        
400054a8:	84 92 20 00 	orcc  %o0, 0, %g2                              
400054ac:	32 80 00 2a 	bne,a   40005554 <rtems_fdisk_recycle_segment+0x3ec><== NEVER TAKEN
400054b0:	e2 06 a0 08 	ld  [ %i2 + 8 ], %l1                           <== NOT EXECUTED
        rtems_fdisk_queue_segment (fd, dsc);                          
        rtems_fdisk_segment_queue_push_head (&fd->used, ssc);         
        return ret;                                                   
      }                                                               
                                                                      
      dsc->pages_active++;                                            
400054b4:	c4 06 a0 1c 	ld  [ %i2 + 0x1c ], %g2                        
       * We do the stats to make sure everything is as it should      
       * be.                                                          
       */                                                             
                                                                      
      ssc->pages_active--;                                            
      ssc->pages_used++;                                              
400054b8:	c6 06 60 20 	ld  [ %i1 + 0x20 ], %g3                        
        rtems_fdisk_queue_segment (fd, dsc);                          
        rtems_fdisk_segment_queue_push_head (&fd->used, ssc);         
        return ret;                                                   
      }                                                               
                                                                      
      dsc->pages_active++;                                            
400054bc:	84 00 a0 01 	inc  %g2                                       
       */                                                             
                                                                      
      ssc->pages_active--;                                            
      ssc->pages_used++;                                              
                                                                      
      fd->blocks[spd->block].segment = dsc;                           
400054c0:	c2 05 a0 04 	ld  [ %l6 + 4 ], %g1                           
        rtems_fdisk_queue_segment (fd, dsc);                          
        rtems_fdisk_segment_queue_push_head (&fd->used, ssc);         
        return ret;                                                   
      }                                                               
                                                                      
      dsc->pages_active++;                                            
400054c4:	c4 26 a0 1c 	st  %g2, [ %i2 + 0x1c ]                        
       */                                                             
                                                                      
      ssc->pages_active--;                                            
      ssc->pages_used++;                                              
                                                                      
      fd->blocks[spd->block].segment = dsc;                           
400054c8:	c4 06 20 18 	ld  [ %i0 + 0x18 ], %g2                        
       * segment will be erased. Power down could be a problem.       
       * We do the stats to make sure everything is as it should      
       * be.                                                          
       */                                                             
                                                                      
      ssc->pages_active--;                                            
400054cc:	c8 06 60 1c 	ld  [ %i1 + 0x1c ], %g4                        
      ssc->pages_used++;                                              
400054d0:	86 00 e0 01 	inc  %g3                                       
                                                                      
      fd->blocks[spd->block].segment = dsc;                           
400054d4:	83 28 60 03 	sll  %g1, 3, %g1                               
       * We do the stats to make sure everything is as it should      
       * be.                                                          
       */                                                             
                                                                      
      ssc->pages_active--;                                            
      ssc->pages_used++;                                              
400054d8:	c6 26 60 20 	st  %g3, [ %i1 + 0x20 ]                        
       * segment will be erased. Power down could be a problem.       
       * We do the stats to make sure everything is as it should      
       * be.                                                          
       */                                                             
                                                                      
      ssc->pages_active--;                                            
400054dc:	88 01 3f ff 	add  %g4, -1, %g4                              
      ssc->pages_used++;                                              
                                                                      
      fd->blocks[spd->block].segment = dsc;                           
400054e0:	86 00 80 01 	add  %g2, %g1, %g3                             
       * segment will be erased. Power down could be a problem.       
       * We do the stats to make sure everything is as it should      
       * be.                                                          
       */                                                             
                                                                      
      ssc->pages_active--;                                            
400054e4:	c8 26 60 1c 	st  %g4, [ %i1 + 0x1c ]                        
      ssc->pages_used++;                                              
                                                                      
      fd->blocks[spd->block].segment = dsc;                           
400054e8:	f4 20 80 01 	st  %i2, [ %g2 + %g1 ]                         
      fd->blocks[spd->block].page    = dpage;                         
400054ec:	fa 20 e0 04 	st  %i5, [ %g3 + 4 ]                           
                                                                      
      /*                                                              
       * Place the segment on to the correct queue.                   
       */                                                             
      rtems_fdisk_queue_segment (fd, dsc);                            
400054f0:	90 10 00 18 	mov  %i0, %o0                                  
400054f4:	7f ff fe 61 	call  40004e78 <rtems_fdisk_queue_segment>     
400054f8:	92 10 00 1a 	mov  %i2, %o1                                  
 * active, used and bad pages.                                        
 */                                                                   
static uint32_t                                                       
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)   
{                                                                     
  return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
400054fc:	c8 06 a0 20 	ld  [ %i2 + 0x20 ], %g4                        
40005500:	c2 06 a0 1c 	ld  [ %i2 + 0x1c ], %g1                        
40005504:	c6 06 a0 24 	ld  [ %i2 + 0x24 ], %g3                        
                                                                      
      /*                                                              
       * Get new destination segment if necessary.                    
       */                                                             
      dst_pages = rtems_fdisk_seg_pages_available (dsc);              
      if (dst_pages == 0)                                             
40005508:	c4 06 a0 14 	ld  [ %i2 + 0x14 ], %g2                        
 * active, used and bad pages.                                        
 */                                                                   
static uint32_t                                                       
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)   
{                                                                     
  return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
4000550c:	82 01 00 01 	add  %g4, %g1, %g1                             
40005510:	82 00 40 03 	add  %g1, %g3, %g1                             
                                                                      
      /*                                                              
       * Get new destination segment if necessary.                    
       */                                                             
      dst_pages = rtems_fdisk_seg_pages_available (dsc);              
      if (dst_pages == 0)                                             
40005514:	80 a0 80 01 	cmp  %g2, %g1                                  
40005518:	02 80 00 07 	be  40005534 <rtems_fdisk_recycle_segment+0x3cc>
4000551c:	01 00 00 00 	nop                                            
        dsc = rtems_fdisk_seg_most_available (&fd->available);        
                                                                      
      (*pages)--;                                                     
40005520:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
40005524:	82 00 7f ff 	add  %g1, -1, %g1                              
40005528:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
      return EIO;                                                     
    }                                                                 
                                                                      
    if (rtems_fdisk_page_desc_flags_set (spd, RTEMS_FDISK_PAGE_ACTIVE) &&
        !rtems_fdisk_page_desc_flags_set (spd, RTEMS_FDISK_PAGE_USED))
    {                                                                 
4000552c:	10 bf ff 8e 	b  40005364 <rtems_fdisk_recycle_segment+0x1fc>
40005530:	c6 06 60 14 	ld  [ %i1 + 0x14 ], %g3                        
      /*                                                              
       * Get new destination segment if necessary.                    
       */                                                             
      dst_pages = rtems_fdisk_seg_pages_available (dsc);              
      if (dst_pages == 0)                                             
        dsc = rtems_fdisk_seg_most_available (&fd->available);        
40005534:	7f ff fc 8f 	call  40004770 <rtems_fdisk_seg_most_available>
40005538:	d0 07 bf f4 	ld  [ %fp + -12 ], %o0                         
4000553c:	10 bf ff f9 	b  40005520 <rtems_fdisk_recycle_segment+0x3b8>
40005540:	b4 10 00 08 	mov  %o0, %i2                                  
                      ssc->device, ssc->segment,                      
                      pages, active, used);                           
#endif                                                                
  if (ssc->pages_active != 0)                                         
  {                                                                   
    rtems_fdisk_error ("compacting: ssc pages not 0: %d",             
40005544:	7f ff fd a5 	call  40004bd8 <rtems_fdisk_error>             <== NOT EXECUTED
40005548:	90 12 21 b8 	or  %o0, 0x1b8, %o0                            <== NOT EXECUTED
                       ssc->pages_active);                            
  }                                                                   
                                                                      
  ret = rtems_fdisk_erase_segment (fd, ssc);                          
4000554c:	7f ff fd c2 	call  40004c54 <rtems_fdisk_erase_segment>     <== NOT EXECUTED
40005550:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                             dsc,                     
                                             dpage, dpd);             
                                                                      
      if (ret)                                                        
      {                                                               
        rtems_fdisk_error ("recycle: %02d-%03d-%03d=>"   \            
40005554:	e0 06 a0 0c 	ld  [ %i2 + 0xc ], %l0                         <== NOT EXECUTED
40005558:	e4 06 60 0c 	ld  [ %i1 + 0xc ], %l2                         <== NOT EXECUTED
4000555c:	f6 06 60 08 	ld  [ %i1 + 8 ], %i3                           <== NOT EXECUTED
40005560:	40 00 7e d1 	call  400250a4 <strerror>                      <== NOT EXECUTED
40005564:	c4 27 bf f0 	st  %g2, [ %fp + -16 ]                         <== NOT EXECUTED
40005568:	c4 07 bf f0 	ld  [ %fp + -16 ], %g2                         <== NOT EXECUTED
4000556c:	d0 23 a0 60 	st  %o0, [ %sp + 0x60 ]                        <== NOT EXECUTED
40005570:	94 10 00 12 	mov  %l2, %o2                                  <== NOT EXECUTED
40005574:	11 10 00 d1 	sethi  %hi(0x40034400), %o0                    <== NOT EXECUTED
40005578:	96 10 00 1c 	mov  %i4, %o3                                  <== NOT EXECUTED
4000557c:	98 10 00 11 	mov  %l1, %o4                                  <== NOT EXECUTED
40005580:	9a 10 00 10 	mov  %l0, %o5                                  <== NOT EXECUTED
40005584:	fa 23 a0 5c 	st  %i5, [ %sp + 0x5c ]                        <== NOT EXECUTED
40005588:	c4 23 a0 64 	st  %g2, [ %sp + 0x64 ]                        <== NOT EXECUTED
4000558c:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
40005590:	10 bf ff 60 	b  40005310 <rtems_fdisk_recycle_segment+0x1a8><== NOT EXECUTED
40005594:	90 12 21 48 	or  %o0, 0x148, %o0                            <== NOT EXECUTED
  {                                                                   
    sc->next = queue->head;                                           
    queue->head = sc;                                                 
                                                                      
    if (queue->tail == 0)                                             
      queue->tail = sc;                                               
40005598:	10 bf ff 6a 	b  40005340 <rtems_fdisk_recycle_segment+0x1d8><== NOT EXECUTED
4000559c:	f2 26 20 44 	st  %i1, [ %i0 + 0x44 ]                        <== NOT EXECUTED
400055a0:	10 bf ff ac 	b  40005450 <rtems_fdisk_recycle_segment+0x2e8><== NOT EXECUTED
400055a4:	f2 26 20 44 	st  %i1, [ %i0 + 0x44 ]                        <== NOT EXECUTED
                                                                      

40004a04 <rtems_fdisk_seg_write>: rtems_fdisk_seg_write (const rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc, uint32_t offset, const void* buffer, uint32_t size) {
40004a04:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int ret;                                                            
  uint32_t                           device;                          
  uint32_t                           segment;                         
  const rtems_fdisk_segment_desc*    sd;                              
  const rtems_fdisk_driver_handlers* ops;                             
  device = sc->device;                                                
40004a08:	e0 06 60 08 	ld  [ %i1 + 8 ], %l0                           
static const rtems_fdisk_segment_desc*                                
rtems_fdisk_seg_descriptor (const rtems_flashdisk* fd,                
                            uint32_t               device,            
                            uint32_t               segment)           
{                                                                     
  return fd->devices[device].segments[segment].descriptor;            
40004a0c:	c4 06 20 2c 	ld  [ %i0 + 0x2c ], %g2                        
40004a10:	87 2c 20 04 	sll  %l0, 4, %g3                               
  uint32_t                           device;                          
  uint32_t                           segment;                         
  const rtems_fdisk_segment_desc*    sd;                              
  const rtems_fdisk_driver_handlers* ops;                             
  device = sc->device;                                                
  segment = sc->segment;                                              
40004a14:	fa 06 60 0c 	ld  [ %i1 + 0xc ], %i5                         
static const rtems_fdisk_segment_desc*                                
rtems_fdisk_seg_descriptor (const rtems_flashdisk* fd,                
                            uint32_t               device,            
                            uint32_t               segment)           
{                                                                     
  return fd->devices[device].segments[segment].descriptor;            
40004a18:	83 2c 20 02 	sll  %l0, 2, %g1                               
40004a1c:	82 20 c0 01 	sub  %g3, %g1, %g1                             
40004a20:	86 00 80 01 	add  %g2, %g1, %g3                             
40004a24:	c2 00 80 01 	ld  [ %g2 + %g1 ], %g1                         
  const rtems_fdisk_segment_desc*    sd;                              
  const rtems_fdisk_driver_handlers* ops;                             
  device = sc->device;                                                
  segment = sc->segment;                                              
  sd = rtems_fdisk_seg_descriptor (fd, device, segment);              
  ops = fd->devices[device].descriptor->flash_ops;                    
40004a28:	c6 00 e0 08 	ld  [ %g3 + 8 ], %g3                           
static const rtems_fdisk_segment_desc*                                
rtems_fdisk_seg_descriptor (const rtems_flashdisk* fd,                
                            uint32_t               device,            
                            uint32_t               segment)           
{                                                                     
  return fd->devices[device].segments[segment].descriptor;            
40004a2c:	85 2f 60 04 	sll  %i5, 4, %g2                               
  const rtems_fdisk_segment_desc*    sd;                              
  const rtems_fdisk_driver_handlers* ops;                             
  device = sc->device;                                                
  segment = sc->segment;                                              
  sd = rtems_fdisk_seg_descriptor (fd, device, segment);              
  ops = fd->devices[device].descriptor->flash_ops;                    
40004a30:	e2 00 e0 08 	ld  [ %g3 + 8 ], %l1                           
static const rtems_fdisk_segment_desc*                                
rtems_fdisk_seg_descriptor (const rtems_flashdisk* fd,                
                            uint32_t               device,            
                            uint32_t               segment)           
{                                                                     
  return fd->devices[device].segments[segment].descriptor;            
40004a34:	87 2f 60 06 	sll  %i5, 6, %g3                               
40004a38:	84 20 c0 02 	sub  %g3, %g2, %g2                             
40004a3c:	82 00 40 02 	add  %g1, %g2, %g1                             
  device = sc->device;                                                
  segment = sc->segment;                                              
  sd = rtems_fdisk_seg_descriptor (fd, device, segment);              
  ops = fd->devices[device].descriptor->flash_ops;                    
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_printf (fd, "  seg-write: %02d-%03d: o=%08x s=%d",      
40004a40:	94 10 00 10 	mov  %l0, %o2                                  
40004a44:	96 10 00 1d 	mov  %i5, %o3                                  
40004a48:	98 10 00 1a 	mov  %i2, %o4                                  
40004a4c:	9a 10 00 1c 	mov  %i4, %o5                                  
40004a50:	90 10 00 18 	mov  %i0, %o0                                  
40004a54:	13 10 00 d0 	sethi  %hi(0x40034000), %o1                    
static const rtems_fdisk_segment_desc*                                
rtems_fdisk_seg_descriptor (const rtems_flashdisk* fd,                
                            uint32_t               device,            
                            uint32_t               segment)           
{                                                                     
  return fd->devices[device].segments[segment].descriptor;            
40004a58:	f0 00 60 04 	ld  [ %g1 + 4 ], %i0                           
  device = sc->device;                                                
  segment = sc->segment;                                              
  sd = rtems_fdisk_seg_descriptor (fd, device, segment);              
  ops = fd->devices[device].descriptor->flash_ops;                    
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_printf (fd, "  seg-write: %02d-%03d: o=%08x s=%d",      
40004a5c:	7f ff ff 85 	call  40004870 <rtems_fdisk_printf>            
40004a60:	92 12 63 78 	or  %o1, 0x378, %o1                            
                      device, segment, offset, size);                 
#endif                                                                
  ret = ops->write (sd, device, segment, offset, buffer, size);       
40004a64:	c2 04 60 04 	ld  [ %l1 + 4 ], %g1                           
40004a68:	90 10 00 18 	mov  %i0, %o0                                  
40004a6c:	92 10 00 10 	mov  %l0, %o1                                  
40004a70:	94 10 00 1d 	mov  %i5, %o2                                  
40004a74:	96 10 00 1a 	mov  %i2, %o3                                  
40004a78:	98 10 00 1b 	mov  %i3, %o4                                  
40004a7c:	9f c0 40 00 	call  %g1                                      
40004a80:	9a 10 00 1c 	mov  %i4, %o5                                  
  if (ret)                                                            
40004a84:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40004a88:	02 80 00 03 	be  40004a94 <rtems_fdisk_seg_write+0x90>      <== ALWAYS TAKEN
40004a8c:	82 10 20 01 	mov  1, %g1                                    
    sc->failed = true;                                                
40004a90:	c2 26 60 28 	st  %g1, [ %i1 + 0x28 ]                        <== NOT EXECUTED
                                                                      
  return ret;                                                         
}                                                                     
40004a94:	81 c7 e0 08 	ret                                            
40004a98:	81 e8 00 00 	restore                                        
                                                                      

40004ae0 <rtems_fdisk_seg_write_page>: static int rtems_fdisk_seg_write_page (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc, uint32_t page, const void* buffer) {
40004ae0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))             
40004ae4:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
40004ae8:	80 88 60 08 	btst  8, %g1                                   
40004aec:	22 80 00 0f 	be,a   40004b28 <rtems_fdisk_seg_write_page+0x48><== NEVER TAKEN
40004af0:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        <== NOT EXECUTED
rtems_fdisk_seg_blank_check_page (const rtems_flashdisk*   fd,        
                                  rtems_fdisk_segment_ctl* sc,        
                                  uint32_t                 page)      
{                                                                     
  return rtems_fdisk_seg_blank_check (fd, sc,                         
                                      page * fd->block_size, fd->block_size);
40004af4:	fa 06 20 14 	ld  [ %i0 + 0x14 ], %i5                        
static int                                                            
rtems_fdisk_seg_blank_check_page (const rtems_flashdisk*   fd,        
                                  rtems_fdisk_segment_ctl* sc,        
                                  uint32_t                 page)      
{                                                                     
  return rtems_fdisk_seg_blank_check (fd, sc,                         
40004af8:	90 10 00 1a 	mov  %i2, %o0                                  
40004afc:	7f ff f6 af 	call  400025b8 <.umul>                         
40004b00:	92 10 00 1d 	mov  %i5, %o1                                  
40004b04:	92 10 00 19 	mov  %i1, %o1                                  
40004b08:	94 10 00 08 	mov  %o0, %o2                                  
40004b0c:	96 10 00 1d 	mov  %i5, %o3                                  
40004b10:	7f ff ff 9c 	call  40004980 <rtems_fdisk_seg_blank_check>   
40004b14:	90 10 00 18 	mov  %i0, %o0                                  
                            const void*              buffer)          
{                                                                     
  if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))             
  {                                                                   
    int ret = rtems_fdisk_seg_blank_check_page (fd, sc, page);        
    if (ret)                                                          
40004b18:	80 a2 20 00 	cmp  %o0, 0                                    
40004b1c:	12 80 00 0b 	bne  40004b48 <rtems_fdisk_seg_write_page+0x68><== NEVER TAKEN
40004b20:	01 00 00 00 	nop                                            
      return ret;                                                     
  }                                                                   
  --fd->erased_blocks;                                                
40004b24:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
  return rtems_fdisk_seg_write (fd, sc,                               
                                page * fd->block_size, buffer, fd->block_size);
40004b28:	f8 06 20 14 	ld  [ %i0 + 0x14 ], %i4                        
  {                                                                   
    int ret = rtems_fdisk_seg_blank_check_page (fd, sc, page);        
    if (ret)                                                          
      return ret;                                                     
  }                                                                   
  --fd->erased_blocks;                                                
40004b2c:	82 00 7f ff 	add  %g1, -1, %g1                              
  return rtems_fdisk_seg_write (fd, sc,                               
40004b30:	90 10 00 1a 	mov  %i2, %o0                                  
  {                                                                   
    int ret = rtems_fdisk_seg_blank_check_page (fd, sc, page);        
    if (ret)                                                          
      return ret;                                                     
  }                                                                   
  --fd->erased_blocks;                                                
40004b34:	c2 26 20 28 	st  %g1, [ %i0 + 0x28 ]                        
  return rtems_fdisk_seg_write (fd, sc,                               
40004b38:	7f ff f6 a0 	call  400025b8 <.umul>                         
40004b3c:	92 10 00 1c 	mov  %i4, %o1                                  
40004b40:	7f ff ff b1 	call  40004a04 <rtems_fdisk_seg_write>         
40004b44:	95 e8 00 08 	restore  %g0, %o0, %o2                         
                                page * fd->block_size, buffer, fd->block_size);
}                                                                     
40004b48:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40004b4c:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
                                                                      

40004a9c <rtems_fdisk_seg_write_page_desc>: static int rtems_fdisk_seg_write_page_desc (const rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc, uint32_t page, const rtems_fdisk_page_desc* page_desc) {
40004a9c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  uint32_t offset = page * sizeof (rtems_fdisk_page_desc);            
  if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))             
40004aa0:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
40004aa4:	80 88 60 08 	btst  8, %g1                                   
40004aa8:	02 80 00 0a 	be  40004ad0 <rtems_fdisk_seg_write_page_desc+0x34><== NEVER TAKEN
40004aac:	b5 2e a0 03 	sll  %i2, 3, %i2                               
  {                                                                   
    int ret = rtems_fdisk_seg_blank_check (fd, sc,                    
40004ab0:	90 10 00 18 	mov  %i0, %o0                                  
40004ab4:	92 10 00 19 	mov  %i1, %o1                                  
40004ab8:	94 10 00 1a 	mov  %i2, %o2                                  
40004abc:	7f ff ff b1 	call  40004980 <rtems_fdisk_seg_blank_check>   
40004ac0:	96 10 20 08 	mov  8, %o3                                    
                                           offset,                    
                                           sizeof (rtems_fdisk_page_desc));
    if (ret)                                                          
40004ac4:	80 a2 20 00 	cmp  %o0, 0                                    
40004ac8:	12 80 00 04 	bne  40004ad8 <rtems_fdisk_seg_write_page_desc+0x3c><== NEVER TAKEN
40004acc:	01 00 00 00 	nop                                            
      return ret;                                                     
  }                                                                   
  return rtems_fdisk_seg_write (fd, sc, offset,                       
40004ad0:	7f ff ff cd 	call  40004a04 <rtems_fdisk_seg_write>         
40004ad4:	99 e8 20 08 	restore  %g0, 8, %o4                           
                                page_desc, sizeof (rtems_fdisk_page_desc));
}                                                                     
40004ad8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40004adc:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
                                                                      

40004dd0 <rtems_fdisk_segment_queue_insert_before>: static void rtems_fdisk_segment_queue_insert_before (rtems_fdisk_segment_ctl_queue* queue, rtems_fdisk_segment_ctl* item, rtems_fdisk_segment_ctl* sc) { if (item)
40004dd0:	80 a2 60 00 	cmp  %o1, 0                                    
40004dd4:	02 80 00 12 	be  40004e1c <rtems_fdisk_segment_queue_insert_before+0x4c><== NEVER TAKEN
40004dd8:	80 a2 a0 00 	cmp  %o2, 0                                    
  {                                                                   
    rtems_fdisk_segment_ctl** prev = &queue->head;                    
    rtems_fdisk_segment_ctl*  it = queue->head;                       
40004ddc:	c4 02 00 00 	ld  [ %o0 ], %g2                               
                                                                      
    while (it)                                                        
40004de0:	80 a0 a0 00 	cmp  %g2, 0                                    
40004de4:	02 80 00 0d 	be  40004e18 <rtems_fdisk_segment_queue_insert_before+0x48><== NEVER TAKEN
40004de8:	80 a2 40 02 	cmp  %o1, %g2                                  
    {                                                                 
      if (item == it)                                                 
40004dec:	32 80 00 08 	bne,a   40004e0c <rtems_fdisk_segment_queue_insert_before+0x3c>
40004df0:	c2 00 80 00 	ld  [ %g2 ], %g1                               
                                         rtems_fdisk_segment_ctl*       item,
                                         rtems_fdisk_segment_ctl*       sc)
{                                                                     
  if (item)                                                           
  {                                                                   
    rtems_fdisk_segment_ctl** prev = &queue->head;                    
40004df4:	10 80 00 18 	b  40004e54 <rtems_fdisk_segment_queue_insert_before+0x84>
40004df8:	84 10 00 08 	mov  %o0, %g2                                  
    rtems_fdisk_segment_ctl*  it = queue->head;                       
                                                                      
    while (it)                                                        
    {                                                                 
      if (item == it)                                                 
40004dfc:	22 80 00 17 	be,a   40004e58 <rtems_fdisk_segment_queue_insert_before+0x88><== ALWAYS TAKEN
40004e00:	c2 02 20 08 	ld  [ %o0 + 8 ], %g1                           
40004e04:	84 10 00 01 	mov  %g1, %g2                                  <== NOT EXECUTED
        queue->count++;                                               
        return;                                                       
      }                                                               
                                                                      
      prev = &it->next;                                               
      it = it->next;                                                  
40004e08:	c2 00 80 00 	ld  [ %g2 ], %g1                               <== NOT EXECUTED
  if (item)                                                           
  {                                                                   
    rtems_fdisk_segment_ctl** prev = &queue->head;                    
    rtems_fdisk_segment_ctl*  it = queue->head;                       
                                                                      
    while (it)                                                        
40004e0c:	80 a0 60 00 	cmp  %g1, 0                                    
40004e10:	12 bf ff fb 	bne  40004dfc <rtems_fdisk_segment_queue_insert_before+0x2c><== ALWAYS TAKEN
40004e14:	80 a2 40 01 	cmp  %o1, %g1                                  
 */                                                                   
static void                                                           
rtems_fdisk_segment_queue_push_tail (rtems_fdisk_segment_ctl_queue* queue,
                                     rtems_fdisk_segment_ctl*       sc)
{                                                                     
  if (sc)                                                             
40004e18:	80 a2 a0 00 	cmp  %o2, 0                                    <== NOT EXECUTED
40004e1c:	02 80 00 0c 	be  40004e4c <rtems_fdisk_segment_queue_insert_before+0x7c><== NOT EXECUTED
40004e20:	01 00 00 00 	nop                                            <== NOT EXECUTED
  {                                                                   
    sc->next = 0;                                                     
                                                                      
    if (queue->head)                                                  
40004e24:	c2 02 00 00 	ld  [ %o0 ], %g1                               <== NOT EXECUTED
40004e28:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40004e2c:	02 80 00 10 	be  40004e6c <rtems_fdisk_segment_queue_insert_before+0x9c><== NOT EXECUTED
40004e30:	c0 22 80 00 	clr  [ %o2 ]                                   <== NOT EXECUTED
    {                                                                 
      queue->tail->next = sc;                                         
40004e34:	c2 02 20 04 	ld  [ %o0 + 4 ], %g1                           <== NOT EXECUTED
40004e38:	d4 20 40 00 	st  %o2, [ %g1 ]                               <== NOT EXECUTED
      queue->tail       = sc;                                         
40004e3c:	d4 22 20 04 	st  %o2, [ %o0 + 4 ]                           <== NOT EXECUTED
    else                                                              
    {                                                                 
      queue->head = queue->tail = sc;                                 
    }                                                                 
                                                                      
    queue->count++;                                                   
40004e40:	c2 02 20 08 	ld  [ %o0 + 8 ], %g1                           <== NOT EXECUTED
40004e44:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
40004e48:	c2 22 20 08 	st  %g1, [ %o0 + 8 ]                           <== NOT EXECUTED
40004e4c:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
40004e50:	01 00 00 00 	nop                                            <== NOT EXECUTED
    {                                                                 
      if (item == it)                                                 
      {                                                               
        sc->next = item;                                              
        *prev = sc;                                                   
        queue->count++;                                               
40004e54:	c2 02 20 08 	ld  [ %o0 + 8 ], %g1                           
                                                                      
    while (it)                                                        
    {                                                                 
      if (item == it)                                                 
      {                                                               
        sc->next = item;                                              
40004e58:	d2 22 80 00 	st  %o1, [ %o2 ]                               
        *prev = sc;                                                   
40004e5c:	d4 20 80 00 	st  %o2, [ %g2 ]                               
        queue->count++;                                               
40004e60:	82 00 60 01 	inc  %g1                                       
        return;                                                       
40004e64:	81 c3 e0 08 	retl                                           
40004e68:	c2 22 20 08 	st  %g1, [ %o0 + 8 ]                           
      queue->tail->next = sc;                                         
      queue->tail       = sc;                                         
    }                                                                 
    else                                                              
    {                                                                 
      queue->head = queue->tail = sc;                                 
40004e6c:	d4 22 20 04 	st  %o2, [ %o0 + 4 ]                           <== NOT EXECUTED
40004e70:	10 bf ff f4 	b  40004e40 <rtems_fdisk_segment_queue_insert_before+0x70><== NOT EXECUTED
40004e74:	d4 22 00 00 	st  %o2, [ %o0 ]                               <== NOT EXECUTED
                                                                      

400045ec <rtems_fdisk_segment_queue_remove>: static void rtems_fdisk_segment_queue_remove (rtems_fdisk_segment_ctl_queue* queue, rtems_fdisk_segment_ctl* sc) { rtems_fdisk_segment_ctl* prev = 0; rtems_fdisk_segment_ctl* it = queue->head;
400045ec:	c4 02 00 00 	ld  [ %o0 ], %g2                               
                                                                      
  /*                                                                  
   * Do not change sc->next as sc could be on another queue.          
   */                                                                 
                                                                      
  while (it)                                                          
400045f0:	80 a0 a0 00 	cmp  %g2, 0                                    
400045f4:	02 80 00 0d 	be  40004628 <rtems_fdisk_segment_queue_remove+0x3c>
400045f8:	80 a0 80 09 	cmp  %g2, %o1                                  
  {                                                                   
    if (sc == it)                                                     
400045fc:	32 80 00 08 	bne,a   4000461c <rtems_fdisk_segment_queue_remove+0x30>
40004600:	c2 00 80 00 	ld  [ %g2 ], %g1                               
    {                                                                 
      if (prev == 0)                                                  
      {                                                               
        queue->head = sc->next;                                       
40004604:	10 80 00 16 	b  4000465c <rtems_fdisk_segment_queue_remove+0x70>
40004608:	c2 02 40 00 	ld  [ %o1 ], %g1                               
   * Do not change sc->next as sc could be on another queue.          
   */                                                                 
                                                                      
  while (it)                                                          
  {                                                                   
    if (sc == it)                                                     
4000460c:	22 80 00 09 	be,a   40004630 <rtems_fdisk_segment_queue_remove+0x44>
40004610:	c6 02 40 00 	ld  [ %o1 ], %g3                               
40004614:	84 10 00 01 	mov  %g1, %g2                                  
      queue->count--;                                                 
      break;                                                          
    }                                                                 
                                                                      
    prev = it;                                                        
    it = it->next;                                                    
40004618:	c2 00 80 00 	ld  [ %g2 ], %g1                               
                                                                      
  /*                                                                  
   * Do not change sc->next as sc could be on another queue.          
   */                                                                 
                                                                      
  while (it)                                                          
4000461c:	80 a0 60 00 	cmp  %g1, 0                                    
40004620:	12 bf ff fb 	bne  4000460c <rtems_fdisk_segment_queue_remove+0x20>
40004624:	80 a2 40 01 	cmp  %o1, %g1                                  
40004628:	81 c3 e0 08 	retl                                           
4000462c:	01 00 00 00 	nop                                            
          queue->tail = 0;                                            
      }                                                               
      else                                                            
      {                                                               
        prev->next = sc->next;                                        
        if (queue->tail == sc)                                        
40004630:	c2 02 20 04 	ld  [ %o0 + 4 ], %g1                           
40004634:	80 a0 40 09 	cmp  %g1, %o1                                  
40004638:	02 80 00 07 	be  40004654 <rtems_fdisk_segment_queue_remove+0x68><== ALWAYS TAKEN
4000463c:	c6 20 80 00 	st  %g3, [ %g2 ]                               
          queue->tail = prev;                                         
      }                                                               
      sc->next = 0;                                                   
      queue->count--;                                                 
40004640:	c2 02 20 08 	ld  [ %o0 + 8 ], %g1                           
      {                                                               
        prev->next = sc->next;                                        
        if (queue->tail == sc)                                        
          queue->tail = prev;                                         
      }                                                               
      sc->next = 0;                                                   
40004644:	c0 22 40 00 	clr  [ %o1 ]                                   
      queue->count--;                                                 
40004648:	82 00 7f ff 	add  %g1, -1, %g1                              
      break;                                                          
4000464c:	81 c3 e0 08 	retl                                           
40004650:	c2 22 20 08 	st  %g1, [ %o0 + 8 ]                           
      }                                                               
      else                                                            
      {                                                               
        prev->next = sc->next;                                        
        if (queue->tail == sc)                                        
          queue->tail = prev;                                         
40004654:	10 bf ff fb 	b  40004640 <rtems_fdisk_segment_queue_remove+0x54>
40004658:	c4 22 20 04 	st  %g2, [ %o0 + 4 ]                           
    if (sc == it)                                                     
    {                                                                 
      if (prev == 0)                                                  
      {                                                               
        queue->head = sc->next;                                       
        if (queue->head == 0)                                         
4000465c:	80 a0 60 00 	cmp  %g1, 0                                    
40004660:	12 bf ff f8 	bne  40004640 <rtems_fdisk_segment_queue_remove+0x54>
40004664:	c2 22 00 00 	st  %g1, [ %o0 ]                               
          queue->tail = 0;                                            
40004668:	10 bf ff f6 	b  40004640 <rtems_fdisk_segment_queue_remove+0x54>
4000466c:	c0 22 20 04 	clr  [ %o0 + 4 ]                               
                                                                      

40004b50 <rtems_fdisk_warning>: * @param ... The arguments for the format text. * @return int The number of bytes written to the output. */ static int rtems_fdisk_warning (const rtems_flashdisk* fd, const char *format, ...) {
40004b50:	9d e3 bf 98 	save  %sp, -104, %sp                           <== NOT EXECUTED
  int ret = 0;                                                        
  if (fd->info_level >= 1)                                            
  {                                                                   
    va_list args;                                                     
    va_start (args, format);                                          
40004b54:	f4 27 a0 4c 	st  %i2, [ %fp + 0x4c ]                        <== NOT EXECUTED
40004b58:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]                        <== NOT EXECUTED
40004b5c:	f8 27 a0 54 	st  %i4, [ %fp + 0x54 ]                        <== NOT EXECUTED
40004b60:	fa 27 a0 58 	st  %i5, [ %fp + 0x58 ]                        <== NOT EXECUTED
 */                                                                   
static int                                                            
rtems_fdisk_warning (const rtems_flashdisk* fd, const char *format, ...)
{                                                                     
  int ret = 0;                                                        
  if (fd->info_level >= 1)                                            
40004b64:	c2 06 20 6c 	ld  [ %i0 + 0x6c ], %g1                        <== NOT EXECUTED
40004b68:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40004b6c:	02 80 00 19 	be  40004bd0 <rtems_fdisk_warning+0x80>        <== NOT EXECUTED
40004b70:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
  {                                                                   
    va_list args;                                                     
    va_start (args, format);                                          
    fprintf (stdout, "fdisk:warning:");                               
40004b74:	3b 10 00 e4 	sethi  %hi(0x40039000), %i5                    <== NOT EXECUTED
40004b78:	c2 07 63 70 	ld  [ %i5 + 0x370 ], %g1	! 40039370 <_impure_ptr><== NOT EXECUTED
40004b7c:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
40004b80:	d6 00 60 08 	ld  [ %g1 + 8 ], %o3                           <== NOT EXECUTED
{                                                                     
  int ret = 0;                                                        
  if (fd->info_level >= 1)                                            
  {                                                                   
    va_list args;                                                     
    va_start (args, format);                                          
40004b84:	82 07 a0 4c 	add  %fp, 0x4c, %g1                            <== NOT EXECUTED
    fprintf (stdout, "fdisk:warning:");                               
40004b88:	94 10 20 0e 	mov  0xe, %o2                                  <== NOT EXECUTED
{                                                                     
  int ret = 0;                                                        
  if (fd->info_level >= 1)                                            
  {                                                                   
    va_list args;                                                     
    va_start (args, format);                                          
40004b8c:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          <== NOT EXECUTED
    fprintf (stdout, "fdisk:warning:");                               
40004b90:	11 10 00 d0 	sethi  %hi(0x40034000), %o0                    <== NOT EXECUTED
40004b94:	40 00 7b 65 	call  40023928 <fwrite>                        <== NOT EXECUTED
40004b98:	90 12 23 a0 	or  %o0, 0x3a0, %o0	! 400343a0 <__FUNCTION__.6193+0x2d8><== NOT EXECUTED
    ret =  vfprintf (stdout, format, args);                           
40004b9c:	c2 07 63 70 	ld  [ %i5 + 0x370 ], %g1                       <== NOT EXECUTED
40004ba0:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          <== NOT EXECUTED
40004ba4:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           <== NOT EXECUTED
40004ba8:	40 00 9c c5 	call  4002bebc <vfprintf>                      <== NOT EXECUTED
40004bac:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
    fprintf (stdout, "\n");                                           
40004bb0:	c2 07 63 70 	ld  [ %i5 + 0x370 ], %g1                       <== NOT EXECUTED
  if (fd->info_level >= 1)                                            
  {                                                                   
    va_list args;                                                     
    va_start (args, format);                                          
    fprintf (stdout, "fdisk:warning:");                               
    ret =  vfprintf (stdout, format, args);                           
40004bb4:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
    fprintf (stdout, "\n");                                           
40004bb8:	d2 00 60 08 	ld  [ %g1 + 8 ], %o1                           <== NOT EXECUTED
40004bbc:	40 00 79 7a 	call  400231a4 <fputc>                         <== NOT EXECUTED
40004bc0:	90 10 20 0a 	mov  0xa, %o0                                  <== NOT EXECUTED
    fflush (stdout);                                                  
40004bc4:	c2 07 63 70 	ld  [ %i5 + 0x370 ], %g1                       <== NOT EXECUTED
40004bc8:	40 00 78 5f 	call  40022d44 <fflush>                        <== NOT EXECUTED
40004bcc:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           <== NOT EXECUTED
    va_end (args);                                                    
  }                                                                   
  return ret;                                                         
}                                                                     
40004bd0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40004bd4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4000c250 <rtems_filesystem_check_access>: int eval_flags, mode_t node_mode, uid_t node_uid, gid_t node_gid ) {
4000c250:	9d e3 bf a0 	save  %sp, -96, %sp                            
  mode_t perm_flags = eval_flags & RTEMS_FS_PERMS_RWX;                
  uid_t task_uid = geteuid();                                         
4000c254:	7f ff fe fa 	call  4000be3c <geteuid>                       
4000c258:	b0 0e 20 07 	and  %i0, 7, %i0                               
                                                                      
  if (task_uid == 0 || task_uid == node_uid) {                        
4000c25c:	91 2a 20 10 	sll  %o0, 0x10, %o0                            
4000c260:	91 32 20 10 	srl  %o0, 0x10, %o0                            
4000c264:	80 a2 00 1a 	cmp  %o0, %i2                                  
4000c268:	12 80 00 08 	bne  4000c288 <rtems_filesystem_check_access+0x38>
4000c26c:	80 a2 20 00 	cmp  %o0, 0                                    
    perm_flags <<= RTEMS_FS_USR_SHIFT;                                
4000c270:	b1 2e 20 06 	sll  %i0, 6, %i0                               
    } else {                                                          
      perm_flags <<= RTEMS_FS_OTH_SHIFT;                              
    }                                                                 
  }                                                                   
                                                                      
  return (perm_flags & node_mode) == perm_flags;                      
4000c274:	b0 2e 00 19 	andn  %i0, %i1, %i0                            
}                                                                     
4000c278:	80 a0 00 18 	cmp  %g0, %i0                                  
4000c27c:	b0 60 3f ff 	subx  %g0, -1, %i0                             
4000c280:	81 c7 e0 08 	ret                                            
4000c284:	81 e8 00 00 	restore                                        
)                                                                     
{                                                                     
  mode_t perm_flags = eval_flags & RTEMS_FS_PERMS_RWX;                
  uid_t task_uid = geteuid();                                         
                                                                      
  if (task_uid == 0 || task_uid == node_uid) {                        
4000c288:	22 bf ff fb 	be,a   4000c274 <rtems_filesystem_check_access+0x24>
4000c28c:	b1 2e 20 06 	sll  %i0, 6, %i0                               
    perm_flags <<= RTEMS_FS_USR_SHIFT;                                
  } else {                                                            
    gid_t task_gid = getegid();                                       
4000c290:	7f ff fe e7 	call  4000be2c <getegid>                       
4000c294:	01 00 00 00 	nop                                            
                                                                      
    if (task_gid == 0 || task_gid == node_gid) {                      
4000c298:	91 2a 20 10 	sll  %o0, 0x10, %o0                            
4000c29c:	91 32 20 10 	srl  %o0, 0x10, %o0                            
4000c2a0:	80 a2 00 1b 	cmp  %o0, %i3                                  
4000c2a4:	12 80 00 08 	bne  4000c2c4 <rtems_filesystem_check_access+0x74>
4000c2a8:	80 a2 20 00 	cmp  %o0, 0                                    
      perm_flags <<= RTEMS_FS_GRP_SHIFT;                              
4000c2ac:	b1 2e 20 03 	sll  %i0, 3, %i0                               
    } else {                                                          
      perm_flags <<= RTEMS_FS_OTH_SHIFT;                              
    }                                                                 
  }                                                                   
                                                                      
  return (perm_flags & node_mode) == perm_flags;                      
4000c2b0:	b0 2e 00 19 	andn  %i0, %i1, %i0                            
}                                                                     
4000c2b4:	80 a0 00 18 	cmp  %g0, %i0                                  
4000c2b8:	b0 60 3f ff 	subx  %g0, -1, %i0                             
4000c2bc:	81 c7 e0 08 	ret                                            
4000c2c0:	81 e8 00 00 	restore                                        
  if (task_uid == 0 || task_uid == node_uid) {                        
    perm_flags <<= RTEMS_FS_USR_SHIFT;                                
  } else {                                                            
    gid_t task_gid = getegid();                                       
                                                                      
    if (task_gid == 0 || task_gid == node_gid) {                      
4000c2c4:	32 bf ff ed 	bne,a   4000c278 <rtems_filesystem_check_access+0x28><== ALWAYS TAKEN
4000c2c8:	b0 2e 00 19 	andn  %i0, %i1, %i0                            
      perm_flags <<= RTEMS_FS_GRP_SHIFT;                              
4000c2cc:	10 bf ff f9 	b  4000c2b0 <rtems_filesystem_check_access+0x60><== NOT EXECUTED
4000c2d0:	b1 2e 20 03 	sll  %i0, 3, %i0                               <== NOT EXECUTED
                                                                      

40004550 <rtems_filesystem_do_unmount>: } void rtems_filesystem_do_unmount( rtems_filesystem_mount_table_entry_t *mt_entry ) {
40004550:	9d e3 bf a0 	save  %sp, -96, %sp                            
 */                                                                   
#include <rtems/userenv.h>                                            
                                                                      
static inline void rtems_libio_lock( void )                           
{                                                                     
  rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
40004554:	3b 10 00 7b 	sethi  %hi(0x4001ec00), %i5                    
40004558:	d0 07 61 38 	ld  [ %i5 + 0x138 ], %o0	! 4001ed38 <rtems_libio_semaphore>
4000455c:	92 10 20 00 	clr  %o1                                       
40004560:	40 00 0b 8b 	call  4000738c <rtems_semaphore_obtain>        
40004564:	94 10 20 00 	clr  %o2                                       
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
40004568:	c4 06 00 00 	ld  [ %i0 ], %g2                               
  previous       = the_node->previous;                                
4000456c:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
}                                                                     
                                                                      
static inline void rtems_libio_unlock( void )                         
{                                                                     
  rtems_semaphore_release( rtems_libio_semaphore );                   
40004570:	d0 07 61 38 	ld  [ %i5 + 0x138 ], %o0                       
  next->previous = previous;                                          
40004574:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]                           
40004578:	40 00 0b d4 	call  400074c8 <rtems_semaphore_release>       
4000457c:	c4 20 40 00 	st  %g2, [ %g1 ]                               
  rtems_filesystem_mt_lock();                                         
  rtems_chain_extract_unprotected(&mt_entry->mt_node);                
  rtems_filesystem_mt_unlock();                                       
  rtems_filesystem_global_location_release(mt_entry->mt_point_node);  
40004580:	40 00 00 6d 	call  40004734 <rtems_filesystem_global_location_release>
40004584:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        
  (*mt_entry->ops->fsunmount_me_h)(mt_entry);                         
40004588:	c2 06 20 0c 	ld  [ %i0 + 0xc ], %g1                         
4000458c:	c2 00 60 3c 	ld  [ %g1 + 0x3c ], %g1                        
40004590:	9f c0 40 00 	call  %g1                                      
40004594:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
  if (mt_entry->unmount_task != 0) {                                  
40004598:	d0 06 20 3c 	ld  [ %i0 + 0x3c ], %o0                        
4000459c:	80 a2 20 00 	cmp  %o0, 0                                    
400045a0:	02 80 00 07 	be  400045bc <rtems_filesystem_do_unmount+0x6c><== NEVER TAKEN
400045a4:	01 00 00 00 	nop                                            
 */                                                                   
RTEMS_INLINE_ROUTINE rtems_status_code rtems_event_transient_send(    
  rtems_id id                                                         
)                                                                     
{                                                                     
  return rtems_event_system_send( id, RTEMS_EVENT_SYSTEM_TRANSIENT ); 
400045a8:	40 00 0b f3 	call  40007574 <rtems_event_system_send>       
400045ac:	13 20 00 00 	sethi  %hi(0x80000000), %o1                    
    rtems_status_code sc =                                            
      rtems_event_transient_send(mt_entry->unmount_task);             
    if (sc != RTEMS_SUCCESSFUL) {                                     
400045b0:	80 a2 20 00 	cmp  %o0, 0                                    
400045b4:	32 80 00 04 	bne,a   400045c4 <rtems_filesystem_do_unmount+0x74><== NEVER TAKEN
400045b8:	11 37 ab 6f 	sethi  %hi(0xdeadbc00), %o0                    <== NOT EXECUTED
      rtems_fatal_error_occurred(0xdeadbeef);                         
    }                                                                 
  }                                                                   
                                                                      
  free(mt_entry);                                                     
400045bc:	7f ff fa 9b 	call  40003028 <free>                          
400045c0:	81 e8 00 00 	restore                                        
                                                                      
  if (mt_entry->unmount_task != 0) {                                  
    rtems_status_code sc =                                            
      rtems_event_transient_send(mt_entry->unmount_task);             
    if (sc != RTEMS_SUCCESSFUL) {                                     
      rtems_fatal_error_occurred(0xdeadbeef);                         
400045c4:	40 00 0d 57 	call  40007b20 <rtems_fatal_error_occurred>    <== NOT EXECUTED
400045c8:	90 12 22 ef 	or  %o0, 0x2ef, %o0                            <== NOT EXECUTED
                                                                      

4000c500 <rtems_filesystem_eval_path_eat_delimiter>: void rtems_filesystem_eval_path_eat_delimiter( rtems_filesystem_eval_path_context_t *ctx ) { const char *current = ctx->path;
4000c500:	c2 02 00 00 	ld  [ %o0 ], %g1                               
  const char *end = current + ctx->pathlen;                           
4000c504:	c6 02 20 04 	ld  [ %o0 + 4 ], %g3                           
4000c508:	86 00 40 03 	add  %g1, %g3, %g3                             
                                                                      
  while (current != end && rtems_filesystem_is_delimiter(*current)) { 
4000c50c:	80 a0 40 03 	cmp  %g1, %g3                                  
4000c510:	32 80 00 08 	bne,a   4000c530 <rtems_filesystem_eval_path_eat_delimiter+0x30><== ALWAYS TAKEN
4000c514:	c4 48 40 00 	ldsb  [ %g1 ], %g2                             
    ++current;                                                        
  }                                                                   
                                                                      
  ctx->path = current;                                                
  ctx->pathlen = (size_t) (end - current);                            
4000c518:	10 80 00 0d 	b  4000c54c <rtems_filesystem_eval_path_eat_delimiter+0x4c><== NOT EXECUTED
4000c51c:	86 20 c0 01 	sub  %g3, %g1, %g3                             <== NOT EXECUTED
)                                                                     
{                                                                     
  const char *current = ctx->path;                                    
  const char *end = current + ctx->pathlen;                           
                                                                      
  while (current != end && rtems_filesystem_is_delimiter(*current)) { 
4000c520:	80 a0 c0 01 	cmp  %g3, %g1                                  
4000c524:	22 80 00 0a 	be,a   4000c54c <rtems_filesystem_eval_path_eat_delimiter+0x4c>
4000c528:	86 20 c0 01 	sub  %g3, %g1, %g3                             
  gid_t node_gid                                                      
);                                                                    
                                                                      
static inline bool rtems_filesystem_is_delimiter(char c)              
{                                                                     
  return c == '/' || c == '\\';                                       
4000c52c:	c4 48 40 00 	ldsb  [ %g1 ], %g2                             
4000c530:	80 a0 a0 5c 	cmp  %g2, 0x5c                                 
4000c534:	22 bf ff fb 	be,a   4000c520 <rtems_filesystem_eval_path_eat_delimiter+0x20>
4000c538:	82 00 60 01 	inc  %g1                                       
4000c53c:	80 a0 a0 2f 	cmp  %g2, 0x2f                                 
4000c540:	22 bf ff f8 	be,a   4000c520 <rtems_filesystem_eval_path_eat_delimiter+0x20>
4000c544:	82 00 60 01 	inc  %g1                                       
    ++current;                                                        
  }                                                                   
                                                                      
  ctx->path = current;                                                
  ctx->pathlen = (size_t) (end - current);                            
4000c548:	86 20 c0 01 	sub  %g3, %g1, %g3                             
                                                                      
  while (current != end && rtems_filesystem_is_delimiter(*current)) { 
    ++current;                                                        
  }                                                                   
                                                                      
  ctx->path = current;                                                
4000c54c:	c2 22 00 00 	st  %g1, [ %o0 ]                               
  ctx->pathlen = (size_t) (end - current);                            
4000c550:	81 c3 e0 08 	retl                                           
4000c554:	c6 22 20 04 	st  %g3, [ %o0 + 4 ]                           
                                                                      

4000c308 <rtems_filesystem_eval_path_generic>: void rtems_filesystem_eval_path_generic( rtems_filesystem_eval_path_context_t *ctx, void *arg, const rtems_filesystem_eval_path_generic_config *config ) {
4000c308:	9d e3 bf a0 	save  %sp, -96, %sp                            
            } else {                                                  
              /* This is the root file system */                      
              status = (*config->eval_token)(ctx, arg, ".", 1);       
            }                                                         
          } else {                                                    
            status = (*config->eval_token)(ctx, arg, "..", 2);        
4000c30c:	03 10 00 74 	sethi  %hi(0x4001d000), %g1                    
              rtems_filesystem_eval_path_error(ctx, EINVAL);          
              status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;       
            }                                                         
          }                                                           
        } else if (rtems_filesystem_is_parent_directory(token, tokenlen)) {
          rtems_filesystem_location_info_t *currentloc =              
4000c310:	b6 06 20 18 	add  %i0, 0x18, %i3                            
            } else {                                                  
              /* This is the root file system */                      
              status = (*config->eval_token)(ctx, arg, ".", 1);       
            }                                                         
          } else {                                                    
            status = (*config->eval_token)(ctx, arg, "..", 2);        
4000c314:	a2 10 63 d0 	or  %g1, 0x3d0, %l1                            
                ¤tloc->mt_entry->mt_point_node                  
              );                                                      
              status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;       
            } else {                                                  
              /* This is the root file system */                      
              status = (*config->eval_token)(ctx, arg, ".", 1);       
4000c318:	03 10 00 73 	sethi  %hi(0x4001cc00), %g1                    
4000c31c:	a0 10 63 38 	or  %g1, 0x338, %l0	! 4001cf38 <rtems_filesystem_default_pathconf+0x3c>
  rtems_filesystem_eval_path_context_t *ctx,                          
  const char **token,                                                 
  size_t *tokenlen                                                    
)                                                                     
{                                                                     
  rtems_filesystem_eval_path_next_token(ctx);                         
4000c320:	40 00 00 8e 	call  4000c558 <rtems_filesystem_eval_path_next_token>
4000c324:	90 10 00 18 	mov  %i0, %o0                                  
  *token = ctx->token;                                                
  *tokenlen = ctx->tokenlen;                                          
4000c328:	fa 06 20 0c 	ld  [ %i0 + 0xc ], %i5                         
    const char *token;                                                
    size_t tokenlen;                                                  
                                                                      
    rtems_filesystem_eval_path_get_next_token(ctx, &token, &tokenlen);
                                                                      
    if (tokenlen > 0) {                                               
4000c32c:	80 a7 60 00 	cmp  %i5, 0                                    
4000c330:	02 80 00 18 	be  4000c390 <rtems_filesystem_eval_path_generic+0x88>
4000c334:	f8 06 20 08 	ld  [ %i0 + 8 ], %i4                           
      if ((*config->is_directory)(ctx, arg)) {                        
4000c338:	c2 06 80 00 	ld  [ %i2 ], %g1                               
4000c33c:	90 10 00 18 	mov  %i0, %o0                                  
4000c340:	9f c0 40 00 	call  %g1                                      
4000c344:	92 10 00 19 	mov  %i1, %o1                                  
4000c348:	80 8a 20 ff 	btst  0xff, %o0                                
4000c34c:	02 80 00 13 	be  4000c398 <rtems_filesystem_eval_path_generic+0x90>
4000c350:	80 a7 60 01 	cmp  %i5, 1                                    
static inline bool rtems_filesystem_is_current_directory(             
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  return tokenlen == 1 && token [0] == '.';                           
4000c354:	02 80 00 23 	be  4000c3e0 <rtems_filesystem_eval_path_generic+0xd8>
4000c358:	80 a7 60 02 	cmp  %i5, 2                                    
static inline bool rtems_filesystem_is_parent_directory(              
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  return tokenlen == 2 && token [0] == '.' && token [1] == '.';       
4000c35c:	22 80 00 2f 	be,a   4000c418 <rtems_filesystem_eval_path_generic+0x110>
4000c360:	c2 4f 00 00 	ldsb  [ %i4 ], %g1                             
            }                                                         
          } else {                                                    
            status = (*config->eval_token)(ctx, arg, "..", 2);        
          }                                                           
        } else {                                                      
          status = (*config->eval_token)(ctx, arg, token, tokenlen);  
4000c364:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1                           
4000c368:	90 10 00 18 	mov  %i0, %o0                                  
4000c36c:	92 10 00 19 	mov  %i1, %o1                                  
4000c370:	94 10 00 1c 	mov  %i4, %o2                                  
4000c374:	9f c0 40 00 	call  %g1                                      
4000c378:	96 10 00 1d 	mov  %i5, %o3                                  
        }                                                             
                                                                      
        if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {  
4000c37c:	80 a2 20 02 	cmp  %o0, 2                                    
4000c380:	02 80 00 08 	be  4000c3a0 <rtems_filesystem_eval_path_generic+0x98>
4000c384:	80 a2 20 00 	cmp  %o0, 0                                    
)                                                                     
{                                                                     
  rtems_filesystem_eval_path_generic_status status =                  
    RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;                      
                                                                      
  while (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE) {     
4000c388:	02 bf ff e6 	be  4000c320 <rtems_filesystem_eval_path_generic+0x18>
4000c38c:	01 00 00 00 	nop                                            
4000c390:	81 c7 e0 08 	ret                                            
4000c394:	81 e8 00 00 	restore                                        
              rtems_filesystem_eval_path_error(ctx, ENOENT);          
            }                                                         
          }                                                           
        }                                                             
      } else {                                                        
        rtems_filesystem_eval_path_error(ctx, ENOTDIR);               
4000c398:	7f ff de fd 	call  40003f8c <rtems_filesystem_eval_path_error>
4000c39c:	93 e8 20 14 	restore  %g0, 0x14, %o1                        
        } else {                                                      
          status = (*config->eval_token)(ctx, arg, token, tokenlen);  
        }                                                             
                                                                      
        if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {  
          if (rtems_filesystem_eval_path_has_path(ctx)) {             
4000c3a0:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
4000c3a4:	80 a0 60 00 	cmp  %g1, 0                                    
4000c3a8:	02 bf ff fa 	be  4000c390 <rtems_filesystem_eval_path_generic+0x88>
4000c3ac:	01 00 00 00 	nop                                            
            int eval_flags;                                           
                                                                      
            rtems_filesystem_eval_path_eat_delimiter(ctx);            
4000c3b0:	40 00 00 54 	call  4000c500 <rtems_filesystem_eval_path_eat_delimiter>
4000c3b4:	90 10 00 18 	mov  %i0, %o0                                  
            eval_flags = rtems_filesystem_eval_path_get_flags(ctx);   
            if (                                                      
              (eval_flags & RTEMS_FS_ACCEPT_RESIDUAL_DELIMITERS) == 0 
4000c3b8:	c2 06 20 10 	ld  [ %i0 + 0x10 ], %g1                        
          if (rtems_filesystem_eval_path_has_path(ctx)) {             
            int eval_flags;                                           
                                                                      
            rtems_filesystem_eval_path_eat_delimiter(ctx);            
            eval_flags = rtems_filesystem_eval_path_get_flags(ctx);   
            if (                                                      
4000c3bc:	80 88 60 80 	btst  0x80, %g1                                
4000c3c0:	02 80 00 06 	be  4000c3d8 <rtems_filesystem_eval_path_generic+0xd0>
4000c3c4:	01 00 00 00 	nop                                            
              (eval_flags & RTEMS_FS_ACCEPT_RESIDUAL_DELIMITERS) == 0 
                || rtems_filesystem_eval_path_has_path(ctx)           
4000c3c8:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
4000c3cc:	80 a0 60 00 	cmp  %g1, 0                                    
4000c3d0:	02 bf ff f0 	be  4000c390 <rtems_filesystem_eval_path_generic+0x88>
4000c3d4:	01 00 00 00 	nop                                            
            ) {                                                       
              rtems_filesystem_eval_path_error(ctx, ENOENT);          
4000c3d8:	7f ff de ed 	call  40003f8c <rtems_filesystem_eval_path_error>
4000c3dc:	93 e8 20 02 	restore  %g0, 2, %o1                           
static inline bool rtems_filesystem_is_current_directory(             
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  return tokenlen == 1 && token [0] == '.';                           
4000c3e0:	c2 4f 00 00 	ldsb  [ %i4 ], %g1                             
4000c3e4:	80 a0 60 2e 	cmp  %g1, 0x2e                                 
4000c3e8:	32 bf ff e0 	bne,a   4000c368 <rtems_filesystem_eval_path_generic+0x60>
4000c3ec:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1                           
    rtems_filesystem_eval_path_get_next_token(ctx, &token, &tokenlen);
                                                                      
    if (tokenlen > 0) {                                               
      if ((*config->is_directory)(ctx, arg)) {                        
        if (rtems_filesystem_is_current_directory(token, tokenlen)) { 
          if (rtems_filesystem_eval_path_has_path(ctx)) {             
4000c3f0:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
4000c3f4:	80 a0 60 00 	cmp  %g1, 0                                    
4000c3f8:	32 80 00 2c 	bne,a   4000c4a8 <rtems_filesystem_eval_path_generic+0x1a0>
4000c3fc:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1                           
            status = (*config->eval_token)(ctx, arg, ".", 1);         
          } else {                                                    
            int eval_flags = rtems_filesystem_eval_path_get_flags(ctx);
                                                                      
            if ((eval_flags & RTEMS_FS_REJECT_TERMINAL_DOT) == 0) {   
4000c400:	c4 06 20 10 	ld  [ %i0 + 0x10 ], %g2                        
4000c404:	80 88 a1 00 	btst  0x100, %g2                               
4000c408:	22 80 00 28 	be,a   4000c4a8 <rtems_filesystem_eval_path_generic+0x1a0>
4000c40c:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1                           
              status = (*config->eval_token)(ctx, arg, ".", 1);       
            } else {                                                  
              rtems_filesystem_eval_path_error(ctx, EINVAL);          
4000c410:	7f ff de df 	call  40003f8c <rtems_filesystem_eval_path_error>
4000c414:	93 e8 20 16 	restore  %g0, 0x16, %o1                        
static inline bool rtems_filesystem_is_parent_directory(              
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  return tokenlen == 2 && token [0] == '.' && token [1] == '.';       
4000c418:	80 a0 60 2e 	cmp  %g1, 0x2e                                 
4000c41c:	32 bf ff d3 	bne,a   4000c368 <rtems_filesystem_eval_path_generic+0x60>
4000c420:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1                           
4000c424:	c2 4f 20 01 	ldsb  [ %i4 + 1 ], %g1                         
4000c428:	80 a0 60 2e 	cmp  %g1, 0x2e                                 
4000c42c:	32 bf ff cf 	bne,a   4000c368 <rtems_filesystem_eval_path_generic+0x60><== NEVER TAKEN
4000c430:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1                           <== NOT EXECUTED
  const rtems_filesystem_eval_path_context_t *ctx,                    
  const rtems_filesystem_location_info_t *loc                         
)                                                                     
{                                                                     
  const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
  const rtems_filesystem_location_info_t *rootloc = &ctx->rootloc->location;
4000c434:	d2 06 20 30 	ld  [ %i0 + 0x30 ], %o1                        
static bool is_eval_path_root(                                        
  const rtems_filesystem_eval_path_context_t *ctx,                    
  const rtems_filesystem_location_info_t *loc                         
)                                                                     
{                                                                     
  const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
4000c438:	c4 06 20 2c 	ld  [ %i0 + 0x2c ], %g2                        
  const rtems_filesystem_location_info_t *rootloc = &ctx->rootloc->location;
                                                                      
  return mt_entry == rootloc->mt_entry                                
    && (*mt_entry->ops->are_nodes_equal_h)( loc, rootloc );           
4000c43c:	c2 02 60 14 	ld  [ %o1 + 0x14 ], %g1                        
4000c440:	80 a0 80 01 	cmp  %g2, %g1                                  
4000c444:	22 80 00 27 	be,a   4000c4e0 <rtems_filesystem_eval_path_generic+0x1d8>
4000c448:	c2 00 a0 0c 	ld  [ %g2 + 0xc ], %g1                         
{                                                                     
  const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
  const rtems_filesystem_location_info_t *mt_fs_root =                
    &mt_entry->mt_fs_root->location;                                  
                                                                      
  return (*mt_entry->ops->are_nodes_equal_h)( loc, mt_fs_root );      
4000c44c:	c2 00 a0 0c 	ld  [ %g2 + 0xc ], %g1                         
4000c450:	d2 00 a0 24 	ld  [ %g2 + 0x24 ], %o1                        
4000c454:	c2 00 60 10 	ld  [ %g1 + 0x10 ], %g1                        
4000c458:	9f c0 40 00 	call  %g1                                      
4000c45c:	90 10 00 1b 	mov  %i3, %o0                                  
            rtems_filesystem_eval_path_get_currentloc( ctx );         
                                                                      
          if (is_eval_path_root(ctx, currentloc)) {                   
            /* This prevents the escape from a chroot() environment */
            status = (*config->eval_token)(ctx, arg, ".", 1);         
          } else if (is_fs_root(currentloc)) {                        
4000c460:	80 8a 20 ff 	btst  0xff, %o0                                
4000c464:	22 80 00 18 	be,a   4000c4c4 <rtems_filesystem_eval_path_generic+0x1bc>
4000c468:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1                           
            if (currentloc->mt_entry->mt_point_node != NULL) {        
4000c46c:	c2 06 20 2c 	ld  [ %i0 + 0x2c ], %g1                        
4000c470:	c4 00 60 20 	ld  [ %g1 + 0x20 ], %g2                        
4000c474:	80 a0 a0 00 	cmp  %g2, 0                                    
4000c478:	22 80 00 0c 	be,a   4000c4a8 <rtems_filesystem_eval_path_generic+0x1a0><== NEVER TAKEN
4000c47c:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1                           <== NOT EXECUTED
                                                                      
static inline void rtems_filesystem_eval_path_put_back_token(         
  rtems_filesystem_eval_path_context_t *ctx                           
)                                                                     
{                                                                     
  size_t tokenlen = ctx->tokenlen;                                    
4000c480:	c4 06 20 0c 	ld  [ %i0 + 0xc ], %g2                         
                                                                      
  ctx->path -= tokenlen;                                              
4000c484:	c6 06 00 00 	ld  [ %i0 ], %g3                               
  ctx->pathlen += tokenlen;                                           
4000c488:	c8 06 20 04 	ld  [ %i0 + 4 ], %g4                           
  rtems_filesystem_eval_path_context_t *ctx                           
)                                                                     
{                                                                     
  size_t tokenlen = ctx->tokenlen;                                    
                                                                      
  ctx->path -= tokenlen;                                              
4000c48c:	86 20 c0 02 	sub  %g3, %g2, %g3                             
  ctx->pathlen += tokenlen;                                           
  ctx->tokenlen = 0;                                                  
4000c490:	c0 26 20 0c 	clr  [ %i0 + 0xc ]                             
)                                                                     
{                                                                     
  size_t tokenlen = ctx->tokenlen;                                    
                                                                      
  ctx->path -= tokenlen;                                              
  ctx->pathlen += tokenlen;                                           
4000c494:	84 01 00 02 	add  %g4, %g2, %g2                             
  rtems_filesystem_eval_path_context_t *ctx                           
)                                                                     
{                                                                     
  size_t tokenlen = ctx->tokenlen;                                    
                                                                      
  ctx->path -= tokenlen;                                              
4000c498:	c6 26 00 00 	st  %g3, [ %i0 ]                               
  ctx->pathlen += tokenlen;                                           
4000c49c:	c4 26 20 04 	st  %g2, [ %i0 + 4 ]                           
              rtems_filesystem_eval_path_put_back_token(ctx);         
              rtems_filesystem_eval_path_restart(                     
4000c4a0:	7f ff df ca 	call  400043c8 <rtems_filesystem_eval_path_restart>
4000c4a4:	93 e8 60 20 	restore  %g1, 0x20, %o1                        
          rtems_filesystem_location_info_t *currentloc =              
            rtems_filesystem_eval_path_get_currentloc( ctx );         
                                                                      
          if (is_eval_path_root(ctx, currentloc)) {                   
            /* This prevents the escape from a chroot() environment */
            status = (*config->eval_token)(ctx, arg, ".", 1);         
4000c4a8:	90 10 00 18 	mov  %i0, %o0                                  
4000c4ac:	92 10 00 19 	mov  %i1, %o1                                  
4000c4b0:	94 10 00 10 	mov  %l0, %o2                                  
4000c4b4:	9f c0 40 00 	call  %g1                                      
4000c4b8:	96 10 20 01 	mov  1, %o3                                    
          }                                                           
        } else {                                                      
          status = (*config->eval_token)(ctx, arg, token, tokenlen);  
        }                                                             
                                                                      
        if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {  
4000c4bc:	10 bf ff b1 	b  4000c380 <rtems_filesystem_eval_path_generic+0x78>
4000c4c0:	80 a2 20 02 	cmp  %o0, 2                                    
            } else {                                                  
              /* This is the root file system */                      
              status = (*config->eval_token)(ctx, arg, ".", 1);       
            }                                                         
          } else {                                                    
            status = (*config->eval_token)(ctx, arg, "..", 2);        
4000c4c4:	90 10 00 18 	mov  %i0, %o0                                  
4000c4c8:	92 10 00 19 	mov  %i1, %o1                                  
4000c4cc:	94 10 00 11 	mov  %l1, %o2                                  
4000c4d0:	9f c0 40 00 	call  %g1                                      
4000c4d4:	96 10 20 02 	mov  2, %o3                                    
          }                                                           
        } else {                                                      
          status = (*config->eval_token)(ctx, arg, token, tokenlen);  
        }                                                             
                                                                      
        if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {  
4000c4d8:	10 bf ff aa 	b  4000c380 <rtems_filesystem_eval_path_generic+0x78>
4000c4dc:	80 a2 20 02 	cmp  %o0, 2                                    
{                                                                     
  const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
  const rtems_filesystem_location_info_t *rootloc = &ctx->rootloc->location;
                                                                      
  return mt_entry == rootloc->mt_entry                                
    && (*mt_entry->ops->are_nodes_equal_h)( loc, rootloc );           
4000c4e0:	c2 00 60 10 	ld  [ %g1 + 0x10 ], %g1                        
4000c4e4:	9f c0 40 00 	call  %g1                                      
4000c4e8:	90 10 00 1b 	mov  %i3, %o0                                  
4000c4ec:	80 8a 20 ff 	btst  0xff, %o0                                
4000c4f0:	32 bf ff ee 	bne,a   4000c4a8 <rtems_filesystem_eval_path_generic+0x1a0>
4000c4f4:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1                           
4000c4f8:	10 bf ff d5 	b  4000c44c <rtems_filesystem_eval_path_generic+0x144>
4000c4fc:	c4 06 20 2c 	ld  [ %i0 + 0x2c ], %g2                        
                                                                      

4000c558 <rtems_filesystem_eval_path_next_token>: void rtems_filesystem_eval_path_eat_delimiter( rtems_filesystem_eval_path_context_t *ctx ) { const char *current = ctx->path;
4000c558:	c2 02 00 00 	ld  [ %o0 ], %g1                               
  const char *end = current + ctx->pathlen;                           
4000c55c:	c8 02 20 04 	ld  [ %o0 + 4 ], %g4                           
4000c560:	88 00 40 04 	add  %g1, %g4, %g4                             
                                                                      
  while (current != end && rtems_filesystem_is_delimiter(*current)) { 
4000c564:	80 a0 40 04 	cmp  %g1, %g4                                  
4000c568:	22 80 00 10 	be,a   4000c5a8 <rtems_filesystem_eval_path_next_token+0x50>
4000c56c:	88 21 00 01 	sub  %g4, %g1, %g4                             
4000c570:	c4 48 40 00 	ldsb  [ %g1 ], %g2                             
4000c574:	80 a0 a0 2f 	cmp  %g2, 0x2f                                 
4000c578:	22 80 00 08 	be,a   4000c598 <rtems_filesystem_eval_path_next_token+0x40>
4000c57c:	82 00 60 01 	inc  %g1                                       
4000c580:	10 80 00 38 	b  4000c660 <rtems_filesystem_eval_path_next_token+0x108>
4000c584:	80 a0 a0 5c 	cmp  %g2, 0x5c                                 
4000c588:	80 a0 a0 5c 	cmp  %g2, 0x5c                                 
4000c58c:	12 80 00 26 	bne  4000c624 <rtems_filesystem_eval_path_next_token+0xcc>
4000c590:	80 a0 a0 2f 	cmp  %g2, 0x2f                                 
    ++current;                                                        
4000c594:	82 00 60 01 	inc  %g1                                       
)                                                                     
{                                                                     
  const char *current = ctx->path;                                    
  const char *end = current + ctx->pathlen;                           
                                                                      
  while (current != end && rtems_filesystem_is_delimiter(*current)) { 
4000c598:	80 a1 00 01 	cmp  %g4, %g1                                  
4000c59c:	32 bf ff fb 	bne,a   4000c588 <rtems_filesystem_eval_path_next_token+0x30>
4000c5a0:	c4 48 40 00 	ldsb  [ %g1 ], %g2                             
    ++current;                                                        
  }                                                                   
                                                                      
  ctx->path = current;                                                
  ctx->pathlen = (size_t) (end - current);                            
4000c5a4:	88 21 00 01 	sub  %g4, %g1, %g4                             
                                                                      
  while (current != end && rtems_filesystem_is_delimiter(*current)) { 
    ++current;                                                        
  }                                                                   
                                                                      
  ctx->path = current;                                                
4000c5a8:	c2 22 00 00 	st  %g1, [ %o0 ]                               
  ctx->pathlen = (size_t) (end - current);                            
4000c5ac:	c8 22 20 04 	st  %g4, [ %o0 + 4 ]                           
}                                                                     
                                                                      
static void next_token(rtems_filesystem_eval_path_context_t *ctx)     
{                                                                     
  const char *begin = ctx->path;                                      
  const char *end = begin + ctx->pathlen;                             
4000c5b0:	88 00 40 04 	add  %g1, %g4, %g4                             
  const char *current = begin;                                        
                                                                      
  while (current != end && !rtems_filesystem_is_delimiter(*current)) {
4000c5b4:	80 a1 00 01 	cmp  %g4, %g1                                  
4000c5b8:	02 80 00 27 	be  4000c654 <rtems_filesystem_eval_path_next_token+0xfc>
4000c5bc:	9a 10 00 01 	mov  %g1, %o5                                  
4000c5c0:	c4 48 40 00 	ldsb  [ %g1 ], %g2                             
4000c5c4:	80 a0 a0 5c 	cmp  %g2, 0x5c                                 
4000c5c8:	02 80 00 23 	be  4000c654 <rtems_filesystem_eval_path_next_token+0xfc><== NEVER TAKEN
4000c5cc:	80 a0 a0 2f 	cmp  %g2, 0x2f                                 
4000c5d0:	02 80 00 22 	be  4000c658 <rtems_filesystem_eval_path_next_token+0x100><== NEVER TAKEN
4000c5d4:	84 10 00 01 	mov  %g1, %g2                                  
    ++current;                                                        
4000c5d8:	10 80 00 08 	b  4000c5f8 <rtems_filesystem_eval_path_next_token+0xa0>
4000c5dc:	84 00 a0 01 	inc  %g2                                       
{                                                                     
  const char *begin = ctx->path;                                      
  const char *end = begin + ctx->pathlen;                             
  const char *current = begin;                                        
                                                                      
  while (current != end && !rtems_filesystem_is_delimiter(*current)) {
4000c5e0:	80 a0 e0 5c 	cmp  %g3, 0x5c                                 
4000c5e4:	02 80 00 14 	be  4000c634 <rtems_filesystem_eval_path_next_token+0xdc>
4000c5e8:	80 a0 e0 2f 	cmp  %g3, 0x2f                                 
4000c5ec:	02 80 00 13 	be  4000c638 <rtems_filesystem_eval_path_next_token+0xe0>
4000c5f0:	9a 10 00 02 	mov  %g2, %o5                                  
    ++current;                                                        
4000c5f4:	84 00 a0 01 	inc  %g2                                       
{                                                                     
  const char *begin = ctx->path;                                      
  const char *end = begin + ctx->pathlen;                             
  const char *current = begin;                                        
                                                                      
  while (current != end && !rtems_filesystem_is_delimiter(*current)) {
4000c5f8:	80 a1 00 02 	cmp  %g4, %g2                                  
4000c5fc:	32 bf ff f9 	bne,a   4000c5e0 <rtems_filesystem_eval_path_next_token+0x88>
4000c600:	c6 48 80 00 	ldsb  [ %g2 ], %g3                             
4000c604:	9a 10 00 04 	mov  %g4, %o5                                  
4000c608:	86 21 00 01 	sub  %g4, %g1, %g3                             
    ++current;                                                        
  }                                                                   
                                                                      
  ctx->path = current;                                                
  ctx->pathlen = (size_t) (end - current);                            
4000c60c:	88 21 00 0d 	sub  %g4, %o5, %g4                             
                                                                      
  while (current != end && !rtems_filesystem_is_delimiter(*current)) {
    ++current;                                                        
  }                                                                   
                                                                      
  ctx->path = current;                                                
4000c610:	c4 22 00 00 	st  %g2, [ %o0 ]                               
  ctx->pathlen = (size_t) (end - current);                            
4000c614:	c8 22 20 04 	st  %g4, [ %o0 + 4 ]                           
  ctx->token = begin;                                                 
4000c618:	c2 22 20 08 	st  %g1, [ %o0 + 8 ]                           
  ctx->tokenlen = (size_t) (current - begin);                         
4000c61c:	81 c3 e0 08 	retl                                           
4000c620:	c6 22 20 0c 	st  %g3, [ %o0 + 0xc ]                         
)                                                                     
{                                                                     
  const char *current = ctx->path;                                    
  const char *end = current + ctx->pathlen;                           
                                                                      
  while (current != end && rtems_filesystem_is_delimiter(*current)) { 
4000c624:	22 bf ff dd 	be,a   4000c598 <rtems_filesystem_eval_path_next_token+0x40>
4000c628:	82 00 60 01 	inc  %g1                                       
    ++current;                                                        
  }                                                                   
                                                                      
  ctx->path = current;                                                
  ctx->pathlen = (size_t) (end - current);                            
4000c62c:	10 bf ff df 	b  4000c5a8 <rtems_filesystem_eval_path_next_token+0x50>
4000c630:	88 21 00 01 	sub  %g4, %g1, %g4                             
4000c634:	9a 10 00 02 	mov  %g2, %o5                                  
4000c638:	86 20 80 01 	sub  %g2, %g1, %g3                             
  while (current != end && !rtems_filesystem_is_delimiter(*current)) {
    ++current;                                                        
  }                                                                   
                                                                      
  ctx->path = current;                                                
  ctx->pathlen = (size_t) (end - current);                            
4000c63c:	88 21 00 0d 	sub  %g4, %o5, %g4                             
                                                                      
  while (current != end && !rtems_filesystem_is_delimiter(*current)) {
    ++current;                                                        
  }                                                                   
                                                                      
  ctx->path = current;                                                
4000c640:	c4 22 00 00 	st  %g2, [ %o0 ]                               
  ctx->pathlen = (size_t) (end - current);                            
4000c644:	c8 22 20 04 	st  %g4, [ %o0 + 4 ]                           
  ctx->token = begin;                                                 
4000c648:	c2 22 20 08 	st  %g1, [ %o0 + 8 ]                           
  ctx->tokenlen = (size_t) (current - begin);                         
4000c64c:	81 c3 e0 08 	retl                                           
4000c650:	c6 22 20 0c 	st  %g3, [ %o0 + 0xc ]                         
{                                                                     
  const char *begin = ctx->path;                                      
  const char *end = begin + ctx->pathlen;                             
  const char *current = begin;                                        
                                                                      
  while (current != end && !rtems_filesystem_is_delimiter(*current)) {
4000c654:	84 10 00 01 	mov  %g1, %g2                                  
4000c658:	10 bf ff ed 	b  4000c60c <rtems_filesystem_eval_path_next_token+0xb4>
4000c65c:	86 10 20 00 	clr  %g3                                       
)                                                                     
{                                                                     
  const char *current = ctx->path;                                    
  const char *end = current + ctx->pathlen;                           
                                                                      
  while (current != end && rtems_filesystem_is_delimiter(*current)) { 
4000c660:	22 bf ff ce 	be,a   4000c598 <rtems_filesystem_eval_path_next_token+0x40>
4000c664:	82 00 60 01 	inc  %g1                                       
    ++current;                                                        
  }                                                                   
                                                                      
  ctx->path = current;                                                
  ctx->pathlen = (size_t) (end - current);                            
4000c668:	10 bf ff d0 	b  4000c5a8 <rtems_filesystem_eval_path_next_token+0x50>
4000c66c:	88 21 00 01 	sub  %g4, %g1, %g4                             
                                                                      

4000442c <rtems_filesystem_eval_path_recursive>: void rtems_filesystem_eval_path_recursive( rtems_filesystem_eval_path_context_t *ctx, const char *path, size_t pathlen ) {
4000442c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if (pathlen > 0) {                                                  
40004430:	80 a6 a0 00 	cmp  %i2, 0                                    
40004434:	02 80 00 22 	be  400044bc <rtems_filesystem_eval_path_recursive+0x90><== NEVER TAKEN
40004438:	ba 10 00 18 	mov  %i0, %i5                                  
    if (ctx->recursionlevel < RTEMS_FILESYSTEM_SYMLOOP_MAX) {         
4000443c:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
40004440:	80 a0 60 1f 	cmp  %g1, 0x1f                                 
40004444:	14 80 00 25 	bg  400044d8 <rtems_filesystem_eval_path_recursive+0xac>
40004448:	01 00 00 00 	nop                                            
  gid_t node_gid                                                      
);                                                                    
                                                                      
static inline bool rtems_filesystem_is_delimiter(char c)              
{                                                                     
  return c == '/' || c == '\\';                                       
4000444c:	c4 4e 40 00 	ldsb  [ %i1 ], %g2                             
      const char *saved_path = ctx->path;                             
40004450:	f6 06 00 00 	ld  [ %i0 ], %i3                               
      size_t saved_pathlen = ctx->pathlen;                            
                                                                      
      if (rtems_filesystem_is_delimiter(path [0])) {                  
40004454:	80 a0 a0 5c 	cmp  %g2, 0x5c                                 
40004458:	02 80 00 1b 	be  400044c4 <rtems_filesystem_eval_path_recursive+0x98><== NEVER TAKEN
4000445c:	f8 06 20 04 	ld  [ %i0 + 4 ], %i4                           
40004460:	80 a0 a0 2f 	cmp  %g2, 0x2f                                 
40004464:	02 80 00 19 	be  400044c8 <rtems_filesystem_eval_path_recursive+0x9c>
40004468:	90 10 00 1d 	mov  %i5, %o0                                  
      }                                                               
                                                                      
      ctx->path = path;                                               
      ctx->pathlen = pathlen;                                         
                                                                      
      ++ctx->recursionlevel;                                          
4000446c:	82 00 60 01 	inc  %g1                                       
                                                                      
      if (rtems_filesystem_is_delimiter(path [0])) {                  
        rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc);       
      }                                                               
                                                                      
      ctx->path = path;                                               
40004470:	f2 27 40 00 	st  %i1, [ %i5 ]                               
      ctx->pathlen = pathlen;                                         
40004474:	f4 27 60 04 	st  %i2, [ %i5 + 4 ]                           
                                                                      
      ++ctx->recursionlevel;                                          
40004478:	c2 27 60 14 	st  %g1, [ %i5 + 0x14 ]                        
      while (ctx->pathlen > 0) {                                      
        (*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);           
4000447c:	c2 07 60 2c 	ld  [ %i5 + 0x2c ], %g1                        
40004480:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
40004484:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
40004488:	9f c0 40 00 	call  %g1                                      
4000448c:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
      ctx->path = path;                                               
      ctx->pathlen = pathlen;                                         
                                                                      
      ++ctx->recursionlevel;                                          
      while (ctx->pathlen > 0) {                                      
40004490:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
40004494:	80 a0 60 00 	cmp  %g1, 0                                    
40004498:	32 bf ff fa 	bne,a   40004480 <rtems_filesystem_eval_path_recursive+0x54>
4000449c:	c2 07 60 2c 	ld  [ %i5 + 0x2c ], %g1                        
        (*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);           
      }                                                               
      --ctx->recursionlevel;                                          
400044a0:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
                                                                      
      ctx->path = saved_path;                                         
400044a4:	f6 27 40 00 	st  %i3, [ %i5 ]                               
                                                                      
      ++ctx->recursionlevel;                                          
      while (ctx->pathlen > 0) {                                      
        (*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);           
      }                                                               
      --ctx->recursionlevel;                                          
400044a8:	82 00 7f ff 	add  %g1, -1, %g1                              
                                                                      
      ctx->path = saved_path;                                         
      ctx->pathlen = saved_pathlen;                                   
400044ac:	f8 27 60 04 	st  %i4, [ %i5 + 4 ]                           
                                                                      
      ++ctx->recursionlevel;                                          
      while (ctx->pathlen > 0) {                                      
        (*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);           
      }                                                               
      --ctx->recursionlevel;                                          
400044b0:	c2 27 60 14 	st  %g1, [ %i5 + 0x14 ]                        
400044b4:	81 c7 e0 08 	ret                                            
400044b8:	81 e8 00 00 	restore                                        
      ctx->pathlen = saved_pathlen;                                   
    } else {                                                          
      rtems_filesystem_eval_path_error(ctx, ELOOP);                   
    }                                                                 
  } else {                                                            
    rtems_filesystem_eval_path_error(ctx, ENOENT);                    
400044bc:	7f ff fe b4 	call  40003f8c <rtems_filesystem_eval_path_error><== NOT EXECUTED
400044c0:	93 e8 20 02 	restore  %g0, 2, %o1                           <== NOT EXECUTED
    if (ctx->recursionlevel < RTEMS_FILESYSTEM_SYMLOOP_MAX) {         
      const char *saved_path = ctx->path;                             
      size_t saved_pathlen = ctx->pathlen;                            
                                                                      
      if (rtems_filesystem_is_delimiter(path [0])) {                  
        rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc);       
400044c4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
400044c8:	7f ff ff c0 	call  400043c8 <rtems_filesystem_eval_path_restart>
400044cc:	92 07 60 30 	add  %i5, 0x30, %o1                            
400044d0:	10 bf ff e7 	b  4000446c <rtems_filesystem_eval_path_recursive+0x40>
400044d4:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
      --ctx->recursionlevel;                                          
                                                                      
      ctx->path = saved_path;                                         
      ctx->pathlen = saved_pathlen;                                   
    } else {                                                          
      rtems_filesystem_eval_path_error(ctx, ELOOP);                   
400044d8:	7f ff fe ad 	call  40003f8c <rtems_filesystem_eval_path_error>
400044dc:	93 e8 20 5c 	restore  %g0, 0x5c, %o1                        
                                                                      

40004294 <rtems_filesystem_eval_path_start_with_parent>: const char *path, int eval_flags, rtems_filesystem_location_info_t *parentloc, int parent_eval_flags ) {
40004294:	9d e3 bf a0 	save  %sp, -96, %sp                            
  size_t pathlen = strlen(path);                                      
40004298:	40 00 32 8f 	call  40010cd4 <strlen>                        
4000429c:	90 10 00 19 	mov  %i1, %o0                                  
                                                                      
#include <rtems/libio_.h>                                             
                                                                      
static size_t get_parentpathlen(const char *path, size_t pathlen)     
{                                                                     
  while (pathlen > 0) {                                               
400042a0:	80 a2 20 00 	cmp  %o0, 0                                    
400042a4:	02 80 00 32 	be  4000436c <rtems_filesystem_eval_path_start_with_parent+0xd8>
400042a8:	92 10 00 19 	mov  %i1, %o1                                  
    size_t i = pathlen - 1;                                           
400042ac:	94 02 3f ff 	add  %o0, -1, %o2                              
  gid_t node_gid                                                      
);                                                                    
                                                                      
static inline bool rtems_filesystem_is_delimiter(char c)              
{                                                                     
  return c == '/' || c == '\\';                                       
400042b0:	c2 4e 40 0a 	ldsb  [ %i1 + %o2 ], %g1                       
                                                                      
    if (rtems_filesystem_is_delimiter(path [i])) {                    
400042b4:	80 a0 60 5c 	cmp  %g1, 0x5c                                 
400042b8:	02 80 00 2a 	be  40004360 <rtems_filesystem_eval_path_start_with_parent+0xcc><== NEVER TAKEN
400042bc:	80 a0 60 2f 	cmp  %g1, 0x2f                                 
400042c0:	12 80 00 08 	bne  400042e0 <rtems_filesystem_eval_path_start_with_parent+0x4c>
400042c4:	80 a2 a0 00 	cmp  %o2, 0                                    
400042c8:	10 80 00 27 	b  40004364 <rtems_filesystem_eval_path_start_with_parent+0xd0>
400042cc:	94 10 00 08 	mov  %o0, %o2                                  
400042d0:	02 80 00 0b 	be  400042fc <rtems_filesystem_eval_path_start_with_parent+0x68>
400042d4:	a0 22 00 0a 	sub  %o0, %o2, %l0                             
#include <rtems/libio_.h>                                             
                                                                      
static size_t get_parentpathlen(const char *path, size_t pathlen)     
{                                                                     
  while (pathlen > 0) {                                               
    size_t i = pathlen - 1;                                           
400042d8:	94 10 00 01 	mov  %g1, %o2                                  
                                                                      
#include <rtems/libio_.h>                                             
                                                                      
static size_t get_parentpathlen(const char *path, size_t pathlen)     
{                                                                     
  while (pathlen > 0) {                                               
400042dc:	80 a2 a0 00 	cmp  %o2, 0                                    
400042e0:	02 80 00 1a 	be  40004348 <rtems_filesystem_eval_path_start_with_parent+0xb4>
400042e4:	82 02 bf ff 	add  %o2, -1, %g1                              
400042e8:	c4 4e 40 01 	ldsb  [ %i1 + %g1 ], %g2                       
    size_t i = pathlen - 1;                                           
                                                                      
    if (rtems_filesystem_is_delimiter(path [i])) {                    
400042ec:	80 a0 a0 5c 	cmp  %g2, 0x5c                                 
400042f0:	12 bf ff f8 	bne  400042d0 <rtems_filesystem_eval_path_start_with_parent+0x3c><== ALWAYS TAKEN
400042f4:	80 a0 a0 2f 	cmp  %g2, 0x2f                                 
400042f8:	a0 22 00 0a 	sub  %o0, %o2, %l0                             <== NOT EXECUTED
      parentpath = ".";                                               
      parentpathlen = 1;                                              
      name = path;                                                    
      namelen = pathlen;                                              
    } else {                                                          
      name = path + parentpathlen;                                    
400042fc:	ba 06 40 0a 	add  %i1, %o2, %i5                             
  rtems_filesystem_location_info_t *parentloc,                        
  int parent_eval_flags                                               
)                                                                     
{                                                                     
  size_t pathlen = strlen(path);                                      
  const char *parentpath = path;                                      
40004300:	92 10 00 19 	mov  %i1, %o1                                  
  currentloc = eval_path_start(                                       
    ctx,                                                              
    parentpath,                                                       
    parentpathlen,                                                    
    parent_eval_flags,                                                
    &rtems_filesystem_root,                                           
40004304:	03 10 00 78 	sethi  %hi(0x4001e000), %g1                    
40004308:	da 00 63 ec 	ld  [ %g1 + 0x3ec ], %o5	! 4001e3ec <rtems_current_user_env>
      name = path + parentpathlen;                                    
      namelen = pathlen - parentpathlen;                              
    }                                                                 
  }                                                                   
                                                                      
  currentloc = eval_path_start(                                       
4000430c:	96 10 00 1c 	mov  %i4, %o3                                  
40004310:	98 03 60 04 	add  %o5, 4, %o4                               
40004314:	7f ff ff 7a 	call  400040fc <eval_path_start>               
40004318:	90 10 00 18 	mov  %i0, %o0                                  
4000431c:	92 10 00 08 	mov  %o0, %o1                                  
    parent_eval_flags,                                                
    &rtems_filesystem_root,                                           
    &rtems_filesystem_current                                         
  );                                                                  
                                                                      
  rtems_filesystem_location_clone(parentloc, currentloc);             
40004320:	40 00 1e 7a 	call  4000bd08 <rtems_filesystem_location_clone>
40004324:	90 10 00 1b 	mov  %i3, %o0                                  
                                                                      
  ctx->path = name;                                                   
  ctx->pathlen = namelen;                                             
  ctx->flags = eval_flags;                                            
                                                                      
  rtems_filesystem_eval_path_continue(ctx);                           
40004328:	90 10 00 18 	mov  %i0, %o0                                  
    &rtems_filesystem_current                                         
  );                                                                  
                                                                      
  rtems_filesystem_location_clone(parentloc, currentloc);             
                                                                      
  ctx->path = name;                                                   
4000432c:	fa 26 00 00 	st  %i5, [ %i0 ]                               
  ctx->pathlen = namelen;                                             
40004330:	e0 26 20 04 	st  %l0, [ %i0 + 4 ]                           
  ctx->flags = eval_flags;                                            
40004334:	f4 26 20 10 	st  %i2, [ %i0 + 0x10 ]                        
                                                                      
  rtems_filesystem_eval_path_continue(ctx);                           
40004338:	7f ff ff 54 	call  40004088 <rtems_filesystem_eval_path_continue>
4000433c:	b0 06 20 18 	add  %i0, 0x18, %i0                            
40004340:	81 c7 e0 08 	ret                                            
40004344:	81 e8 00 00 	restore                                        
  size_t namelen = 0;                                                 
  const rtems_filesystem_location_info_t *currentloc = NULL;          
                                                                      
  if (pathlen > 0) {                                                  
    if (parentpathlen == 0) {                                         
      parentpath = ".";                                               
40004348:	13 10 00 73 	sethi  %hi(0x4001cc00), %o1                    
                                                                      
#include <rtems/libio_.h>                                             
                                                                      
static size_t get_parentpathlen(const char *path, size_t pathlen)     
{                                                                     
  while (pathlen > 0) {                                               
4000434c:	a0 10 00 08 	mov  %o0, %l0                                  
                                                                      
  if (pathlen > 0) {                                                  
    if (parentpathlen == 0) {                                         
      parentpath = ".";                                               
      parentpathlen = 1;                                              
      name = path;                                                    
40004350:	ba 10 00 19 	mov  %i1, %i5                                  
  const rtems_filesystem_location_info_t *currentloc = NULL;          
                                                                      
  if (pathlen > 0) {                                                  
    if (parentpathlen == 0) {                                         
      parentpath = ".";                                               
      parentpathlen = 1;                                              
40004354:	94 10 20 01 	mov  1, %o2                                    
  size_t namelen = 0;                                                 
  const rtems_filesystem_location_info_t *currentloc = NULL;          
                                                                      
  if (pathlen > 0) {                                                  
    if (parentpathlen == 0) {                                         
      parentpath = ".";                                               
40004358:	10 bf ff eb 	b  40004304 <rtems_filesystem_eval_path_start_with_parent+0x70>
4000435c:	92 12 63 38 	or  %o1, 0x338, %o1                            
static size_t get_parentpathlen(const char *path, size_t pathlen)     
{                                                                     
  while (pathlen > 0) {                                               
    size_t i = pathlen - 1;                                           
                                                                      
    if (rtems_filesystem_is_delimiter(path [i])) {                    
40004360:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40004364:	10 bf ff e6 	b  400042fc <rtems_filesystem_eval_path_start_with_parent+0x68>
40004368:	a0 10 20 00 	clr  %l0                                       
{                                                                     
  size_t pathlen = strlen(path);                                      
  const char *parentpath = path;                                      
  size_t parentpathlen = get_parentpathlen(path, pathlen);            
  const char *name = NULL;                                            
  size_t namelen = 0;                                                 
4000436c:	a0 10 20 00 	clr  %l0                                       
)                                                                     
{                                                                     
  size_t pathlen = strlen(path);                                      
  const char *parentpath = path;                                      
  size_t parentpathlen = get_parentpathlen(path, pathlen);            
  const char *name = NULL;                                            
40004370:	ba 10 20 00 	clr  %i5                                       
    }                                                                 
                                                                      
    pathlen = i;                                                      
  }                                                                   
                                                                      
  return 0;                                                           
40004374:	10 bf ff e4 	b  40004304 <rtems_filesystem_eval_path_start_with_parent+0x70>
40004378:	94 10 20 00 	clr  %o2                                       
                                                                      

4000c06c <rtems_filesystem_get_mount_handler>: rtems_filesystem_fsmount_me_t rtems_filesystem_get_mount_handler( const char *type ) {
4000c06c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  find_arg fa = {                                                     
4000c070:	f0 27 bf f8 	st  %i0, [ %fp + -8 ]                          
4000c074:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
                                                                      
rtems_filesystem_fsmount_me_t                                         
rtems_filesystem_get_mount_handler(                                   
  const char *type                                                    
)                                                                     
{                                                                     
4000c078:	82 10 00 18 	mov  %i0, %g1                                  
  find_arg fa = {                                                     
    .type = type,                                                     
    .mount_h = NULL                                                   
  };                                                                  
                                                                      
  if ( type != NULL ) {                                               
4000c07c:	80 a0 60 00 	cmp  %g1, 0                                    
4000c080:	02 80 00 07 	be  4000c09c <rtems_filesystem_get_mount_handler+0x30><== NEVER TAKEN
4000c084:	b0 10 20 00 	clr  %i0                                       
    rtems_filesystem_iterate( find_handler, &fa );                    
4000c088:	92 07 bf f8 	add  %fp, -8, %o1                              
4000c08c:	11 10 00 2f 	sethi  %hi(0x4000bc00), %o0                    
4000c090:	7f ff ff c9 	call  4000bfb4 <rtems_filesystem_iterate>      
4000c094:	90 12 23 80 	or  %o0, 0x380, %o0	! 4000bf80 <find_handler>  
4000c098:	f0 07 bf fc 	ld  [ %fp + -4 ], %i0                          
  }                                                                   
                                                                      
  return fa.mount_h;                                                  
}                                                                     
4000c09c:	81 c7 e0 08 	ret                                            
4000c0a0:	81 e8 00 00 	restore                                        
                                                                      

400047b4 <rtems_filesystem_global_location_obtain>: } rtems_filesystem_global_location_t *rtems_filesystem_global_location_obtain( rtems_filesystem_global_location_t *const *global_loc_ptr ) {
400047b4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_filesystem_mt_entry_declare_lock_context(lock_context);       
  rtems_filesystem_global_location_t *global_loc;                     
                                                                      
  if (deferred_released_global_locations != NULL) {                   
400047b8:	37 10 00 7a 	sethi  %hi(0x4001e800), %i3                    
400047bc:	c2 06 e2 a8 	ld  [ %i3 + 0x2a8 ], %g1	! 4001eaa8 <deferred_released_global_locations>
400047c0:	80 a0 60 00 	cmp  %g1, 0                                    
400047c4:	02 80 00 1e 	be  4000483c <rtems_filesystem_global_location_obtain+0x88>
400047c8:	01 00 00 00 	nop                                            
   *                                                                  
   * This rountine increments the thread dispatch level               
   */                                                                 
  RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
  {                                                                   
    uint32_t level = _Thread_Dispatch_disable_level;                  
400047cc:	39 10 00 7b 	sethi  %hi(0x4001ec00), %i4                    
400047d0:	c2 07 22 c0 	ld  [ %i4 + 0x2c0 ], %g1	! 4001eec0 <_Thread_Dispatch_disable_level>
                                                                      
    ++level;                                                          
400047d4:	82 00 60 01 	inc  %g1                                       
    _Thread_Dispatch_disable_level = level;                           
400047d8:	c2 27 22 c0 	st  %g1, [ %i4 + 0x2c0 ]                       
                                                                      
  do {                                                                
    int count = 0;                                                    
                                                                      
    _Thread_Disable_dispatch();                                       
    current = deferred_released_global_locations;                     
400047dc:	fa 06 e2 a8 	ld  [ %i3 + 0x2a8 ], %i5                       
    if (current != NULL) {                                            
400047e0:	80 a7 60 00 	cmp  %i5, 0                                    
400047e4:	02 80 00 14 	be  40004834 <rtems_filesystem_global_location_obtain+0x80><== NEVER TAKEN
400047e8:	01 00 00 00 	nop                                            
400047ec:	b6 16 e2 a8 	or  %i3, 0x2a8, %i3                            
400047f0:	b8 17 22 c0 	or  %i4, 0x2c0, %i4                            
      deferred_released_global_locations = current->deferred_released_next;
400047f4:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
      count = current->deferred_released_count;                       
400047f8:	f4 07 60 20 	ld  [ %i5 + 0x20 ], %i2                        
    int count = 0;                                                    
                                                                      
    _Thread_Disable_dispatch();                                       
    current = deferred_released_global_locations;                     
    if (current != NULL) {                                            
      deferred_released_global_locations = current->deferred_released_next;
400047fc:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
      count = current->deferred_released_count;                       
      current->deferred_released_next = NULL;                         
40004800:	c0 27 60 1c 	clr  [ %i5 + 0x1c ]                            
      current->deferred_released_count = 0;                           
    }                                                                 
    _Thread_Enable_dispatch();                                        
40004804:	40 00 15 b1 	call  40009ec8 <_Thread_Enable_dispatch>       
40004808:	c0 27 60 20 	clr  [ %i5 + 0x20 ]                            
                                                                      
    if (current != NULL) {                                            
      release_with_count(current, count);                             
4000480c:	90 10 00 1d 	mov  %i5, %o0                                  
40004810:	7f ff ff 9e 	call  40004688 <release_with_count>            
40004814:	92 10 00 1a 	mov  %i2, %o1                                  
   *                                                                  
   * This rountine increments the thread dispatch level               
   */                                                                 
  RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
  {                                                                   
    uint32_t level = _Thread_Dispatch_disable_level;                  
40004818:	c2 07 00 00 	ld  [ %i4 ], %g1                               
                                                                      
    ++level;                                                          
4000481c:	82 00 60 01 	inc  %g1                                       
    _Thread_Dispatch_disable_level = level;                           
40004820:	c2 27 00 00 	st  %g1, [ %i4 ]                               
                                                                      
  do {                                                                
    int count = 0;                                                    
                                                                      
    _Thread_Disable_dispatch();                                       
    current = deferred_released_global_locations;                     
40004824:	fa 06 c0 00 	ld  [ %i3 ], %i5                               
    if (current != NULL) {                                            
40004828:	80 a7 60 00 	cmp  %i5, 0                                    
4000482c:	32 bf ff f3 	bne,a   400047f8 <rtems_filesystem_global_location_obtain+0x44><== NEVER TAKEN
40004830:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        <== NOT EXECUTED
      deferred_released_global_locations = current->deferred_released_next;
      count = current->deferred_released_count;                       
      current->deferred_released_next = NULL;                         
      current->deferred_released_count = 0;                           
    }                                                                 
    _Thread_Enable_dispatch();                                        
40004834:	40 00 15 a5 	call  40009ec8 <_Thread_Enable_dispatch>       
40004838:	01 00 00 00 	nop                                            
                                                                      
  if (deferred_released_global_locations != NULL) {                   
    deferred_release();                                               
  }                                                                   
                                                                      
  rtems_filesystem_mt_entry_lock(lock_context);                       
4000483c:	7f ff f6 1a 	call  400020a4 <sparc_disable_interrupts>      
40004840:	01 00 00 00 	nop                                            
40004844:	ba 10 00 08 	mov  %o0, %i5                                  
  global_loc = *global_loc_ptr;                                       
40004848:	f0 06 00 00 	ld  [ %i0 ], %i0                               
  if (global_loc == NULL || !global_loc->location.mt_entry->mounted) {
4000484c:	80 a6 20 00 	cmp  %i0, 0                                    
40004850:	02 80 00 07 	be  4000486c <rtems_filesystem_global_location_obtain+0xb8>
40004854:	01 00 00 00 	nop                                            
40004858:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
4000485c:	c2 08 60 28 	ldub  [ %g1 + 0x28 ], %g1                      
40004860:	80 a0 60 00 	cmp  %g1, 0                                    
40004864:	32 80 00 08 	bne,a   40004884 <rtems_filesystem_global_location_obtain+0xd0>
40004868:	c2 06 20 18 	ld  [ %i0 + 0x18 ], %g1                        
    global_loc = &rtems_filesystem_global_location_null;              
    errno = ENXIO;                                                    
4000486c:	40 00 2b b5 	call  4000f740 <__errno>                       
40004870:	31 10 00 79 	sethi  %hi(0x4001e400), %i0                    
40004874:	82 10 20 06 	mov  6, %g1                                    
40004878:	c2 22 00 00 	st  %g1, [ %o0 ]                               
  }                                                                   
                                                                      
  rtems_filesystem_mt_entry_lock(lock_context);                       
  global_loc = *global_loc_ptr;                                       
  if (global_loc == NULL || !global_loc->location.mt_entry->mounted) {
    global_loc = &rtems_filesystem_global_location_null;              
4000487c:	b0 16 20 1c 	or  %i0, 0x1c, %i0                             
    errno = ENXIO;                                                    
  }                                                                   
  ++global_loc->reference_count;                                      
40004880:	c2 06 20 18 	ld  [ %i0 + 0x18 ], %g1                        
40004884:	82 00 60 01 	inc  %g1                                       
40004888:	c2 26 20 18 	st  %g1, [ %i0 + 0x18 ]                        
  rtems_filesystem_mt_entry_unlock(lock_context);                     
4000488c:	7f ff f6 0a 	call  400020b4 <sparc_enable_interrupts>       
40004890:	90 10 00 1d 	mov  %i5, %o0                                  
40004894:	81 c7 e0 08 	ret                                            
40004898:	81 e8 00 00 	restore                                        
                                                                      

40002d04 <rtems_filesystem_initialize>: /* * Default mode for created files. */ void rtems_filesystem_initialize( void ) {
40002d04:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rv = 0;                                                         
  const rtems_filesystem_mount_configuration *root_config =           
    &rtems_filesystem_root_configuration;                             
                                                                      
  rv = mount(                                                         
40002d08:	05 10 00 71 	sethi  %hi(0x4001c400), %g2                    
40002d0c:	82 10 a0 64 	or  %g2, 0x64, %g1	! 4001c464 <rtems_filesystem_root_configuration>
40002d10:	d0 00 a0 64 	ld  [ %g2 + 0x64 ], %o0                        
40002d14:	d2 00 60 04 	ld  [ %g1 + 4 ], %o1                           
40002d18:	d4 00 60 08 	ld  [ %g1 + 8 ], %o2                           
40002d1c:	d6 00 60 0c 	ld  [ %g1 + 0xc ], %o3                         
40002d20:	40 00 02 22 	call  400035a8 <mount>                         
40002d24:	d8 00 60 10 	ld  [ %g1 + 0x10 ], %o4                        
    root_config->target,                                              
    root_config->filesystemtype,                                      
    root_config->options,                                             
    root_config->data                                                 
  );                                                                  
  if ( rv != 0 )                                                      
40002d28:	80 a2 20 00 	cmp  %o0, 0                                    
40002d2c:	12 80 00 0a 	bne  40002d54 <rtems_filesystem_initialize+0x50><== NEVER TAKEN
40002d30:	92 10 21 ff 	mov  0x1ff, %o1                                
   *                                                                  
   *  NOTE: UNIX root is 755 and owned by root/root (0/0).  It is actually
   *        created that way by the IMFS.                             
   */                                                                 
                                                                      
  rv = mkdir( "/dev", 0777);                                          
40002d34:	11 10 00 72 	sethi  %hi(0x4001c800), %o0                    
40002d38:	40 00 01 d3 	call  40003484 <mkdir>                         
40002d3c:	90 12 21 c8 	or  %o0, 0x1c8, %o0	! 4001c9c8 <IMFS_node_control_default+0x58>
  if ( rv != 0 )                                                      
40002d40:	80 a2 20 00 	cmp  %o0, 0                                    
40002d44:	12 80 00 07 	bne  40002d60 <rtems_filesystem_initialize+0x5c><== NEVER TAKEN
40002d48:	11 2a f3 40 	sethi  %hi(0xabcd0000), %o0                    
40002d4c:	81 c7 e0 08 	ret                                            
40002d50:	81 e8 00 00 	restore                                        
    root_config->filesystemtype,                                      
    root_config->options,                                             
    root_config->data                                                 
  );                                                                  
  if ( rv != 0 )                                                      
    rtems_fatal_error_occurred( 0xABCD0002 );                         
40002d54:	11 2a f3 40 	sethi  %hi(0xabcd0000), %o0                    <== NOT EXECUTED
40002d58:	40 00 13 72 	call  40007b20 <rtems_fatal_error_occurred>    <== NOT EXECUTED
40002d5c:	90 12 20 02 	or  %o0, 2, %o0	! abcd0002 <LEON_REG+0x2bcd0002><== NOT EXECUTED
   *        created that way by the IMFS.                             
   */                                                                 
                                                                      
  rv = mkdir( "/dev", 0777);                                          
  if ( rv != 0 )                                                      
    rtems_fatal_error_occurred( 0xABCD0003 );                         
40002d60:	40 00 13 70 	call  40007b20 <rtems_fatal_error_occurred>    <== NOT EXECUTED
40002d64:	90 12 20 03 	or  %o0, 3, %o0                                <== NOT EXECUTED
                                                                      

4000bfb4 <rtems_filesystem_iterate>: bool rtems_filesystem_iterate( rtems_per_filesystem_routine routine, void *routine_arg ) {
4000bfb4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
  rtems_chain_node *node = NULL;                                      
  bool stop = false;                                                  
                                                                      
  while ( table_entry->type && !stop ) {                              
4000bfb8:	3b 10 00 71 	sethi  %hi(0x4001c400), %i5                    
4000bfbc:	c2 07 60 78 	ld  [ %i5 + 0x78 ], %g1	! 4001c478 <rtems_filesystem_table>
4000bfc0:	80 a0 60 00 	cmp  %g1, 0                                    
4000bfc4:	12 80 00 06 	bne  4000bfdc <rtems_filesystem_iterate+0x28>  <== ALWAYS TAKEN
4000bfc8:	ba 17 60 78 	or  %i5, 0x78, %i5                             
 */                                                                   
#include <rtems/userenv.h>                                            
                                                                      
static inline void rtems_libio_lock( void )                           
{                                                                     
  rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
4000bfcc:	10 80 00 0e 	b  4000c004 <rtems_filesystem_iterate+0x50>    <== NOT EXECUTED
4000bfd0:	35 10 00 7b 	sethi  %hi(0x4001ec00), %i2                    <== NOT EXECUTED
4000bfd4:	12 80 00 24 	bne  4000c064 <rtems_filesystem_iterate+0xb0>  
4000bfd8:	01 00 00 00 	nop                                            
    stop = (*routine)( table_entry, routine_arg );                    
4000bfdc:	90 10 00 1d 	mov  %i5, %o0                                  
4000bfe0:	9f c6 00 00 	call  %i0                                      
4000bfe4:	92 10 00 19 	mov  %i1, %o1                                  
    ++table_entry;                                                    
4000bfe8:	ba 07 60 08 	add  %i5, 8, %i5                               
{                                                                     
  const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
  rtems_chain_node *node = NULL;                                      
  bool stop = false;                                                  
                                                                      
  while ( table_entry->type && !stop ) {                              
4000bfec:	c2 07 40 00 	ld  [ %i5 ], %g1                               
4000bff0:	80 a0 60 00 	cmp  %g1, 0                                    
4000bff4:	12 bf ff f8 	bne  4000bfd4 <rtems_filesystem_iterate+0x20>  
4000bff8:	b8 8a 20 ff 	andcc  %o0, 0xff, %i4                          
    stop = (*routine)( table_entry, routine_arg );                    
    ++table_entry;                                                    
  }                                                                   
                                                                      
  if ( !stop ) {                                                      
4000bffc:	12 80 00 1a 	bne  4000c064 <rtems_filesystem_iterate+0xb0>  
4000c000:	35 10 00 7b 	sethi  %hi(0x4001ec00), %i2                    
4000c004:	d0 06 a1 38 	ld  [ %i2 + 0x138 ], %o0	! 4001ed38 <rtems_libio_semaphore>
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return _Chain_Head( the_chain )->next;                              
4000c008:	37 10 00 79 	sethi  %hi(0x4001e400), %i3                    
4000c00c:	92 10 20 00 	clr  %o1                                       
4000c010:	7f ff ec df 	call  4000738c <rtems_semaphore_obtain>        
4000c014:	94 10 20 00 	clr  %o2                                       
4000c018:	fa 06 e0 9c 	ld  [ %i3 + 0x9c ], %i5                        
4000c01c:	b6 16 e0 9c 	or  %i3, 0x9c, %i3                             
    rtems_libio_lock();                                               
    for (                                                             
4000c020:	b6 06 e0 04 	add  %i3, 4, %i3                               
4000c024:	80 a7 40 1b 	cmp  %i5, %i3                                  
4000c028:	12 80 00 05 	bne  4000c03c <rtems_filesystem_iterate+0x88>  
4000c02c:	b8 10 20 00 	clr  %i4                                       
4000c030:	30 80 00 0b 	b,a   4000c05c <rtems_filesystem_iterate+0xa8> 
      node = rtems_chain_first( &filesystem_chain );                  
      !rtems_chain_is_tail( &filesystem_chain, node ) && !stop;       
4000c034:	12 80 00 0a 	bne  4000c05c <rtems_filesystem_iterate+0xa8>  <== NEVER TAKEN
4000c038:	01 00 00 00 	nop                                            
      node = rtems_chain_next( node )                                 
    ) {                                                               
      const filesystem_node *fsn = (filesystem_node *) node;          
                                                                      
      stop = (*routine)( &fsn->entry, routine_arg );                  
4000c03c:	90 07 60 08 	add  %i5, 8, %o0                               
4000c040:	9f c6 00 00 	call  %i0                                      
4000c044:	92 10 00 19 	mov  %i1, %o1                                  
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(                         
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  return the_node->next;                                              
4000c048:	fa 07 40 00 	ld  [ %i5 ], %i5                               
    ++table_entry;                                                    
  }                                                                   
                                                                      
  if ( !stop ) {                                                      
    rtems_libio_lock();                                               
    for (                                                             
4000c04c:	80 a7 40 1b 	cmp  %i5, %i3                                  
4000c050:	12 bf ff f9 	bne  4000c034 <rtems_filesystem_iterate+0x80>  
4000c054:	b8 8a 20 ff 	andcc  %o0, 0xff, %i4                          
4000c058:	b8 0a 20 ff 	and  %o0, 0xff, %i4                            
}                                                                     
                                                                      
static inline void rtems_libio_unlock( void )                         
{                                                                     
  rtems_semaphore_release( rtems_libio_semaphore );                   
4000c05c:	7f ff ed 1b 	call  400074c8 <rtems_semaphore_release>       
4000c060:	d0 06 a1 38 	ld  [ %i2 + 0x138 ], %o0                       
    }                                                                 
    rtems_libio_unlock();                                             
  }                                                                   
                                                                      
  return stop;                                                        
}                                                                     
4000c064:	81 c7 e0 08 	ret                                            
4000c068:	91 e8 00 1c 	restore  %g0, %i4, %o0                         
                                                                      

4000bd08 <rtems_filesystem_location_clone>: void rtems_filesystem_location_clone( rtems_filesystem_location_info_t *clone, const rtems_filesystem_location_info_t *master ) {
4000bd08:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rv = 0;                                                         
                                                                      
  clone = rtems_filesystem_location_copy( clone, master );            
4000bd0c:	92 10 00 19 	mov  %i1, %o1                                  
4000bd10:	7f ff e1 f4 	call  400044e0 <rtems_filesystem_location_copy>
4000bd14:	90 10 00 18 	mov  %i0, %o0                                  
  rv = (*clone->mt_entry->ops->clonenod_h)( clone );                  
4000bd18:	c2 02 20 14 	ld  [ %o0 + 0x14 ], %g1                        
4000bd1c:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
4000bd20:	c2 00 60 28 	ld  [ %g1 + 0x28 ], %g1                        
4000bd24:	9f c0 40 00 	call  %g1                                      
4000bd28:	b0 10 00 08 	mov  %o0, %i0                                  
  if ( rv != 0 ) {                                                    
4000bd2c:	80 a2 20 00 	cmp  %o0, 0                                    
4000bd30:	12 80 00 04 	bne  4000bd40 <rtems_filesystem_location_clone+0x38><== NEVER TAKEN
4000bd34:	90 10 00 18 	mov  %i0, %o0                                  
4000bd38:	81 c7 e0 08 	ret                                            
4000bd3c:	81 e8 00 00 	restore                                        
    rtems_filesystem_location_remove_from_mt_entry( clone );          
4000bd40:	7f ff e2 24 	call  400045d0 <rtems_filesystem_location_remove_from_mt_entry><== NOT EXECUTED
4000bd44:	33 10 00 79 	sethi  %hi(0x4001e400), %i1                    <== NOT EXECUTED
static inline rtems_filesystem_location_info_t *                      
rtems_filesystem_location_initialize_to_null(                         
  rtems_filesystem_location_info_t *loc                               
)                                                                     
{                                                                     
  return rtems_filesystem_location_copy(                              
4000bd48:	7f ff e1 e6 	call  400044e0 <rtems_filesystem_location_copy><== NOT EXECUTED
4000bd4c:	93 ee 60 1c 	restore  %i1, 0x1c, %o1                        <== NOT EXECUTED
                                                                      

400045d0 <rtems_filesystem_location_remove_from_mt_entry>: } void rtems_filesystem_location_remove_from_mt_entry( rtems_filesystem_location_info_t *loc ) {
400045d0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_filesystem_mt_entry_declare_lock_context(lock_context);       
  bool do_unmount;                                                    
                                                                      
  rtems_filesystem_mt_entry_lock(lock_context);                       
400045d4:	7f ff f6 b4 	call  400020a4 <sparc_disable_interrupts>      
400045d8:	01 00 00 00 	nop                                            
  rtems_chain_extract_unprotected(&loc->mt_entry_node);               
  do_unmount = rtems_filesystem_is_ready_for_unmount(loc->mt_entry);  
400045dc:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
400045e0:	c6 06 00 00 	ld  [ %i0 ], %g3                               
  previous       = the_node->previous;                                
400045e4:	c4 06 20 04 	ld  [ %i0 + 4 ], %g2                           
  rtems_filesystem_mount_table_entry_t *mt_entry                      
)                                                                     
{                                                                     
  bool ready = !mt_entry->mounted                                     
    && rtems_chain_has_only_one_node( &mt_entry->location_chain )     
    && mt_entry->mt_fs_root->reference_count == 1;                    
400045e8:	c8 08 60 28 	ldub  [ %g1 + 0x28 ], %g4                      
  next->previous = previous;                                          
400045ec:	c4 20 e0 04 	st  %g2, [ %g3 + 4 ]                           
  previous->next = next;                                              
400045f0:	c6 20 80 00 	st  %g3, [ %g2 ]                               
400045f4:	80 a1 20 00 	cmp  %g4, 0                                    
400045f8:	12 80 00 07 	bne  40004614 <rtems_filesystem_location_remove_from_mt_entry+0x44>
400045fc:	ba 10 20 00 	clr  %i5                                       
static inline bool rtems_filesystem_is_ready_for_unmount(             
  rtems_filesystem_mount_table_entry_t *mt_entry                      
)                                                                     
{                                                                     
  bool ready = !mt_entry->mounted                                     
    && rtems_chain_has_only_one_node( &mt_entry->location_chain )     
40004600:	c6 00 60 14 	ld  [ %g1 + 0x14 ], %g3                        
40004604:	c4 00 60 1c 	ld  [ %g1 + 0x1c ], %g2                        
40004608:	80 a0 c0 02 	cmp  %g3, %g2                                  
4000460c:	22 80 00 0b 	be,a   40004638 <rtems_filesystem_location_remove_from_mt_entry+0x68>
40004610:	c4 00 60 24 	ld  [ %g1 + 0x24 ], %g2                        
  rtems_filesystem_mt_entry_unlock(lock_context);                     
40004614:	7f ff f6 a8 	call  400020b4 <sparc_enable_interrupts>       
40004618:	01 00 00 00 	nop                                            
                                                                      
  if (do_unmount) {                                                   
4000461c:	80 8f 60 ff 	btst  0xff, %i5                                
40004620:	32 80 00 04 	bne,a   40004630 <rtems_filesystem_location_remove_from_mt_entry+0x60><== NEVER TAKEN
40004624:	f0 06 20 14 	ld  [ %i0 + 0x14 ], %i0                        <== NOT EXECUTED
40004628:	81 c7 e0 08 	ret                                            
4000462c:	81 e8 00 00 	restore                                        
    rtems_filesystem_do_unmount(loc->mt_entry);                       
40004630:	7f ff ff c8 	call  40004550 <rtems_filesystem_do_unmount>   <== NOT EXECUTED
40004634:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    && mt_entry->mt_fs_root->reference_count == 1;                    
40004638:	c4 00 a0 18 	ld  [ %g2 + 0x18 ], %g2                        
4000463c:	80 a0 a0 01 	cmp  %g2, 1                                    
40004640:	12 bf ff f5 	bne  40004614 <rtems_filesystem_location_remove_from_mt_entry+0x44><== ALWAYS TAKEN
40004644:	84 00 60 14 	add  %g1, 0x14, %g2                            
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
40004648:	86 00 60 18 	add  %g1, 0x18, %g3                            <== NOT EXECUTED
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
4000464c:	c0 20 60 18 	clr  [ %g1 + 0x18 ]                            <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
40004650:	c6 20 60 14 	st  %g3, [ %g1 + 0x14 ]                        <== NOT EXECUTED
  head->previous = NULL;                                              
  tail->previous = head;                                              
40004654:	c4 20 60 1c 	st  %g2, [ %g1 + 0x1c ]                        <== NOT EXECUTED
                                                                      
static inline bool rtems_filesystem_is_ready_for_unmount(             
  rtems_filesystem_mount_table_entry_t *mt_entry                      
)                                                                     
{                                                                     
  bool ready = !mt_entry->mounted                                     
40004658:	10 bf ff ef 	b  40004614 <rtems_filesystem_location_remove_from_mt_entry+0x44><== NOT EXECUTED
4000465c:	ba 10 20 01 	mov  1, %i5                                    <== NOT EXECUTED
                                                                      

4000489c <rtems_filesystem_location_transform_to_global>: } rtems_filesystem_global_location_t *rtems_filesystem_location_transform_to_global( rtems_filesystem_location_info_t *loc ) {
4000489c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_filesystem_global_location_t *global_loc = malloc(sizeof(*global_loc));
400048a0:	7f ff fa bc 	call  40003390 <malloc>                        
400048a4:	90 10 20 24 	mov  0x24, %o0                                 
                                                                      
  if (global_loc != NULL) {                                           
400048a8:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400048ac:	02 80 00 0c 	be  400048dc <rtems_filesystem_location_transform_to_global+0x40><== NEVER TAKEN
400048b0:	82 10 20 01 	mov  1, %g1                                    
    global_loc->reference_count = 1;                                  
    global_loc->deferred_released_next = NULL;                        
    global_loc->deferred_released_count = 0;                          
    rtems_filesystem_location_copy(&global_loc->location, loc);       
400048b4:	92 10 00 18 	mov  %i0, %o1                                  
)                                                                     
{                                                                     
  rtems_filesystem_global_location_t *global_loc = malloc(sizeof(*global_loc));
                                                                      
  if (global_loc != NULL) {                                           
    global_loc->reference_count = 1;                                  
400048b8:	c2 27 60 18 	st  %g1, [ %i5 + 0x18 ]                        
    global_loc->deferred_released_next = NULL;                        
400048bc:	c0 27 60 1c 	clr  [ %i5 + 0x1c ]                            
    global_loc->deferred_released_count = 0;                          
    rtems_filesystem_location_copy(&global_loc->location, loc);       
400048c0:	7f ff ff 08 	call  400044e0 <rtems_filesystem_location_copy>
400048c4:	c0 27 60 20 	clr  [ %i5 + 0x20 ]                            
    rtems_filesystem_location_remove_from_mt_entry(loc);              
400048c8:	90 10 00 18 	mov  %i0, %o0                                  
400048cc:	7f ff ff 41 	call  400045d0 <rtems_filesystem_location_remove_from_mt_entry>
400048d0:	b0 10 00 1d 	mov  %i5, %i0                                  
    global_loc = rtems_filesystem_global_location_obtain_null();      
    errno = ENOMEM;                                                   
  }                                                                   
                                                                      
  return global_loc;                                                  
}                                                                     
400048d4:	81 c7 e0 08 	ret                                            
400048d8:	81 e8 00 00 	restore                                        
    global_loc->deferred_released_next = NULL;                        
    global_loc->deferred_released_count = 0;                          
    rtems_filesystem_location_copy(&global_loc->location, loc);       
    rtems_filesystem_location_remove_from_mt_entry(loc);              
  } else {                                                            
    rtems_filesystem_location_free(loc);                              
400048dc:	40 00 1d 1d 	call  4000bd50 <rtems_filesystem_location_free><== NOT EXECUTED
400048e0:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
static inline rtems_filesystem_global_location_t *                    
rtems_filesystem_global_location_obtain_null(void)                    
{                                                                     
  rtems_filesystem_global_location_t *global_loc = NULL;              
                                                                      
  return rtems_filesystem_global_location_obtain( &global_loc );      
400048e4:	90 07 bf fc 	add  %fp, -4, %o0                              <== NOT EXECUTED
400048e8:	7f ff ff b3 	call  400047b4 <rtems_filesystem_global_location_obtain><== NOT EXECUTED
400048ec:	c0 27 bf fc 	clr  [ %fp + -4 ]                              <== NOT EXECUTED
    global_loc = rtems_filesystem_global_location_obtain_null();      
    errno = ENOMEM;                                                   
400048f0:	40 00 2b 94 	call  4000f740 <__errno>                       <== NOT EXECUTED
400048f4:	ba 10 00 08 	mov  %o0, %i5                                  <== NOT EXECUTED
400048f8:	82 10 20 0c 	mov  0xc, %g1                                  <== NOT EXECUTED
400048fc:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  return global_loc;                                                  
}                                                                     
40004900:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40004904:	91 e8 00 1d 	restore  %g0, %i5, %o0                         <== NOT EXECUTED
                                                                      

400034a0 <rtems_filesystem_mknod>: const char *name, size_t namelen, mode_t mode, dev_t dev ) {
400034a0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rv = 0;                                                         
                                                                      
  mode &= ~rtems_filesystem_umask;                                    
400034a4:	03 10 00 78 	sethi  %hi(0x4001e000), %g1                    
400034a8:	c2 00 63 ec 	ld  [ %g1 + 0x3ec ], %g1	! 4001e3ec <rtems_current_user_env>
                                                                      
  switch (mode & S_IFMT) {                                            
400034ac:	05 00 00 10 	sethi  %hi(0x4000), %g2                        
  dev_t dev                                                           
)                                                                     
{                                                                     
  int rv = 0;                                                         
                                                                      
  mode &= ~rtems_filesystem_umask;                                    
400034b0:	d6 00 60 08 	ld  [ %g1 + 8 ], %o3                           
                                                                      
  switch (mode & S_IFMT) {                                            
400034b4:	03 00 00 3c 	sethi  %hi(0xf000), %g1                        
  dev_t dev                                                           
)                                                                     
{                                                                     
  int rv = 0;                                                         
                                                                      
  mode &= ~rtems_filesystem_umask;                                    
400034b8:	96 2e c0 0b 	andn  %i3, %o3, %o3                            
                                                                      
  switch (mode & S_IFMT) {                                            
400034bc:	82 0a c0 01 	and  %o3, %g1, %g1                             
400034c0:	80 a0 40 02 	cmp  %g1, %g2                                  
400034c4:	22 80 00 18 	be,a   40003524 <rtems_filesystem_mknod+0x84>  
400034c8:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
400034cc:	08 80 00 0f 	bleu  40003508 <rtems_filesystem_mknod+0x68>   
400034d0:	05 00 00 04 	sethi  %hi(0x1000), %g2                        
400034d4:	05 00 00 18 	sethi  %hi(0x6000), %g2                        
400034d8:	80 a0 40 02 	cmp  %g1, %g2                                  
400034dc:	02 80 00 11 	be  40003520 <rtems_filesystem_mknod+0x80>     
400034e0:	05 00 00 20 	sethi  %hi(0x8000), %g2                        
400034e4:	80 a0 40 02 	cmp  %g1, %g2                                  
400034e8:	22 80 00 0f 	be,a   40003524 <rtems_filesystem_mknod+0x84>  <== ALWAYS TAKEN
400034ec:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
    case S_IFDIR:                                                     
    case S_IFIFO:                                                     
    case S_IFREG:                                                     
      break;                                                          
    default:                                                          
      errno = EINVAL;                                                 
400034f0:	40 00 30 94 	call  4000f740 <__errno>                       
400034f4:	b0 10 3f ff 	mov  -1, %i0                                   
400034f8:	82 10 20 16 	mov  0x16, %g1                                 
400034fc:	c2 22 00 00 	st  %g1, [ %o0 ]                               
40003500:	81 c7 e0 08 	ret                                            
40003504:	81 e8 00 00 	restore                                        
{                                                                     
  int rv = 0;                                                         
                                                                      
  mode &= ~rtems_filesystem_umask;                                    
                                                                      
  switch (mode & S_IFMT) {                                            
40003508:	80 a0 40 02 	cmp  %g1, %g2                                  
4000350c:	02 80 00 05 	be  40003520 <rtems_filesystem_mknod+0x80>     
40003510:	05 00 00 08 	sethi  %hi(0x2000), %g2                        
40003514:	80 a0 40 02 	cmp  %g1, %g2                                  
40003518:	12 bf ff f6 	bne  400034f0 <rtems_filesystem_mknod+0x50>    
4000351c:	01 00 00 00 	nop                                            
      rv = -1;                                                        
      break;                                                          
  }                                                                   
                                                                      
  if ( rv == 0 ) {                                                    
    const rtems_filesystem_operations_table *ops = parentloc->mt_entry->ops;
40003520:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
                                                                      
    rv = (*ops->mknod_h)( parentloc, name, namelen, mode, dev );      
40003524:	90 10 00 18 	mov  %i0, %o0                                  
40003528:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
4000352c:	92 10 00 19 	mov  %i1, %o1                                  
40003530:	c2 00 60 18 	ld  [ %g1 + 0x18 ], %g1                        
40003534:	94 10 00 1a 	mov  %i2, %o2                                  
40003538:	98 10 00 1c 	mov  %i4, %o4                                  
4000353c:	9f c0 40 00 	call  %g1                                      
40003540:	9a 10 00 1d 	mov  %i5, %o5                                  
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
40003544:	81 c7 e0 08 	ret                                            
40003548:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

4000c170 <rtems_filesystem_unregister>: int rtems_filesystem_unregister( const char *type ) {
4000c170:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_chain_node *node = NULL;                                      
                                                                      
  if ( type == NULL ) {                                               
4000c174:	80 a6 20 00 	cmp  %i0, 0                                    
4000c178:	02 80 00 29 	be  4000c21c <rtems_filesystem_unregister+0xac>
4000c17c:	37 10 00 7b 	sethi  %hi(0x4001ec00), %i3                    
 */                                                                   
#include <rtems/userenv.h>                                            
                                                                      
static inline void rtems_libio_lock( void )                           
{                                                                     
  rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
4000c180:	d0 06 e1 38 	ld  [ %i3 + 0x138 ], %o0	! 4001ed38 <rtems_libio_semaphore>
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return _Chain_Head( the_chain )->next;                              
4000c184:	39 10 00 79 	sethi  %hi(0x4001e400), %i4                    
4000c188:	92 10 20 00 	clr  %o1                                       
4000c18c:	7f ff ec 80 	call  4000738c <rtems_semaphore_obtain>        
4000c190:	94 10 20 00 	clr  %o2                                       
4000c194:	fa 07 20 9c 	ld  [ %i4 + 0x9c ], %i5                        
4000c198:	b8 17 20 9c 	or  %i4, 0x9c, %i4                             
    rtems_set_errno_and_return_minus_one( EINVAL );                   
  }                                                                   
                                                                      
  rtems_libio_lock();                                                 
  for (                                                               
4000c19c:	b8 07 20 04 	add  %i4, 4, %i4                               
4000c1a0:	80 a7 40 1c 	cmp  %i5, %i4                                  
4000c1a4:	32 80 00 08 	bne,a   4000c1c4 <rtems_filesystem_unregister+0x54>
4000c1a8:	d0 07 60 08 	ld  [ %i5 + 8 ], %o0                           
}                                                                     
                                                                      
static inline void rtems_libio_unlock( void )                         
{                                                                     
  rtems_semaphore_release( rtems_libio_semaphore );                   
4000c1ac:	10 80 00 14 	b  4000c1fc <rtems_filesystem_unregister+0x8c> 
4000c1b0:	d0 06 e1 38 	ld  [ %i3 + 0x138 ], %o0                       
4000c1b4:	80 a7 40 1c 	cmp  %i5, %i4                                  
4000c1b8:	02 80 00 11 	be  4000c1fc <rtems_filesystem_unregister+0x8c><== ALWAYS TAKEN
4000c1bc:	d0 06 e1 38 	ld  [ %i3 + 0x138 ], %o0                       
    !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 ) {                     
4000c1c0:	d0 07 60 08 	ld  [ %i5 + 8 ], %o0                           <== NOT EXECUTED
4000c1c4:	40 00 10 f9 	call  400105a8 <strcmp>                        
4000c1c8:	92 10 00 18 	mov  %i0, %o1                                  
4000c1cc:	80 a2 20 00 	cmp  %o0, 0                                    
4000c1d0:	32 bf ff f9 	bne,a   4000c1b4 <rtems_filesystem_unregister+0x44>
4000c1d4:	fa 07 40 00 	ld  [ %i5 ], %i5                               
 */                                                                   
RTEMS_INLINE_ROUTINE void rtems_chain_extract(                        
  rtems_chain_node *the_node                                          
)                                                                     
{                                                                     
  _Chain_Extract( the_node );                                         
4000c1d8:	40 00 04 40 	call  4000d2d8 <_Chain_Extract>                
4000c1dc:	90 10 00 1d 	mov  %i5, %o0                                  
      rtems_chain_extract( node );                                    
      free( fsn );                                                    
4000c1e0:	7f ff db 92 	call  40003028 <free>                          
4000c1e4:	90 10 00 1d 	mov  %i5, %o0                                  
4000c1e8:	d0 06 e1 38 	ld  [ %i3 + 0x138 ], %o0                       
4000c1ec:	7f ff ec b7 	call  400074c8 <rtems_semaphore_release>       
4000c1f0:	b0 10 20 00 	clr  %i0                                       
4000c1f4:	81 c7 e0 08 	ret                                            
4000c1f8:	81 e8 00 00 	restore                                        
4000c1fc:	7f ff ec b3 	call  400074c8 <rtems_semaphore_release>       
4000c200:	b0 10 3f ff 	mov  -1, %i0                                   
      return 0;                                                       
    }                                                                 
  }                                                                   
  rtems_libio_unlock();                                               
                                                                      
  rtems_set_errno_and_return_minus_one( ENOENT );                     
4000c204:	40 00 0d 4f 	call  4000f740 <__errno>                       
4000c208:	01 00 00 00 	nop                                            
4000c20c:	82 10 20 02 	mov  2, %g1	! 2 <PROM_START+0x2>               
4000c210:	c2 22 00 00 	st  %g1, [ %o0 ]                               
}                                                                     
4000c214:	81 c7 e0 08 	ret                                            
4000c218:	81 e8 00 00 	restore                                        
)                                                                     
{                                                                     
  rtems_chain_node *node = NULL;                                      
                                                                      
  if ( type == NULL ) {                                               
    rtems_set_errno_and_return_minus_one( EINVAL );                   
4000c21c:	40 00 0d 49 	call  4000f740 <__errno>                       
4000c220:	b0 10 3f ff 	mov  -1, %i0                                   
4000c224:	82 10 20 16 	mov  0x16, %g1                                 
4000c228:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4000c22c:	81 c7 e0 08 	ret                                            
4000c230:	81 e8 00 00 	restore                                        
                                                                      

400035f0 <rtems_gxx_key_create>: int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *)) {
400035f0:	9d e3 bf a0 	save  %sp, -96, %sp                            
   * pointer to the buffer that will hold the value of the key itself.
   * We have to to this, because the others functions on this interface
   * deal with the value of the key, as used with the POSIX API.      
   */                                                                 
   /* Do not pull your hair, trust me this works. :-) */              
  __gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) );
400035f4:	40 00 01 0c 	call  40003a24 <malloc>                        
400035f8:	90 10 20 08 	mov  8, %o0                                    
  *key = new_key;                                                     
  new_key->val  = NULL;                                               
400035fc:	c0 22 00 00 	clr  [ %o0 ]                                   
   * We have to to this, because the others functions on this interface
   * deal with the value of the key, as used with the POSIX API.      
   */                                                                 
   /* Do not pull your hair, trust me this works. :-) */              
  __gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) );
  *key = new_key;                                                     
40003600:	d0 26 00 00 	st  %o0, [ %i0 ]                               
   * pointer to the buffer that will hold the value of the key itself.
   * We have to to this, because the others functions on this interface
   * deal with the value of the key, as used with the POSIX API.      
   */                                                                 
   /* Do not pull your hair, trust me this works. :-) */              
  __gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) );
40003604:	ba 10 00 08 	mov  %o0, %i5                                  
  *key = new_key;                                                     
  new_key->val  = NULL;                                               
  new_key->dtor = dtor;                                               
40003608:	f2 22 20 04 	st  %i1, [ %o0 + 4 ]                           
      "gxx_wrappers: create key=%x, dtor=%x, new_key=%x\n", key, dtor, new_key
    );                                                                
  #endif                                                              
                                                                      
  /* register with RTEMS the buffer that will hold the key values */  
  status = rtems_task_variable_add( RTEMS_SELF, (void **)new_key, dtor );
4000360c:	92 10 00 1d 	mov  %i5, %o1                                  
40003610:	90 10 20 00 	clr  %o0                                       
40003614:	94 10 00 19 	mov  %i1, %o2                                  
40003618:	40 00 12 84 	call  40008028 <rtems_task_variable_add>       
4000361c:	b0 10 20 00 	clr  %i0                                       
  if ( status == RTEMS_SUCCESSFUL )                                   
40003620:	80 a2 20 00 	cmp  %o0, 0                                    
40003624:	02 80 00 04 	be  40003634 <rtems_gxx_key_create+0x44>       <== ALWAYS TAKEN
40003628:	90 10 00 1d 	mov  %i5, %o0                                  
    return 0;                                                         
                                                                      
  free( new_key );                                                    
4000362c:	7f ff ff 81 	call  40003430 <free>                          <== NOT EXECUTED
40003630:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
  return -1;                                                          
}                                                                     
40003634:	81 c7 e0 08 	ret                                            
40003638:	81 e8 00 00 	restore                                        
                                                                      

40003648 <rtems_gxx_key_delete>: int rtems_gxx_key_delete (__gthread_key_t key) {
40003648:	9d e3 bf a0 	save  %sp, -96, %sp                            
  #ifdef DEBUG_GXX_WRAPPERS                                           
    printk( "gxx_wrappers: delete key=%x\n", key );                   
  #endif                                                              
                                                                      
  /* register with RTEMS the buffer that will hold the key values */  
  status = rtems_task_variable_delete( RTEMS_SELF, (void **)key );    
4000364c:	90 10 20 00 	clr  %o0                                       
40003650:	40 00 12 a8 	call  400080f0 <rtems_task_variable_delete>    
40003654:	92 10 00 18 	mov  %i0, %o1                                  
  if ( status == RTEMS_SUCCESSFUL ) {                                 
40003658:	80 a2 20 00 	cmp  %o0, 0                                    
4000365c:	12 80 00 06 	bne  40003674 <rtems_gxx_key_delete+0x2c>      <== NEVER TAKEN
40003660:	80 a6 20 00 	cmp  %i0, 0                                    
    /* Hmm - hopefully all tasks using this key have gone away... */  
    if ( key ) free( *(void **)key );                                 
40003664:	02 80 00 04 	be  40003674 <rtems_gxx_key_delete+0x2c>       <== NEVER TAKEN
40003668:	01 00 00 00 	nop                                            
4000366c:	7f ff ff 71 	call  40003430 <free>                          
40003670:	d0 06 00 00 	ld  [ %i0 ], %o0                               
    return 0;                                                         
  }                                                                   
  key = NULL;                                                         
  return 0;                                                           
}                                                                     
40003674:	81 c7 e0 08 	ret                                            
40003678:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

40003580 <rtems_gxx_once>: /* uncomment this if you need to debug this interface */ /*#define DEBUG_GXX_WRAPPERS 1*/ int rtems_gxx_once(__gthread_once_t *once, void (*func) (void)) {
40003580:	9d e3 bf 98 	save  %sp, -104, %sp                           
  #ifdef DEBUG_GXX_WRAPPERS                                           
    printk( "gxx_wrappers: once=%x, func=%x\n", *once, func );        
  #endif                                                              
                                                                      
  if ( *(volatile __gthread_once_t *)once == 0 ) {                    
40003584:	c2 06 00 00 	ld  [ %i0 ], %g1                               
40003588:	80 a0 60 00 	cmp  %g1, 0                                    
4000358c:	02 80 00 04 	be  4000359c <rtems_gxx_once+0x1c>             
40003590:	92 10 21 00 	mov  0x100, %o1                                
    rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);         
    if ( o == 0 )                                                     
      (*func)();                                                      
  }                                                                   
  return 0;                                                           
}                                                                     
40003594:	81 c7 e0 08 	ret                                            
40003598:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      
  if ( *(volatile __gthread_once_t *)once == 0 ) {                    
    rtems_mode saveMode;                                              
    __gthread_once_t o;                                               
                                                                      
    rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); 
4000359c:	94 07 bf fc 	add  %fp, -4, %o2                              
400035a0:	40 00 12 18 	call  40007e00 <rtems_task_mode>               
400035a4:	90 10 21 00 	mov  0x100, %o0                                
    if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {            
400035a8:	c2 06 00 00 	ld  [ %i0 ], %g1                               
      *(volatile __gthread_once_t *)once = 1;                         
    }                                                                 
    rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);         
400035ac:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
400035b0:	92 10 21 00 	mov  0x100, %o1                                
  if ( *(volatile __gthread_once_t *)once == 0 ) {                    
    rtems_mode saveMode;                                              
    __gthread_once_t o;                                               
                                                                      
    rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); 
    if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {            
400035b4:	80 a0 60 00 	cmp  %g1, 0                                    
400035b8:	12 80 00 0a 	bne  400035e0 <rtems_gxx_once+0x60>            <== NEVER TAKEN
400035bc:	94 07 bf fc 	add  %fp, -4, %o2                              
      *(volatile __gthread_once_t *)once = 1;                         
400035c0:	82 10 20 01 	mov  1, %g1                                    
400035c4:	c2 26 00 00 	st  %g1, [ %i0 ]                               
    }                                                                 
    rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);         
400035c8:	40 00 12 0e 	call  40007e00 <rtems_task_mode>               
400035cc:	b0 10 20 00 	clr  %i0                                       
    if ( o == 0 )                                                     
      (*func)();                                                      
400035d0:	9f c6 40 00 	call  %i1                                      
400035d4:	01 00 00 00 	nop                                            
  }                                                                   
  return 0;                                                           
}                                                                     
400035d8:	81 c7 e0 08 	ret                                            
400035dc:	81 e8 00 00 	restore                                        
                                                                      
    rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); 
    if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {            
      *(volatile __gthread_once_t *)once = 1;                         
    }                                                                 
    rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);         
400035e0:	40 00 12 08 	call  40007e00 <rtems_task_mode>               <== NOT EXECUTED
400035e4:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
    if ( o == 0 )                                                     
      (*func)();                                                      
  }                                                                   
  return 0;                                                           
}                                                                     
400035e8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400035ec:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

400036e4 <rtems_gxx_setspecific>: #endif return p; } int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr) {
400036e4:	9d e3 bf a0 	save  %sp, -96, %sp                            
      rtems_task_self()                                               
      );                                                              
  #endif                                                              
                                                                      
  /* register with RTEMS the buffer that will hold the key values */  
  status = rtems_task_variable_add( RTEMS_SELF, (void **)key, key->dtor );
400036e8:	d4 06 20 04 	ld  [ %i0 + 4 ], %o2                           
400036ec:	90 10 20 00 	clr  %o0                                       
400036f0:	40 00 12 4e 	call  40008028 <rtems_task_variable_add>       
400036f4:	92 10 00 18 	mov  %i0, %o1                                  
  if ( status == RTEMS_SUCCESSFUL ) {                                 
400036f8:	80 a2 20 00 	cmp  %o0, 0                                    
400036fc:	12 80 00 05 	bne  40003710 <rtems_gxx_setspecific+0x2c>     <== NEVER TAKEN
40003700:	01 00 00 00 	nop                                            
    /* now let's set the proper value */                              
    key->val =  (void *)ptr;                                          
40003704:	f2 26 00 00 	st  %i1, [ %i0 ]                               
    return 0;                                                         
40003708:	81 c7 e0 08 	ret                                            
4000370c:	91 e8 20 00 	restore  %g0, 0, %o0                           
  }                                                                   
  return -1;                                                          
}                                                                     
40003710:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40003714:	91 e8 3f ff 	restore  %g0, -1, %o0                          <== NOT EXECUTED
                                                                      

400085f4 <rtems_heap_allocate_aligned_with_boundary>: void *rtems_heap_allocate_aligned_with_boundary( size_t size, uintptr_t alignment, uintptr_t boundary ) {
400085f4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if (                                                                
400085f8:	03 10 00 99 	sethi  %hi(0x40026400), %g1                    
400085fc:	c2 00 63 08 	ld  [ %g1 + 0x308 ], %g1	! 40026708 <_System_state_Current>
void *rtems_heap_allocate_aligned_with_boundary(                      
  size_t size,                                                        
  uintptr_t alignment,                                                
  uintptr_t boundary                                                  
)                                                                     
{                                                                     
40008600:	ba 10 00 18 	mov  %i0, %i5                                  
40008604:	b8 10 00 19 	mov  %i1, %i4                                  
  if (                                                                
40008608:	80 a0 60 03 	cmp  %g1, 3                                    
4000860c:	02 80 00 08 	be  4000862c <rtems_heap_allocate_aligned_with_boundary+0x38><== ALWAYS TAKEN
40008610:	b6 10 00 1a 	mov  %i2, %i3                                  
      && !malloc_is_system_state_OK()                                 
  ) {                                                                 
    return NULL;                                                      
  }                                                                   
                                                                      
  malloc_deferred_frees_process();                                    
40008614:	7f ff fb d4 	call  40007564 <malloc_deferred_frees_process> 
40008618:	b2 10 00 1d 	mov  %i5, %i1                                  
                                                                      
  /* FIXME: Statistics, boundary checks */                            
                                                                      
  return _Protected_heap_Allocate_aligned_with_boundary(              
4000861c:	03 10 00 93 	sethi  %hi(0x40024c00), %g1                    
40008620:	f0 00 61 b4 	ld  [ %g1 + 0x1b4 ], %i0	! 40024db4 <RTEMS_Malloc_Heap>
40008624:	40 00 19 6f 	call  4000ebe0 <_Protected_heap_Allocate_aligned_with_boundary>
40008628:	95 e8 00 1c 	restore  %g0, %i4, %o2                         
  uintptr_t boundary                                                  
)                                                                     
{                                                                     
  if (                                                                
    _System_state_Is_up( _System_state_Get() )                        
      && !malloc_is_system_state_OK()                                 
4000862c:	7f ff fb c1 	call  40007530 <malloc_is_system_state_OK>     
40008630:	01 00 00 00 	nop                                            
40008634:	80 8a 20 ff 	btst  0xff, %o0                                
40008638:	12 bf ff f7 	bne  40008614 <rtems_heap_allocate_aligned_with_boundary+0x20>
4000863c:	b0 10 20 00 	clr  %i0                                       
    RTEMS_Malloc_Heap,                                                
    size,                                                             
    alignment,                                                        
    boundary                                                          
  );                                                                  
}                                                                     
40008640:	81 c7 e0 08 	ret                                            
40008644:	81 e8 00 00 	restore                                        
                                                                      

40003be8 <rtems_heap_extend_via_sbrk>: void *rtems_heap_extend_via_sbrk( Heap_Control *heap, size_t alloc_size ) {
40003be8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  ptrdiff_t sbrk_amount = RTEMS_Malloc_Sbrk_amount;                   
40003bec:	03 10 00 5b 	sethi  %hi(0x40016c00), %g1                    
40003bf0:	f8 00 60 90 	ld  [ %g1 + 0x90 ], %i4	! 40016c90 <RTEMS_Malloc_Sbrk_amount>
  ptrdiff_t sbrk_size = (ptrdiff_t) alloc_size;                       
  ptrdiff_t misaligned = sbrk_size % sbrk_amount;                     
40003bf4:	90 10 00 19 	mov  %i1, %o0                                  
40003bf8:	92 10 00 1c 	mov  %i4, %o1                                  
40003bfc:	40 00 3c f4 	call  40012fcc <.rem>                          
40003c00:	ba 10 00 19 	mov  %i1, %i5                                  
  void *return_this = NULL;                                           
                                                                      
  if ( misaligned != 0 ) {                                            
40003c04:	80 a2 20 00 	cmp  %o0, 0                                    
40003c08:	02 80 00 05 	be  40003c1c <rtems_heap_extend_via_sbrk+0x34> 
40003c0c:	80 a7 60 00 	cmp  %i5, 0                                    
    sbrk_size += sbrk_amount - misaligned;                            
40003c10:	ba 27 00 08 	sub  %i4, %o0, %i5                             
40003c14:	ba 06 40 1d 	add  %i1, %i5, %i5                             
  }                                                                   
                                                                      
  if ( sbrk_size > 0 && sbrk_amount > 0 ) {                           
40003c18:	80 a7 60 00 	cmp  %i5, 0                                    
40003c1c:	04 80 00 17 	ble  40003c78 <rtems_heap_extend_via_sbrk+0x90><== NEVER TAKEN
40003c20:	80 a7 20 00 	cmp  %i4, 0                                    
40003c24:	04 80 00 15 	ble  40003c78 <rtems_heap_extend_via_sbrk+0x90><== NEVER TAKEN
40003c28:	01 00 00 00 	nop                                            
    void *area_begin = sbrk( sbrk_size );                             
40003c2c:	7f ff f6 2d 	call  400014e0 <sbrk>                          
40003c30:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
    if ( area_begin != (void *) -1 ) {                                
40003c34:	80 a2 3f ff 	cmp  %o0, -1                                   
40003c38:	02 80 00 10 	be  40003c78 <rtems_heap_extend_via_sbrk+0x90> 
40003c3c:	92 10 00 08 	mov  %o0, %o1                                  
      bool ok = _Protected_heap_Extend( heap, area_begin, sbrk_size );
40003c40:	90 10 00 18 	mov  %i0, %o0                                  
40003c44:	40 00 14 a5 	call  40008ed8 <_Protected_heap_Extend>        
40003c48:	94 10 00 1d 	mov  %i5, %o2                                  
                                                                      
      if ( ok ) {                                                     
40003c4c:	80 8a 20 ff 	btst  0xff, %o0                                
40003c50:	02 80 00 08 	be  40003c70 <rtems_heap_extend_via_sbrk+0x88> 
40003c54:	03 10 00 5b 	sethi  %hi(0x40016c00), %g1                    
        MSBUMP( space_available, sbrk_size );                         
40003c58:	c4 00 60 60 	ld  [ %g1 + 0x60 ], %g2	! 40016c60 <rtems_malloc_statistics>
40003c5c:	b4 10 20 00 	clr  %i2                                       
40003c60:	ba 07 40 02 	add  %i5, %g2, %i5                             
40003c64:	fa 20 60 60 	st  %i5, [ %g1 + 0x60 ]                        
40003c68:	40 00 14 8e 	call  40008ea0 <_Protected_heap_Allocate_aligned_with_boundary>
40003c6c:	97 e8 20 00 	restore  %g0, 0, %o3                           
                                                                      
        return_this = _Protected_heap_Allocate( heap, alloc_size );   
      } else {                                                        
        sbrk( -sbrk_size );                                           
40003c70:	7f ff f6 1c 	call  400014e0 <sbrk>                          
40003c74:	90 20 00 1d 	neg  %i5, %o0                                  
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  return return_this;                                                 
}                                                                     
40003c78:	81 c7 e0 08 	ret                                            
40003c7c:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

40003ee0 <rtems_heap_null_extend>: Heap_Control *heap __attribute__((unused)), size_t alloc_size __attribute__((unused)) ) { return NULL; }
40003ee0:	81 c3 e0 08 	retl                                           
40003ee4:	90 10 20 00 	clr  %o0                                       
                                                                      

400049c8 <rtems_ide_part_table_free>: * N/A */ void rtems_ide_part_table_free(rtems_disk_desc_t *disk_desc) { partition_table_free( disk_desc );
400049c8:	82 13 c0 00 	mov  %o7, %g1                                  <== NOT EXECUTED
400049cc:	7f ff fe bb 	call  400044b8 <partition_table_free>          <== NOT EXECUTED
400049d0:	9e 10 40 00 	mov  %g1, %o7                                  <== NOT EXECUTED
                                                                      

400049d4 <rtems_ide_part_table_get>: * RTEMS_INTERNAL_ERROR otherwise */ rtems_status_code rtems_ide_part_table_get(const char *dev_name, rtems_disk_desc_t *disk_desc) { return partition_table_get( dev_name, disk_desc );
400049d4:	82 13 c0 00 	mov  %o7, %g1                                  <== NOT EXECUTED
400049d8:	7f ff ff 89 	call  400047fc <partition_table_get>           <== NOT EXECUTED
400049dc:	9e 10 40 00 	mov  %g1, %o7                                  <== NOT EXECUTED
                                                                      

400049e0 <rtems_ide_part_table_initialize>: * RTEMS_NO_MEMOTY if cannot have not enough memory, * RTEMS_INTERNAL_ERROR if other error occurs. */ rtems_status_code rtems_ide_part_table_initialize(const char *dev_name) {
400049e0:	9d e3 bf 88 	save  %sp, -120, %sp                           
    rtems_part_desc_t          *part_desc;                            
                                                                      
    /* logical device name /dev/hdxyy */                              
    char                        name[RTEMS_IDE_PARTITION_DEV_NAME_LENGTH_MAX];
                                                                      
    disk_desc = (rtems_disk_desc_t *) calloc(1, sizeof(rtems_disk_desc_t));
400049e4:	90 10 20 01 	mov  1, %o0                                    
400049e8:	92 10 21 28 	mov  0x128, %o1                                
400049ec:	40 00 02 2c 	call  4000529c <calloc>                        
400049f0:	b2 10 00 18 	mov  %i0, %i1                                  
    if (disk_desc == NULL)                                            
    {                                                                 
        return RTEMS_NO_MEMORY;                                       
400049f4:	b0 10 20 1a 	mov  0x1a, %i0                                 
                                                                      
    /* logical device name /dev/hdxyy */                              
    char                        name[RTEMS_IDE_PARTITION_DEV_NAME_LENGTH_MAX];
                                                                      
    disk_desc = (rtems_disk_desc_t *) calloc(1, sizeof(rtems_disk_desc_t));
    if (disk_desc == NULL)                                            
400049f8:	80 a2 20 00 	cmp  %o0, 0                                    
400049fc:	02 80 00 33 	be  40004ac8 <rtems_ide_part_table_initialize+0xe8><== NEVER TAKEN
40004a00:	b4 10 00 08 	mov  %o0, %i2                                  
    {                                                                 
        return RTEMS_NO_MEMORY;                                       
    }                                                                 
                                                                      
    /* get partition table */                                         
    rc = partition_table_get(dev_name, disk_desc);                    
40004a04:	90 10 00 19 	mov  %i1, %o0                                  
40004a08:	7f ff ff 7d 	call  400047fc <partition_table_get>           
40004a0c:	92 10 00 1a 	mov  %i2, %o1                                  
    if (rc != RTEMS_SUCCESSFUL)                                       
40004a10:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40004a14:	12 80 00 36 	bne  40004aec <rtems_ide_part_table_initialize+0x10c><== NEVER TAKEN
40004a18:	ba 10 20 00 	clr  %i5                                       
     */                                                               
                                                                      
    rtems_filesystem_split_dev_t (disk_desc->dev, major, minor);      
                                                                      
    /* create logical disks on the physical one */                    
    for (part_num = 0; part_num < disk_desc->last_log_id; part_num++) 
40004a1c:	c2 06 a0 24 	ld  [ %i2 + 0x24 ], %g1                        
    {                                                                 
        sprintf(name, "%s%d", dev_name, part_num + 1);                
40004a20:	b6 07 bf f0 	add  %fp, -16, %i3                             
40004a24:	21 10 00 95 	sethi  %hi(0x40025400), %l0                    
                                                                      
        rc = rtems_disk_create_log(dev, disk_desc->dev, part_desc->start,
                                   part_desc->size, name);            
        if (rc != RTEMS_SUCCESSFUL)                                   
        {                                                             
            fprintf(stdout,"Cannot create device %s, error code %d\n", name, rc);
40004a28:	27 10 00 95 	sethi  %hi(0x40025400), %l3                    
    rtems_filesystem_split_dev_t (disk_desc->dev, major, minor);      
                                                                      
    /* create logical disks on the physical one */                    
    for (part_num = 0; part_num < disk_desc->last_log_id; part_num++) 
    {                                                                 
        sprintf(name, "%s%d", dev_name, part_num + 1);                
40004a2c:	a0 14 22 48 	or  %l0, 0x248, %l0                            
     */                                                               
                                                                      
    rtems_filesystem_split_dev_t (disk_desc->dev, major, minor);      
                                                                      
    /* create logical disks on the physical one */                    
    for (part_num = 0; part_num < disk_desc->last_log_id; part_num++) 
40004a30:	80 a7 40 01 	cmp  %i5, %g1                                  
    /* To avoid device numbers conflicts we have to use for logic disk the same
     * device major number as ATA device has, and minor number that equals to
     * sum of logic disk partition number and the minor number of physical disk
     */                                                               
                                                                      
    rtems_filesystem_split_dev_t (disk_desc->dev, major, minor);      
40004a34:	e4 06 80 00 	ld  [ %i2 ], %l2                               
                                                                      
    /* create logical disks on the physical one */                    
    for (part_num = 0; part_num < disk_desc->last_log_id; part_num++) 
    {                                                                 
        sprintf(name, "%s%d", dev_name, part_num + 1);                
40004a38:	ba 07 60 01 	inc  %i5                                       
    /* To avoid device numbers conflicts we have to use for logic disk the same
     * device major number as ATA device has, and minor number that equals to
     * sum of logic disk partition number and the minor number of physical disk
     */                                                               
                                                                      
    rtems_filesystem_split_dev_t (disk_desc->dev, major, minor);      
40004a3c:	e2 06 a0 04 	ld  [ %i2 + 4 ], %l1                           
 *      RTEMS_SUCCESSFUL if success,                                  
 *      RTEMS_NO_MEMOTY if cannot have not enough memory,             
 *      RTEMS_INTERNAL_ERROR if other error occurs.                   
 */                                                                   
rtems_status_code                                                     
rtems_ide_part_table_initialize(const char *dev_name)                 
40004a40:	b8 06 a0 28 	add  %i2, 0x28, %i4                            
                                                                      
        rc = rtems_disk_create_log(dev, disk_desc->dev, part_desc->start,
                                   part_desc->size, name);            
        if (rc != RTEMS_SUCCESSFUL)                                   
        {                                                             
            fprintf(stdout,"Cannot create device %s, error code %d\n", name, rc);
40004a44:	29 10 00 99 	sethi  %hi(0x40026400), %l4                    
40004a48:	a6 14 e2 50 	or  %l3, 0x250, %l3                            
    rtems_filesystem_split_dev_t (disk_desc->dev, major, minor);      
                                                                      
    /* create logical disks on the physical one */                    
    for (part_num = 0; part_num < disk_desc->last_log_id; part_num++) 
    {                                                                 
        sprintf(name, "%s%d", dev_name, part_num + 1);                
40004a4c:	92 10 00 10 	mov  %l0, %o1                                  
40004a50:	94 10 00 19 	mov  %i1, %o2                                  
40004a54:	90 10 00 1b 	mov  %i3, %o0                                  
     */                                                               
                                                                      
    rtems_filesystem_split_dev_t (disk_desc->dev, major, minor);      
                                                                      
    /* create logical disks on the physical one */                    
    for (part_num = 0; part_num < disk_desc->last_log_id; part_num++) 
40004a58:	16 80 00 1a 	bge  40004ac0 <rtems_ide_part_table_initialize+0xe0><== NEVER TAKEN
40004a5c:	96 10 00 1d 	mov  %i5, %o3                                  
    {                                                                 
        sprintf(name, "%s%d", dev_name, part_num + 1);                
40004a60:	40 00 46 0b 	call  4001628c <sprintf>                       
40004a64:	01 00 00 00 	nop                                            
        dev = rtems_filesystem_make_dev_t(major, ++minor);            
                                                                      
        part_desc = disk_desc->partitions[part_num];                  
40004a68:	c2 07 00 00 	ld  [ %i4 ], %g1                               
        if (part_desc == NULL)                                        
        {                                                             
            continue;                                                 
        }                                                             
                                                                      
        rc = rtems_disk_create_log(dev, disk_desc->dev, part_desc->start,
40004a6c:	90 10 00 12 	mov  %l2, %o0                                  
    {                                                                 
        sprintf(name, "%s%d", dev_name, part_num + 1);                
        dev = rtems_filesystem_make_dev_t(major, ++minor);            
                                                                      
        part_desc = disk_desc->partitions[part_num];                  
        if (part_desc == NULL)                                        
40004a70:	80 a0 60 00 	cmp  %g1, 0                                    
40004a74:	02 80 00 0a 	be  40004a9c <rtems_ide_part_table_initialize+0xbc>
40004a78:	92 07 40 11 	add  %i5, %l1, %o1                             
        {                                                             
            continue;                                                 
        }                                                             
                                                                      
        rc = rtems_disk_create_log(dev, disk_desc->dev, part_desc->start,
40004a7c:	d8 00 60 04 	ld  [ %g1 + 4 ], %o4                           
40004a80:	da 00 60 08 	ld  [ %g1 + 8 ], %o5                           
40004a84:	d4 1e 80 00 	ldd  [ %i2 ], %o2                              
40004a88:	7f ff fd 47 	call  40003fa4 <rtems_disk_create_log>         
40004a8c:	f6 23 a0 5c 	st  %i3, [ %sp + 0x5c ]                        
                                   part_desc->size, name);            
        if (rc != RTEMS_SUCCESSFUL)                                   
40004a90:	96 92 20 00 	orcc  %o0, 0, %o3                              
40004a94:	12 80 00 0f 	bne  40004ad0 <rtems_ide_part_table_initialize+0xf0><== NEVER TAKEN
40004a98:	c2 05 23 c0 	ld  [ %l4 + 0x3c0 ], %g1                       
40004a9c:	b8 07 20 04 	add  %i4, 4, %i4                               
     */                                                               
                                                                      
    rtems_filesystem_split_dev_t (disk_desc->dev, major, minor);      
                                                                      
    /* create logical disks on the physical one */                    
    for (part_num = 0; part_num < disk_desc->last_log_id; part_num++) 
40004aa0:	c2 06 a0 24 	ld  [ %i2 + 0x24 ], %g1                        
    {                                                                 
        sprintf(name, "%s%d", dev_name, part_num + 1);                
40004aa4:	92 10 00 10 	mov  %l0, %o1                                  
     */                                                               
                                                                      
    rtems_filesystem_split_dev_t (disk_desc->dev, major, minor);      
                                                                      
    /* create logical disks on the physical one */                    
    for (part_num = 0; part_num < disk_desc->last_log_id; part_num++) 
40004aa8:	80 a7 40 01 	cmp  %i5, %g1                                  
    {                                                                 
        sprintf(name, "%s%d", dev_name, part_num + 1);                
40004aac:	94 10 00 19 	mov  %i1, %o2                                  
40004ab0:	ba 07 60 01 	inc  %i5                                       
40004ab4:	90 10 00 1b 	mov  %i3, %o0                                  
     */                                                               
                                                                      
    rtems_filesystem_split_dev_t (disk_desc->dev, major, minor);      
                                                                      
    /* create logical disks on the physical one */                    
    for (part_num = 0; part_num < disk_desc->last_log_id; part_num++) 
40004ab8:	06 bf ff ea 	bl  40004a60 <rtems_ide_part_table_initialize+0x80>
40004abc:	96 10 00 1d 	mov  %i5, %o3                                  
            fprintf(stdout,"Cannot create device %s, error code %d\n", name, rc);
            continue;                                                 
        }                                                             
    }                                                                 
                                                                      
    partition_table_free(disk_desc);                                  
40004ac0:	7f ff fe 7e 	call  400044b8 <partition_table_free>          
40004ac4:	90 10 00 1a 	mov  %i2, %o0                                  
                                                                      
    return RTEMS_SUCCESSFUL;                                          
}                                                                     
40004ac8:	81 c7 e0 08 	ret                                            
40004acc:	81 e8 00 00 	restore                                        
                                                                      
        rc = rtems_disk_create_log(dev, disk_desc->dev, part_desc->start,
                                   part_desc->size, name);            
        if (rc != RTEMS_SUCCESSFUL)                                   
        {                                                             
            fprintf(stdout,"Cannot create device %s, error code %d\n", name, rc);
40004ad0:	92 10 00 13 	mov  %l3, %o1                                  <== NOT EXECUTED
40004ad4:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           <== NOT EXECUTED
40004ad8:	94 10 00 1b 	mov  %i3, %o2                                  <== NOT EXECUTED
40004adc:	40 00 43 dd 	call  40015a50 <fprintf>                       <== NOT EXECUTED
40004ae0:	b8 07 20 04 	add  %i4, 4, %i4                               <== NOT EXECUTED
     */                                                               
                                                                      
    rtems_filesystem_split_dev_t (disk_desc->dev, major, minor);      
                                                                      
    /* create logical disks on the physical one */                    
    for (part_num = 0; part_num < disk_desc->last_log_id; part_num++) 
40004ae4:	10 bf ff f0 	b  40004aa4 <rtems_ide_part_table_initialize+0xc4><== NOT EXECUTED
40004ae8:	c2 06 a0 24 	ld  [ %i2 + 0x24 ], %g1                        <== NOT EXECUTED
                                                                      
    /* get partition table */                                         
    rc = partition_table_get(dev_name, disk_desc);                    
    if (rc != RTEMS_SUCCESSFUL)                                       
    {                                                                 
        free(disk_desc);                                              
40004aec:	40 00 02 23 	call  40005378 <free>                          <== NOT EXECUTED
40004af0:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
40004af4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40004af8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40008e6c <rtems_io_register_driver>: rtems_status_code rtems_io_register_driver( rtems_device_major_number major, const rtems_driver_address_table *driver_table, rtems_device_major_number *registered_major ) {
40008e6c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_device_major_number major_limit = _IO_Number_of_drivers;      
                                                                      
  if ( rtems_interrupt_is_in_progress() )                             
40008e70:	03 10 00 6d 	sethi  %hi(0x4001b400), %g1                    
40008e74:	c4 00 63 e8 	ld  [ %g1 + 0x3e8 ], %g2	! 4001b7e8 <_Per_CPU_Information+0x8>
rtems_status_code rtems_io_register_driver(                           
  rtems_device_major_number         major,                            
  const rtems_driver_address_table *driver_table,                     
  rtems_device_major_number        *registered_major                  
)                                                                     
{                                                                     
40008e78:	ba 10 00 18 	mov  %i0, %i5                                  
  rtems_device_major_number major_limit = _IO_Number_of_drivers;      
40008e7c:	03 10 00 6f 	sethi  %hi(0x4001bc00), %g1                    
rtems_status_code rtems_io_register_driver(                           
  rtems_device_major_number         major,                            
  const rtems_driver_address_table *driver_table,                     
  rtems_device_major_number        *registered_major                  
)                                                                     
{                                                                     
40008e80:	86 10 00 19 	mov  %i1, %g3                                  
  rtems_device_major_number major_limit = _IO_Number_of_drivers;      
40008e84:	c8 00 60 28 	ld  [ %g1 + 0x28 ], %g4                        
                                                                      
  if ( rtems_interrupt_is_in_progress() )                             
40008e88:	80 a0 a0 00 	cmp  %g2, 0                                    
40008e8c:	12 80 00 1f 	bne  40008f08 <rtems_io_register_driver+0x9c>  
40008e90:	b0 10 20 12 	mov  0x12, %i0                                 
    return RTEMS_CALLED_FROM_ISR;                                     
                                                                      
  if ( registered_major == NULL )                                     
40008e94:	80 a6 a0 00 	cmp  %i2, 0                                    
40008e98:	02 80 00 21 	be  40008f1c <rtems_io_register_driver+0xb0>   
40008e9c:	80 a6 60 00 	cmp  %i1, 0                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  /* Set it to an invalid value */                                    
  *registered_major = major_limit;                                    
                                                                      
  if ( driver_table == NULL )                                         
40008ea0:	02 80 00 1f 	be  40008f1c <rtems_io_register_driver+0xb0>   
40008ea4:	c8 26 80 00 	st  %g4, [ %i2 ]                               
                                                                      
static inline bool rtems_io_is_empty_table(                           
  const rtems_driver_address_table *table                             
)                                                                     
{                                                                     
  return table->initialization_entry == NULL && table->open_entry == NULL;
40008ea8:	c4 06 40 00 	ld  [ %i1 ], %g2                               
40008eac:	80 a0 a0 00 	cmp  %g2, 0                                    
40008eb0:	22 80 00 18 	be,a   40008f10 <rtems_io_register_driver+0xa4>
40008eb4:	c4 06 60 04 	ld  [ %i1 + 4 ], %g2                           
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( rtems_io_is_empty_table( driver_table ) )                      
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( major >= major_limit )                                         
40008eb8:	80 a1 00 1d 	cmp  %g4, %i5                                  
40008ebc:	08 80 00 13 	bleu  40008f08 <rtems_io_register_driver+0x9c> 
40008ec0:	b0 10 20 0a 	mov  0xa, %i0                                  
   *                                                                  
   * This rountine increments the thread dispatch level               
   */                                                                 
  RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
  {                                                                   
    uint32_t level = _Thread_Dispatch_disable_level;                  
40008ec4:	05 10 00 6c 	sethi  %hi(0x4001b000), %g2                    
40008ec8:	c8 00 a2 d0 	ld  [ %g2 + 0x2d0 ], %g4	! 4001b2d0 <_Thread_Dispatch_disable_level>
                                                                      
    ++level;                                                          
40008ecc:	88 01 20 01 	inc  %g4                                       
    _Thread_Dispatch_disable_level = level;                           
40008ed0:	c8 20 a2 d0 	st  %g4, [ %g2 + 0x2d0 ]                       
    return RTEMS_INVALID_NUMBER;                                      
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  if ( major == 0 ) {                                                 
40008ed4:	80 a7 60 00 	cmp  %i5, 0                                    
40008ed8:	02 80 00 13 	be  40008f24 <rtems_io_register_driver+0xb8>   
40008edc:	39 10 00 6f 	sethi  %hi(0x4001bc00), %i4                    
      _Thread_Enable_dispatch();                                      
      return sc;                                                      
    }                                                                 
    major = *registered_major;                                        
  } else {                                                            
    rtems_driver_address_table *const table = _IO_Driver_address_table + major;
40008ee0:	c8 07 20 2c 	ld  [ %i4 + 0x2c ], %g4	! 4001bc2c <_IO_Driver_address_table>
40008ee4:	85 2f 60 03 	sll  %i5, 3, %g2                               
40008ee8:	b7 2f 60 05 	sll  %i5, 5, %i3                               
40008eec:	82 26 c0 02 	sub  %i3, %g2, %g1                             
                                                                      
static inline bool rtems_io_is_empty_table(                           
  const rtems_driver_address_table *table                             
)                                                                     
{                                                                     
  return table->initialization_entry == NULL && table->open_entry == NULL;
40008ef0:	f2 01 00 01 	ld  [ %g4 + %g1 ], %i1                         
40008ef4:	80 a6 60 00 	cmp  %i1, 0                                    
40008ef8:	02 80 00 3a 	be  40008fe0 <rtems_io_register_driver+0x174>  
40008efc:	82 01 00 01 	add  %g4, %g1, %g1                             
    major = *registered_major;                                        
  } else {                                                            
    rtems_driver_address_table *const table = _IO_Driver_address_table + major;
                                                                      
    if ( !rtems_io_is_empty_table( table ) ) {                        
      _Thread_Enable_dispatch();                                      
40008f00:	40 00 08 68 	call  4000b0a0 <_Thread_Enable_dispatch>       
40008f04:	b0 10 20 0c 	mov  0xc, %i0                                  
      return RTEMS_RESOURCE_IN_USE;                                   
40008f08:	81 c7 e0 08 	ret                                            
40008f0c:	81 e8 00 00 	restore                                        
                                                                      
static inline bool rtems_io_is_empty_table(                           
  const rtems_driver_address_table *table                             
)                                                                     
{                                                                     
  return table->initialization_entry == NULL && table->open_entry == NULL;
40008f10:	80 a0 a0 00 	cmp  %g2, 0                                    
40008f14:	12 bf ff ea 	bne  40008ebc <rtems_io_register_driver+0x50>  
40008f18:	80 a1 00 1d 	cmp  %g4, %i5                                  
                                                                      
  if ( driver_table == NULL )                                         
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( rtems_io_is_empty_table( driver_table ) )                      
    return RTEMS_INVALID_ADDRESS;                                     
40008f1c:	81 c7 e0 08 	ret                                            
40008f20:	91 e8 20 09 	restore  %g0, 9, %o0                           
                                                                      
static rtems_status_code rtems_io_obtain_major_number(                
  rtems_device_major_number *major                                    
)                                                                     
{                                                                     
  rtems_device_major_number n = _IO_Number_of_drivers;                
40008f24:	c8 00 60 28 	ld  [ %g1 + 0x28 ], %g4                        
  rtems_device_major_number m = 0;                                    
                                                                      
  /* major is error checked by caller */                              
                                                                      
  for ( m = 0; m < n; ++m ) {                                         
40008f28:	80 a1 20 00 	cmp  %g4, 0                                    
40008f2c:	02 80 00 33 	be  40008ff8 <rtems_io_register_driver+0x18c>  <== NEVER TAKEN
40008f30:	c2 07 20 2c 	ld  [ %i4 + 0x2c ], %g1                        
40008f34:	30 80 00 04 	b,a   40008f44 <rtems_io_register_driver+0xd8> 
40008f38:	80 a7 40 04 	cmp  %i5, %g4                                  
40008f3c:	02 80 00 24 	be  40008fcc <rtems_io_register_driver+0x160>  
40008f40:	82 00 60 18 	add  %g1, 0x18, %g1                            
                                                                      
static inline bool rtems_io_is_empty_table(                           
  const rtems_driver_address_table *table                             
)                                                                     
{                                                                     
  return table->initialization_entry == NULL && table->open_entry == NULL;
40008f44:	c4 00 40 00 	ld  [ %g1 ], %g2                               
40008f48:	80 a0 a0 00 	cmp  %g2, 0                                    
40008f4c:	32 bf ff fb 	bne,a   40008f38 <rtems_io_register_driver+0xcc>
40008f50:	ba 07 60 01 	inc  %i5                                       
40008f54:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
40008f58:	80 a0 a0 00 	cmp  %g2, 0                                    
40008f5c:	32 bf ff f7 	bne,a   40008f38 <rtems_io_register_driver+0xcc>
40008f60:	ba 07 60 01 	inc  %i5                                       
    if ( rtems_io_is_empty_table( table ) )                           
      break;                                                          
  }                                                                   
                                                                      
  /* Assigns invalid value in case of failure */                      
  *major = m;                                                         
40008f64:	fa 26 80 00 	st  %i5, [ %i2 ]                               
40008f68:	85 2f 60 03 	sll  %i5, 3, %g2                               
                                                                      
  if ( m != n )                                                       
40008f6c:	80 a1 00 1d 	cmp  %g4, %i5                                  
40008f70:	02 80 00 18 	be  40008fd0 <rtems_io_register_driver+0x164>  <== NEVER TAKEN
40008f74:	b7 2f 60 05 	sll  %i5, 5, %i3                               
    }                                                                 
                                                                      
    *registered_major = major;                                        
  }                                                                   
                                                                      
  _IO_Driver_address_table [major] = *driver_table;                   
40008f78:	c8 00 c0 00 	ld  [ %g3 ], %g4                               
40008f7c:	c2 07 20 2c 	ld  [ %i4 + 0x2c ], %g1                        
40008f80:	84 26 c0 02 	sub  %i3, %g2, %g2                             
40008f84:	c8 20 40 02 	st  %g4, [ %g1 + %g2 ]                         
40008f88:	c8 00 e0 04 	ld  [ %g3 + 4 ], %g4                           
40008f8c:	82 00 40 02 	add  %g1, %g2, %g1                             
40008f90:	c8 20 60 04 	st  %g4, [ %g1 + 4 ]                           
40008f94:	c4 00 e0 08 	ld  [ %g3 + 8 ], %g2                           
                                                                      
  _Thread_Enable_dispatch();                                          
                                                                      
  return rtems_io_initialize( major, 0, NULL );                       
40008f98:	b2 10 20 00 	clr  %i1                                       
    }                                                                 
                                                                      
    *registered_major = major;                                        
  }                                                                   
                                                                      
  _IO_Driver_address_table [major] = *driver_table;                   
40008f9c:	c4 20 60 08 	st  %g2, [ %g1 + 8 ]                           
40008fa0:	c4 00 e0 0c 	ld  [ %g3 + 0xc ], %g2                         
                                                                      
  _Thread_Enable_dispatch();                                          
                                                                      
  return rtems_io_initialize( major, 0, NULL );                       
40008fa4:	b4 10 20 00 	clr  %i2                                       
    }                                                                 
                                                                      
    *registered_major = major;                                        
  }                                                                   
                                                                      
  _IO_Driver_address_table [major] = *driver_table;                   
40008fa8:	c4 20 60 0c 	st  %g2, [ %g1 + 0xc ]                         
40008fac:	c4 00 e0 10 	ld  [ %g3 + 0x10 ], %g2                        
                                                                      
  _Thread_Enable_dispatch();                                          
                                                                      
  return rtems_io_initialize( major, 0, NULL );                       
40008fb0:	b0 10 00 1d 	mov  %i5, %i0                                  
    }                                                                 
                                                                      
    *registered_major = major;                                        
  }                                                                   
                                                                      
  _IO_Driver_address_table [major] = *driver_table;                   
40008fb4:	c4 20 60 10 	st  %g2, [ %g1 + 0x10 ]                        
40008fb8:	c4 00 e0 14 	ld  [ %g3 + 0x14 ], %g2                        
                                                                      
  _Thread_Enable_dispatch();                                          
40008fbc:	40 00 08 39 	call  4000b0a0 <_Thread_Enable_dispatch>       
40008fc0:	c4 20 60 14 	st  %g2, [ %g1 + 0x14 ]                        
                                                                      
  return rtems_io_initialize( major, 0, NULL );                       
40008fc4:	40 00 21 e9 	call  40011768 <rtems_io_initialize>           
40008fc8:	81 e8 00 00 	restore                                        
    if ( rtems_io_is_empty_table( table ) )                           
      break;                                                          
  }                                                                   
                                                                      
  /* Assigns invalid value in case of failure */                      
  *major = m;                                                         
40008fcc:	fa 26 80 00 	st  %i5, [ %i2 ]                               
                                                                      
  if ( major == 0 ) {                                                 
    rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
                                                                      
    if ( sc != RTEMS_SUCCESSFUL ) {                                   
      _Thread_Enable_dispatch();                                      
40008fd0:	40 00 08 34 	call  4000b0a0 <_Thread_Enable_dispatch>       
40008fd4:	b0 10 20 05 	mov  5, %i0                                    
      return sc;                                                      
40008fd8:	81 c7 e0 08 	ret                                            
40008fdc:	81 e8 00 00 	restore                                        
                                                                      
static inline bool rtems_io_is_empty_table(                           
  const rtems_driver_address_table *table                             
)                                                                     
{                                                                     
  return table->initialization_entry == NULL && table->open_entry == NULL;
40008fe0:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
40008fe4:	80 a0 60 00 	cmp  %g1, 0                                    
40008fe8:	12 bf ff c6 	bne  40008f00 <rtems_io_register_driver+0x94>  
40008fec:	01 00 00 00 	nop                                            
    if ( !rtems_io_is_empty_table( table ) ) {                        
      _Thread_Enable_dispatch();                                      
      return RTEMS_RESOURCE_IN_USE;                                   
    }                                                                 
                                                                      
    *registered_major = major;                                        
40008ff0:	10 bf ff e2 	b  40008f78 <rtems_io_register_driver+0x10c>   
40008ff4:	fa 26 80 00 	st  %i5, [ %i2 ]                               
    if ( rtems_io_is_empty_table( table ) )                           
      break;                                                          
  }                                                                   
                                                                      
  /* Assigns invalid value in case of failure */                      
  *major = m;                                                         
40008ff8:	10 bf ff f6 	b  40008fd0 <rtems_io_register_driver+0x164>   <== NOT EXECUTED
40008ffc:	c0 26 80 00 	clr  [ %i2 ]                                   <== NOT EXECUTED
                                                                      

4000a160 <rtems_iterate_over_all_threads>: #include <rtems/system.h> #include <rtems/score/thread.h> void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) {
4000a160:	9d e3 bf a0 	save  %sp, -96, %sp                            
  uint32_t             i;                                             
  uint32_t             api_index;                                     
  Thread_Control      *the_thread;                                    
  Objects_Information *information;                                   
                                                                      
  if ( !routine )                                                     
4000a164:	80 a6 20 00 	cmp  %i0, 0                                    
4000a168:	02 80 00 20 	be  4000a1e8 <rtems_iterate_over_all_threads+0x88><== NEVER TAKEN
4000a16c:	37 10 00 86 	sethi  %hi(0x40021800), %i3                    
4000a170:	b6 16 e2 58 	or  %i3, 0x258, %i3	! 40021a58 <_Objects_Information_table+0x4>
#endif                                                                
                                                                      
#include <rtems/system.h>                                             
#include <rtems/score/thread.h>                                       
                                                                      
void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) 
4000a174:	b4 06 e0 0c 	add  %i3, 0xc, %i2                             
    #if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)             
      if ( !_Objects_Information_table[ api_index ] )                 
        continue;                                                     
    #endif                                                            
                                                                      
    information = _Objects_Information_table[ api_index ][ 1 ];       
4000a178:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
4000a17c:	f8 00 60 04 	ld  [ %g1 + 4 ], %i4                           
    if ( !information )                                               
4000a180:	80 a7 20 00 	cmp  %i4, 0                                    
4000a184:	22 80 00 16 	be,a   4000a1dc <rtems_iterate_over_all_threads+0x7c>
4000a188:	b6 06 e0 04 	add  %i3, 4, %i3                               
      continue;                                                       
                                                                      
    for ( i=1 ; i <= information->maximum ; i++ ) {                   
4000a18c:	c2 17 20 10 	lduh  [ %i4 + 0x10 ], %g1                      
4000a190:	86 90 60 00 	orcc  %g1, 0, %g3                              
4000a194:	22 80 00 12 	be,a   4000a1dc <rtems_iterate_over_all_threads+0x7c>
4000a198:	b6 06 e0 04 	add  %i3, 4, %i3                               
4000a19c:	ba 10 20 01 	mov  1, %i5                                    
      the_thread = (Thread_Control *)information->local_table[ i ];   
4000a1a0:	c4 07 20 1c 	ld  [ %i4 + 0x1c ], %g2                        
4000a1a4:	83 2f 60 02 	sll  %i5, 2, %g1                               
4000a1a8:	c2 00 80 01 	ld  [ %g2 + %g1 ], %g1                         
                                                                      
      if ( !the_thread )                                              
4000a1ac:	90 90 60 00 	orcc  %g1, 0, %o0                              
4000a1b0:	02 80 00 05 	be  4000a1c4 <rtems_iterate_over_all_threads+0x64><== NEVER TAKEN
4000a1b4:	ba 07 60 01 	inc  %i5                                       
	continue;                                                            
                                                                      
      (*routine)(the_thread);                                         
4000a1b8:	9f c6 00 00 	call  %i0                                      
4000a1bc:	01 00 00 00 	nop                                            
4000a1c0:	c6 17 20 10 	lduh  [ %i4 + 0x10 ], %g3                      
                                                                      
    information = _Objects_Information_table[ api_index ][ 1 ];       
    if ( !information )                                               
      continue;                                                       
                                                                      
    for ( i=1 ; i <= information->maximum ; i++ ) {                   
4000a1c4:	83 28 e0 10 	sll  %g3, 0x10, %g1                            
4000a1c8:	83 30 60 10 	srl  %g1, 0x10, %g1                            
4000a1cc:	80 a0 40 1d 	cmp  %g1, %i5                                  
4000a1d0:	3a bf ff f5 	bcc,a   4000a1a4 <rtems_iterate_over_all_threads+0x44>
4000a1d4:	c4 07 20 1c 	ld  [ %i4 + 0x1c ], %g2                        
4000a1d8:	b6 06 e0 04 	add  %i3, 4, %i3                               
  Objects_Information *information;                                   
                                                                      
  if ( !routine )                                                     
    return;                                                           
                                                                      
  for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
4000a1dc:	80 a6 c0 1a 	cmp  %i3, %i2                                  
4000a1e0:	32 bf ff e7 	bne,a   4000a17c <rtems_iterate_over_all_threads+0x1c>
4000a1e4:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
4000a1e8:	81 c7 e0 08 	ret                                            
4000a1ec:	81 e8 00 00 	restore                                        
                                                                      

40003178 <rtems_libio_init>: rtems_id rtems_libio_semaphore; rtems_libio_t *rtems_libio_iops; rtems_libio_t *rtems_libio_iop_freelist; void rtems_libio_init( void ) {
40003178:	9d e3 bf a0 	save  %sp, -96, %sp                            
    rtems_status_code rc;                                             
    uint32_t i;                                                       
    rtems_libio_t *iop;                                               
                                                                      
    if (rtems_libio_number_iops > 0)                                  
4000317c:	03 10 00 78 	sethi  %hi(0x4001e000), %g1                    
40003180:	fa 00 63 a4 	ld  [ %g1 + 0x3a4 ], %i5	! 4001e3a4 <rtems_libio_number_iops>
40003184:	80 a7 60 00 	cmp  %i5, 0                                    
40003188:	02 80 00 1b 	be  400031f4 <rtems_libio_init+0x7c>           <== NEVER TAKEN
4000318c:	92 10 20 01 	mov  1, %o1                                    
    {                                                                 
        rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
40003190:	90 10 00 1d 	mov  %i5, %o0                                  
40003194:	7f ff fe f6 	call  40002d6c <calloc>                        
40003198:	92 10 20 38 	mov  0x38, %o1                                 
4000319c:	03 10 00 7b 	sethi  %hi(0x4001ec00), %g1                    
                                                    sizeof(rtems_libio_t));
        if (rtems_libio_iops == NULL)                                 
400031a0:	80 a2 20 00 	cmp  %o0, 0                                    
400031a4:	02 80 00 28 	be  40003244 <rtems_libio_init+0xcc>           
400031a8:	d0 20 61 30 	st  %o0, [ %g1 + 0x130 ]                       
            rtems_fatal_error_occurred(RTEMS_NO_MEMORY);              
                                                                      
        iop = rtems_libio_iop_freelist = rtems_libio_iops;            
400031ac:	03 10 00 7b 	sethi  %hi(0x4001ec00), %g1                    
        for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)  
400031b0:	80 a7 60 01 	cmp  %i5, 1                                    
400031b4:	08 80 00 0e 	bleu  400031ec <rtems_libio_init+0x74>         
400031b8:	d0 20 61 34 	st  %o0, [ %g1 + 0x134 ]                       
400031bc:	82 10 00 08 	mov  %o0, %g1                                  
400031c0:	84 10 20 01 	mov  1, %g2                                    
          iop->data1 = iop + 1;                                       
400031c4:	82 00 60 38 	add  %g1, 0x38, %g1                            
                                                    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++)  
400031c8:	84 00 a0 01 	inc  %g2                                       
400031cc:	80 a0 80 1d 	cmp  %g2, %i5                                  
400031d0:	12 bf ff fd 	bne  400031c4 <rtems_libio_init+0x4c>          
400031d4:	c2 20 7f f8 	st  %g1, [ %g1 + -8 ]                          
                                                                      
rtems_id           rtems_libio_semaphore;                             
rtems_libio_t     *rtems_libio_iops;                                  
rtems_libio_t     *rtems_libio_iop_freelist;                          
                                                                      
void rtems_libio_init( void )                                         
400031d8:	84 00 bf ff 	add  %g2, -1, %g2                              
400031dc:	83 28 a0 03 	sll  %g2, 3, %g1                               
400031e0:	85 28 a0 06 	sll  %g2, 6, %g2                               
400031e4:	84 20 80 01 	sub  %g2, %g1, %g2                             
400031e8:	90 02 00 02 	add  %o0, %g2, %o0                             
            rtems_fatal_error_occurred(RTEMS_NO_MEMORY);              
                                                                      
        iop = rtems_libio_iop_freelist = rtems_libio_iops;            
        for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)  
          iop->data1 = iop + 1;                                       
        iop->data1 = NULL;                                            
400031ec:	c0 22 20 30 	clr  [ %o0 + 0x30 ]                            
  /*                                                                  
   *  Create the binary semaphore used to provide mutual exclusion    
   *  on the IOP Table.                                               
   */                                                                 
                                                                      
  rc = rtems_semaphore_create(                                        
400031f0:	92 10 20 01 	mov  1, %o1                                    
400031f4:	11 13 10 92 	sethi  %hi(0x4c424800), %o0                    
400031f8:	94 10 20 54 	mov  0x54, %o2                                 
400031fc:	90 12 21 4f 	or  %o0, 0x14f, %o0                            
40003200:	96 10 20 00 	clr  %o3                                       
40003204:	19 10 00 7b 	sethi  %hi(0x4001ec00), %o4                    
40003208:	40 00 0f b9 	call  400070ec <rtems_semaphore_create>        
4000320c:	98 13 21 38 	or  %o4, 0x138, %o4	! 4001ed38 <rtems_libio_semaphore>
    1,                                                                
    RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, 
    RTEMS_NO_PRIORITY,                                                
    &rtems_libio_semaphore                                            
  );                                                                  
  if ( rc != RTEMS_SUCCESSFUL )                                       
40003210:	80 a2 20 00 	cmp  %o0, 0                                    
40003214:	12 80 00 0a 	bne  4000323c <rtems_libio_init+0xc4>          <== NEVER TAKEN
40003218:	03 10 00 78 	sethi  %hi(0x4001e000), %g1                    
                                                                      
  /*                                                                  
   *  Initialize the base file system infrastructure.                 
   */                                                                 
                                                                      
  if (rtems_fs_init_helper)                                           
4000321c:	c2 00 63 a8 	ld  [ %g1 + 0x3a8 ], %g1	! 4001e3a8 <rtems_fs_init_helper>
40003220:	80 a0 60 00 	cmp  %g1, 0                                    
40003224:	02 80 00 04 	be  40003234 <rtems_libio_init+0xbc>           
40003228:	01 00 00 00 	nop                                            
     (* rtems_fs_init_helper)();                                      
4000322c:	9f c0 40 00 	call  %g1                                      
40003230:	01 00 00 00 	nop                                            
40003234:	81 c7 e0 08 	ret                                            
40003238:	81 e8 00 00 	restore                                        
    RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, 
    RTEMS_NO_PRIORITY,                                                
    &rtems_libio_semaphore                                            
  );                                                                  
  if ( rc != RTEMS_SUCCESSFUL )                                       
    rtems_fatal_error_occurred( rc );                                 
4000323c:	40 00 12 39 	call  40007b20 <rtems_fatal_error_occurred>    <== NOT EXECUTED
40003240:	01 00 00 00 	nop                                            <== NOT EXECUTED
    if (rtems_libio_number_iops > 0)                                  
    {                                                                 
        rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
                                                    sizeof(rtems_libio_t));
        if (rtems_libio_iops == NULL)                                 
            rtems_fatal_error_occurred(RTEMS_NO_MEMORY);              
40003244:	40 00 12 37 	call  40007b20 <rtems_fatal_error_occurred>    
40003248:	90 10 20 1a 	mov  0x1a, %o0	! 1a <PROM_START+0x1a>          
                                                                      

40004628 <rtems_libio_set_private_env>: } rtems_status_code rtems_libio_set_private_env(void) {
40004628:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_id self_task_id = rtems_task_self();                          
4000462c:	40 00 06 73 	call  40005ff8 <rtems_task_self>               
40004630:	37 10 00 54 	sethi  %hi(0x40015000), %i3                    
  rtems_user_env_t *old_env = rtems_current_user_env;                 
40004634:	fa 06 e2 5c 	ld  [ %i3 + 0x25c ], %i5	! 4001525c <rtems_current_user_env>
  bool uses_global_env = old_env == &rtems_global_user_env;           
  bool uses_shared_env = old_env->task_id != self_task_id;            
40004638:	c2 07 60 24 	ld  [ %i5 + 0x24 ], %g1                        
                                                                      
  if (uses_global_env || uses_shared_env) {                           
4000463c:	80 a0 40 08 	cmp  %g1, %o0                                  
40004640:	12 80 00 07 	bne  4000465c <rtems_libio_set_private_env+0x34>
40004644:	b8 10 00 08 	mov  %o0, %i4                                  
rtems_status_code rtems_libio_set_private_env(void)                   
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_id self_task_id = rtems_task_self();                          
  rtems_user_env_t *old_env = rtems_current_user_env;                 
  bool uses_global_env = old_env == &rtems_global_user_env;           
40004648:	03 10 00 54 	sethi  %hi(0x40015000), %g1                    
4000464c:	82 10 62 60 	or  %g1, 0x260, %g1	! 40015260 <rtems_global_user_env>
  bool uses_shared_env = old_env->task_id != self_task_id;            
                                                                      
  if (uses_global_env || uses_shared_env) {                           
40004650:	80 a7 40 01 	cmp  %i5, %g1                                  
40004654:	12 80 00 2a 	bne  400046fc <rtems_libio_set_private_env+0xd4><== ALWAYS TAKEN
40004658:	b0 10 20 00 	clr  %i0                                       
    rtems_user_env_t *new_env = calloc(1, sizeof(*new_env));          
4000465c:	90 10 20 01 	mov  1, %o0                                    
40004660:	92 10 20 2c 	mov  0x2c, %o1                                 
40004664:	40 00 14 a6 	call  400098fc <calloc>                        
40004668:	b0 10 20 1a 	mov  0x1a, %i0                                 
                                                                      
    if (new_env != NULL) {                                            
4000466c:	80 a2 20 00 	cmp  %o0, 0                                    
40004670:	02 80 00 23 	be  400046fc <rtems_libio_set_private_env+0xd4>
40004674:	b4 10 00 08 	mov  %o0, %i2                                  
      *new_env = *old_env;                                            
40004678:	92 10 00 1d 	mov  %i5, %o1                                  
4000467c:	40 00 20 b0 	call  4000c93c <memcpy>                        
40004680:	94 10 20 2c 	mov  0x2c, %o2                                 
      new_env->reference_count = 1;                                   
40004684:	82 10 20 01 	mov  1, %g1                                    
      new_env->task_id = self_task_id;                                
      new_env->root_directory =                                       
        rtems_filesystem_global_location_obtain(&old_env->root_directory);
40004688:	90 07 60 04 	add  %i5, 4, %o0                               
  if (uses_global_env || uses_shared_env) {                           
    rtems_user_env_t *new_env = calloc(1, sizeof(*new_env));          
                                                                      
    if (new_env != NULL) {                                            
      *new_env = *old_env;                                            
      new_env->reference_count = 1;                                   
4000468c:	c2 26 a0 28 	st  %g1, [ %i2 + 0x28 ]                        
      new_env->task_id = self_task_id;                                
      new_env->root_directory =                                       
        rtems_filesystem_global_location_obtain(&old_env->root_directory);
40004690:	40 00 03 10 	call  400052d0 <rtems_filesystem_global_location_obtain>
40004694:	f8 26 a0 24 	st  %i4, [ %i2 + 0x24 ]                        
                                                                      
    if (new_env != NULL) {                                            
      *new_env = *old_env;                                            
      new_env->reference_count = 1;                                   
      new_env->task_id = self_task_id;                                
      new_env->root_directory =                                       
40004698:	d0 26 a0 04 	st  %o0, [ %i2 + 4 ]                           
        rtems_filesystem_global_location_obtain(&old_env->root_directory);
      new_env->current_directory =                                    
        rtems_filesystem_global_location_obtain(&old_env->current_directory);
4000469c:	40 00 03 0d 	call  400052d0 <rtems_filesystem_global_location_obtain>
400046a0:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
static inline bool rtems_filesystem_location_is_null(                 
  const rtems_filesystem_location_info_t *loc                         
)                                                                     
{                                                                     
  return loc->handlers == &rtems_filesystem_null_handlers;            
400046a4:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1                           
      *new_env = *old_env;                                            
      new_env->reference_count = 1;                                   
      new_env->task_id = self_task_id;                                
      new_env->root_directory =                                       
        rtems_filesystem_global_location_obtain(&old_env->root_directory);
      new_env->current_directory =                                    
400046a8:	d0 26 80 00 	st  %o0, [ %i2 ]                               
        rtems_filesystem_global_location_obtain(&old_env->current_directory);
                                                                      
      if (                                                            
400046ac:	c4 00 60 10 	ld  [ %g1 + 0x10 ], %g2                        
400046b0:	03 10 00 51 	sethi  %hi(0x40014400), %g1                    
400046b4:	82 10 63 14 	or  %g1, 0x314, %g1	! 40014714 <rtems_filesystem_null_handlers>
400046b8:	80 a0 80 01 	cmp  %g2, %g1                                  
400046bc:	22 80 00 0e 	be,a   400046f4 <rtems_libio_set_private_env+0xcc>
400046c0:	b0 10 20 0d 	mov  0xd, %i0                                  
        !rtems_filesystem_global_location_is_null(new_env->root_directory)
          && !rtems_filesystem_global_location_is_null(new_env->current_directory)
400046c4:	c4 02 20 10 	ld  [ %o0 + 0x10 ], %g2                        
400046c8:	80 a0 80 01 	cmp  %g2, %g1                                  
400046cc:	02 80 00 0e 	be  40004704 <rtems_libio_set_private_env+0xdc><== NEVER TAKEN
400046d0:	90 10 20 00 	clr  %o0                                       
      ) {                                                             
        sc = rtems_task_variable_add(                                 
400046d4:	92 16 e2 5c 	or  %i3, 0x25c, %o1                            
400046d8:	15 10 00 11 	sethi  %hi(0x40004400), %o2                    
400046dc:	40 00 06 69 	call  40006080 <rtems_task_variable_add>       
400046e0:	94 12 a1 b8 	or  %o2, 0x1b8, %o2	! 400045b8 <free_user_env> 
          RTEMS_SELF,                                                 
          (void **) &rtems_current_user_env,                          
          free_user_env                                               
        );                                                            
        if (sc == RTEMS_SUCCESSFUL) {                                 
400046e4:	b0 92 20 00 	orcc  %o0, 0, %i0                              
400046e8:	02 80 00 09 	be  4000470c <rtems_libio_set_private_env+0xe4>
400046ec:	01 00 00 00 	nop                                            
          free_user_env_protected(old_env);                           
          rtems_current_user_env = new_env;                           
        } else {                                                      
          sc = RTEMS_TOO_MANY;                                        
400046f0:	b0 10 20 05 	mov  5, %i0	! 5 <PROM_START+0x5>               
      } else {                                                        
        sc = RTEMS_UNSATISFIED;                                       
      }                                                               
                                                                      
      if (sc != RTEMS_SUCCESSFUL) {                                   
        free_user_env(new_env);                                       
400046f4:	7f ff ff b1 	call  400045b8 <free_user_env>                 
400046f8:	90 10 00 1a 	mov  %i2, %o0                                  
      sc = RTEMS_NO_MEMORY;                                           
    }                                                                 
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
400046fc:	81 c7 e0 08 	ret                                            
40004700:	81 e8 00 00 	restore                                        
          rtems_current_user_env = new_env;                           
        } else {                                                      
          sc = RTEMS_TOO_MANY;                                        
        }                                                             
      } else {                                                        
        sc = RTEMS_UNSATISFIED;                                       
40004704:	10 bf ff fc 	b  400046f4 <rtems_libio_set_private_env+0xcc> <== NOT EXECUTED
40004708:	b0 10 20 0d 	mov  0xd, %i0                                  <== NOT EXECUTED
          RTEMS_SELF,                                                 
          (void **) &rtems_current_user_env,                          
          free_user_env                                               
        );                                                            
        if (sc == RTEMS_SUCCESSFUL) {                                 
          free_user_env_protected(old_env);                           
4000470c:	7f ff ff be 	call  40004604 <free_user_env_protected>       
40004710:	90 10 00 1d 	mov  %i5, %o0                                  
          rtems_current_user_env = new_env;                           
40004714:	03 10 00 54 	sethi  %hi(0x40015000), %g1                    
40004718:	f4 20 62 5c 	st  %i2, [ %g1 + 0x25c ]	! 4001525c <rtems_current_user_env>
4000471c:	81 c7 e0 08 	ret                                            
40004720:	81 e8 00 00 	restore                                        
                                                                      

40004724 <rtems_libio_share_private_env>: return sc; } rtems_status_code rtems_libio_share_private_env(rtems_id task_id) {
40004724:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_id self_task_id = rtems_task_self();                          
40004728:	40 00 06 34 	call  40005ff8 <rtems_task_self>               
4000472c:	01 00 00 00 	nop                                            
                                                                      
  if (task_id != RTEMS_SELF && self_task_id != task_id) {             
40004730:	80 a2 00 18 	cmp  %o0, %i0                                  
40004734:	12 80 00 04 	bne  40004744 <rtems_libio_share_private_env+0x20>
40004738:	80 a6 20 00 	cmp  %i0, 0                                    
  return sc;                                                          
}                                                                     
                                                                      
rtems_status_code rtems_libio_share_private_env(rtems_id task_id)     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
4000473c:	81 c7 e0 08 	ret                                            
40004740:	91 e8 20 00 	restore  %g0, 0, %o0                           
  rtems_id self_task_id = rtems_task_self();                          
                                                                      
  if (task_id != RTEMS_SELF && self_task_id != task_id) {             
40004744:	02 bf ff fe 	be  4000473c <rtems_libio_share_private_env+0x18>
40004748:	03 10 00 57 	sethi  %hi(0x40015c00), %g1                    
   *                                                                  
   * This rountine increments the thread dispatch level               
   */                                                                 
  RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
  {                                                                   
    uint32_t level = _Thread_Dispatch_disable_level;                  
4000474c:	c4 00 60 c0 	ld  [ %g1 + 0xc0 ], %g2	! 40015cc0 <_Thread_Dispatch_disable_level>
                                                                      
    ++level;                                                          
40004750:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
40004754:	c4 20 60 c0 	st  %g2, [ %g1 + 0xc0 ]                        
    /*                                                                
     * We have to disable the thread dispatching to prevent deletion of the
     * environment in the meantime.                                   
     */                                                               
    _Thread_Disable_dispatch();                                       
    sc = rtems_task_variable_get(                                     
40004758:	3b 10 00 54 	sethi  %hi(0x40015000), %i5                    
4000475c:	90 10 00 18 	mov  %i0, %o0                                  
40004760:	92 17 62 5c 	or  %i5, 0x25c, %o1                            
40004764:	40 00 06 a7 	call  40006200 <rtems_task_variable_get>       
40004768:	94 07 bf fc 	add  %fp, -4, %o2                              
      task_id,                                                        
      (void *) &rtems_current_user_env,                               
      (void *) &env                                                   
    );                                                                
    if (sc == RTEMS_SUCCESSFUL) {                                     
4000476c:	80 a2 20 00 	cmp  %o0, 0                                    
40004770:	12 80 00 14 	bne  400047c0 <rtems_libio_share_private_env+0x9c>
40004774:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
      ++env->reference_count;                                         
40004778:	c4 00 60 28 	ld  [ %g1 + 0x28 ], %g2                        
4000477c:	84 00 a0 01 	inc  %g2                                       
    } else {                                                          
      sc = RTEMS_UNSATISFIED;                                         
    }                                                                 
    _Thread_Enable_dispatch();                                        
40004780:	40 00 0f 1c 	call  400083f0 <_Thread_Enable_dispatch>       
40004784:	c4 20 60 28 	st  %g2, [ %g1 + 0x28 ]                        
                                                                      
    if (sc == RTEMS_SUCCESSFUL) {                                     
      sc = rtems_task_variable_add(                                   
40004788:	90 10 20 00 	clr  %o0                                       
4000478c:	92 17 62 5c 	or  %i5, 0x25c, %o1                            
40004790:	15 10 00 11 	sethi  %hi(0x40004400), %o2                    
40004794:	40 00 06 3b 	call  40006080 <rtems_task_variable_add>       
40004798:	94 12 a1 b8 	or  %o2, 0x1b8, %o2	! 400045b8 <free_user_env> 
        RTEMS_SELF,                                                   
        (void **) &rtems_current_user_env,                            
        free_user_env                                                 
      );                                                              
      if (sc == RTEMS_SUCCESSFUL) {                                   
4000479c:	b0 92 20 00 	orcc  %o0, 0, %i0                              
400047a0:	12 80 00 0c 	bne  400047d0 <rtems_libio_share_private_env+0xac><== NEVER TAKEN
400047a4:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
        free_user_env_protected(rtems_current_user_env);              
400047a8:	7f ff ff 97 	call  40004604 <free_user_env_protected>       
400047ac:	d0 07 62 5c 	ld  [ %i5 + 0x25c ], %o0                       
        rtems_current_user_env = env;                                 
400047b0:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
400047b4:	c2 27 62 5c 	st  %g1, [ %i5 + 0x25c ]                       
400047b8:	81 c7 e0 08 	ret                                            
400047bc:	81 e8 00 00 	restore                                        
    if (sc == RTEMS_SUCCESSFUL) {                                     
      ++env->reference_count;                                         
    } else {                                                          
      sc = RTEMS_UNSATISFIED;                                         
    }                                                                 
    _Thread_Enable_dispatch();                                        
400047c0:	40 00 0f 0c 	call  400083f0 <_Thread_Enable_dispatch>       
400047c4:	b0 10 20 0d 	mov  0xd, %i0                                  
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
400047c8:	81 c7 e0 08 	ret                                            
400047cc:	81 e8 00 00 	restore                                        
      );                                                              
      if (sc == RTEMS_SUCCESSFUL) {                                   
        free_user_env_protected(rtems_current_user_env);              
        rtems_current_user_env = env;                                 
      } else {                                                        
        free_user_env_protected(env);                                 
400047d0:	7f ff ff 8d 	call  40004604 <free_user_env_protected>       <== NOT EXECUTED
400047d4:	b0 10 20 05 	mov  5, %i0                                    <== NOT EXECUTED
400047d8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400047dc:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4000be80 <rtems_libio_to_fcntl_flags>: int rtems_libio_to_fcntl_flags( uint32_t flags ) {
4000be80:	82 10 00 08 	mov  %o0, %g1                                  
  int fcntl_flags = 0;                                                
                                                                      
  if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { 
4000be84:	84 08 60 06 	and  %g1, 6, %g2                               
4000be88:	80 a0 a0 06 	cmp  %g2, 6                                    
4000be8c:	02 80 00 05 	be  4000bea0 <rtems_libio_to_fcntl_flags+0x20> 
4000be90:	90 10 20 02 	mov  2, %o0                                    
    fcntl_flags |= O_RDWR;                                            
  } else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {       
4000be94:	80 88 60 02 	btst  2, %g1                                   
4000be98:	02 80 00 0e 	be  4000bed0 <rtems_libio_to_fcntl_flags+0x50> <== NEVER TAKEN
4000be9c:	90 10 20 00 	clr  %o0                                       
    fcntl_flags |= O_RDONLY;                                          
  } else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) {     
    fcntl_flags |= O_WRONLY;                                          
  }                                                                   
                                                                      
  if ( (flags & LIBIO_FLAGS_NO_DELAY) == LIBIO_FLAGS_NO_DELAY ) {     
4000bea0:	80 88 60 01 	btst  1, %g1                                   
4000bea4:	02 80 00 04 	be  4000beb4 <rtems_libio_to_fcntl_flags+0x34> 
4000bea8:	80 88 62 00 	btst  0x200, %g1                               
    fcntl_flags |= O_NONBLOCK;                                        
4000beac:	05 00 00 10 	sethi  %hi(0x4000), %g2                        
4000beb0:	90 12 00 02 	or  %o0, %g2, %o0                              
  }                                                                   
                                                                      
  if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {         
4000beb4:	32 80 00 02 	bne,a   4000bebc <rtems_libio_to_fcntl_flags+0x3c>
4000beb8:	90 12 20 08 	or  %o0, 8, %o0                                
    fcntl_flags |= O_APPEND;                                          
  }                                                                   
                                                                      
  if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {         
4000bebc:	80 88 64 00 	btst  0x400, %g1                               
4000bec0:	32 80 00 02 	bne,a   4000bec8 <rtems_libio_to_fcntl_flags+0x48>
4000bec4:	90 12 22 00 	or  %o0, 0x200, %o0                            
    fcntl_flags |= O_CREAT;                                           
  }                                                                   
                                                                      
  return fcntl_flags;                                                 
}                                                                     
4000bec8:	81 c3 e0 08 	retl                                           
4000becc:	01 00 00 00 	nop                                            
                                                                      
  if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { 
    fcntl_flags |= O_RDWR;                                            
  } else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {       
    fcntl_flags |= O_RDONLY;                                          
  } else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) {     
4000bed0:	91 30 60 02 	srl  %g1, 2, %o0                               <== NOT EXECUTED
4000bed4:	10 bf ff f3 	b  4000bea0 <rtems_libio_to_fcntl_flags+0x20>  <== NOT EXECUTED
4000bed8:	90 0a 20 01 	and  %o0, 1, %o0                               <== NOT EXECUTED
                                                                      

400047e0 <rtems_libio_use_global_env>: return sc; } void rtems_libio_use_global_env(void) {
400047e0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_user_env_t *env = rtems_current_user_env;                     
  bool uses_private_env = env != &rtems_global_user_env;              
                                                                      
  if (uses_private_env) {                                             
400047e4:	3b 10 00 54 	sethi  %hi(0x40015000), %i5                    
400047e8:	c2 07 62 5c 	ld  [ %i5 + 0x25c ], %g1	! 4001525c <rtems_current_user_env>
400047ec:	39 10 00 54 	sethi  %hi(0x40015000), %i4                    
400047f0:	b8 17 22 60 	or  %i4, 0x260, %i4	! 40015260 <rtems_global_user_env>
400047f4:	80 a0 40 1c 	cmp  %g1, %i4                                  
400047f8:	02 80 00 08 	be  40004818 <rtems_libio_use_global_env+0x38> 
400047fc:	92 17 62 5c 	or  %i5, 0x25c, %o1                            
    sc = rtems_task_variable_delete(                                  
40004800:	40 00 06 52 	call  40006148 <rtems_task_variable_delete>    
40004804:	90 10 20 00 	clr  %o0                                       
      RTEMS_SELF,                                                     
      (void **) &rtems_current_user_env                               
    );                                                                
    if (sc != RTEMS_SUCCESSFUL) {                                     
40004808:	80 a2 20 00 	cmp  %o0, 0                                    
4000480c:	12 80 00 05 	bne  40004820 <rtems_libio_use_global_env+0x40><== NEVER TAKEN
40004810:	11 37 ab 6f 	sethi  %hi(0xdeadbc00), %o0                    
      rtems_fatal_error_occurred(0xdeadbeef);                         
    }                                                                 
                                                                      
    rtems_current_user_env = &rtems_global_user_env;                  
40004814:	f8 27 62 5c 	st  %i4, [ %i5 + 0x25c ]                       
40004818:	81 c7 e0 08 	ret                                            
4000481c:	81 e8 00 00 	restore                                        
    sc = rtems_task_variable_delete(                                  
      RTEMS_SELF,                                                     
      (void **) &rtems_current_user_env                               
    );                                                                
    if (sc != RTEMS_SUCCESSFUL) {                                     
      rtems_fatal_error_occurred(0xdeadbeef);                         
40004820:	40 00 07 0c 	call  40006450 <rtems_fatal_error_occurred>    <== NOT EXECUTED
40004824:	90 12 22 ef 	or  %o0, 0x2ef, %o0                            <== NOT EXECUTED
                                                                      

400078c0 <rtems_malloc_statistics_at_free>: * size and thus we skip updating the statistics. */ static void rtems_malloc_statistics_at_free( void *pointer ) {
400078c0:	9d e3 bf 98 	save  %sp, -104, %sp                           
  uintptr_t size;                                                     
                                                                      
  if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
400078c4:	03 10 00 93 	sethi  %hi(0x40024c00), %g1                    
400078c8:	d0 00 61 b4 	ld  [ %g1 + 0x1b4 ], %o0	! 40024db4 <RTEMS_Malloc_Heap>
400078cc:	92 10 00 18 	mov  %i0, %o1                                  
400078d0:	40 00 1c ef 	call  4000ec8c <_Protected_heap_Get_block_size>
400078d4:	94 07 bf fc 	add  %fp, -4, %o2                              
400078d8:	80 8a 20 ff 	btst  0xff, %o0                                
400078dc:	02 80 00 08 	be  400078fc <rtems_malloc_statistics_at_free+0x3c><== NEVER TAKEN
400078e0:	03 10 00 98 	sethi  %hi(0x40026000), %g1                    
    MSBUMP(lifetime_freed, size);                                     
400078e4:	c8 07 bf fc 	ld  [ %fp + -4 ], %g4                          
400078e8:	82 10 60 80 	or  %g1, 0x80, %g1                             
400078ec:	c4 18 60 28 	ldd  [ %g1 + 0x28 ], %g2                       
400078f0:	86 80 c0 04 	addcc  %g3, %g4, %g3                           
400078f4:	84 40 a0 00 	addx  %g2, 0, %g2                              
400078f8:	c4 38 60 28 	std  %g2, [ %g1 + 0x28 ]                       
400078fc:	81 c7 e0 08 	ret                                            
40007900:	81 e8 00 00 	restore                                        
                                                                      

40007904 <rtems_malloc_statistics_at_malloc>: } static void rtems_malloc_statistics_at_malloc( void *pointer ) {
40007904:	9d e3 bf 98 	save  %sp, -104, %sp                           
  uintptr_t actual_size = 0;                                          
  uint32_t current_depth;                                             
  rtems_malloc_statistics_t *s = &rtems_malloc_statistics;            
                                                                      
  if ( !pointer )                                                     
40007908:	80 a6 20 00 	cmp  %i0, 0                                    
4000790c:	02 80 00 14 	be  4000795c <rtems_malloc_statistics_at_malloc+0x58><== NEVER TAKEN
40007910:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
    return;                                                           
                                                                      
  _Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
40007914:	03 10 00 93 	sethi  %hi(0x40024c00), %g1                    
40007918:	d0 00 61 b4 	ld  [ %g1 + 0x1b4 ], %o0	! 40024db4 <RTEMS_Malloc_Heap>
4000791c:	92 10 00 18 	mov  %i0, %o1                                  
40007920:	40 00 1c db 	call  4000ec8c <_Protected_heap_Get_block_size>
40007924:	94 07 bf fc 	add  %fp, -4, %o2                              
                                                                      
  MSBUMP(lifetime_allocated, actual_size);                            
40007928:	03 10 00 98 	sethi  %hi(0x40026000), %g1                    
4000792c:	f8 07 bf fc 	ld  [ %fp + -4 ], %i4                          
40007930:	82 10 60 80 	or  %g1, 0x80, %g1                             
40007934:	c4 18 60 20 	ldd  [ %g1 + 0x20 ], %g2                       
                                                                      
  current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
40007938:	fa 00 60 2c 	ld  [ %g1 + 0x2c ], %i5                        
  if (current_depth > s->max_depth)                                   
4000793c:	c8 00 60 18 	ld  [ %g1 + 0x18 ], %g4                        
  if ( !pointer )                                                     
    return;                                                           
                                                                      
  _Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
                                                                      
  MSBUMP(lifetime_allocated, actual_size);                            
40007940:	86 80 c0 1c 	addcc  %g3, %i4, %g3                           
40007944:	84 40 a0 00 	addx  %g2, 0, %g2                              
40007948:	c4 38 60 20 	std  %g2, [ %g1 + 0x20 ]                       
                                                                      
  current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
4000794c:	84 20 c0 1d 	sub  %g3, %i5, %g2                             
  if (current_depth > s->max_depth)                                   
40007950:	80 a0 80 04 	cmp  %g2, %g4                                  
40007954:	38 80 00 02 	bgu,a   4000795c <rtems_malloc_statistics_at_malloc+0x58>
40007958:	c4 20 60 18 	st  %g2, [ %g1 + 0x18 ]                        
4000795c:	81 c7 e0 08 	ret                                            
40007960:	81 e8 00 00 	restore                                        
                                                                      

400103c4 <rtems_memalign>: int rtems_memalign( void **pointer, size_t alignment, size_t size ) {
400103c4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  void *return_this;                                                  
                                                                      
  /*                                                                  
   *  Parameter error checks                                          
   */                                                                 
  if ( !pointer )                                                     
400103c8:	ba 96 20 00 	orcc  %i0, 0, %i5                              
400103cc:	02 80 00 21 	be  40010450 <rtems_memalign+0x8c>             
400103d0:	03 10 00 6d 	sethi  %hi(0x4001b400), %g1                    
  *pointer = NULL;                                                    
                                                                      
  /*                                                                  
   *  Do not attempt to allocate memory if not in correct system state.
   */                                                                 
  if ( _System_state_Is_up(_System_state_Get()) &&                    
400103d4:	c2 00 63 d8 	ld  [ %g1 + 0x3d8 ], %g1	! 4001b7d8 <_System_state_Current>
400103d8:	80 a0 60 03 	cmp  %g1, 3                                    
400103dc:	02 80 00 18 	be  4001043c <rtems_memalign+0x78>             
400103e0:	c0 27 40 00 	clr  [ %i5 ]                                   
    return EINVAL;                                                    
                                                                      
  /*                                                                  
   *  If some free's have been deferred, then do them now.            
   */                                                                 
  malloc_deferred_frees_process();                                    
400103e4:	7f ff d0 20 	call  40004464 <malloc_deferred_frees_process> 
400103e8:	b0 10 20 0c 	mov  0xc, %i0                                  
  Heap_Control *heap,                                                 
  uintptr_t size,                                                     
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return                                                              
400103ec:	03 10 00 69 	sethi  %hi(0x4001a400), %g1                    
400103f0:	d0 00 62 f8 	ld  [ %g1 + 0x2f8 ], %o0	! 4001a6f8 <RTEMS_Malloc_Heap>
400103f4:	92 10 00 1a 	mov  %i2, %o1                                  
400103f8:	94 10 00 19 	mov  %i1, %o2                                  
400103fc:	7f ff e8 53 	call  4000a548 <_Protected_heap_Allocate_aligned_with_boundary>
40010400:	96 10 20 00 	clr  %o3                                       
  return_this = _Protected_heap_Allocate_aligned(                     
    RTEMS_Malloc_Heap,                                                
    size,                                                             
    alignment                                                         
  );                                                                  
  if ( !return_this )                                                 
40010404:	80 a2 20 00 	cmp  %o0, 0                                    
40010408:	02 80 00 14 	be  40010458 <rtems_memalign+0x94>             
4001040c:	b8 10 00 08 	mov  %o0, %i4                                  
    return ENOMEM;                                                    
                                                                      
  /*                                                                  
   *  If configured, update the more involved statistics              
   */                                                                 
  if ( rtems_malloc_statistics_helpers )                              
40010410:	03 10 00 6b 	sethi  %hi(0x4001ac00), %g1                    
40010414:	c2 00 62 00 	ld  [ %g1 + 0x200 ], %g1	! 4001ae00 <rtems_malloc_statistics_helpers>
40010418:	80 a0 60 00 	cmp  %g1, 0                                    
4001041c:	22 80 00 06 	be,a   40010434 <rtems_memalign+0x70>          
40010420:	f8 27 40 00 	st  %i4, [ %i5 ]                               
    (*rtems_malloc_statistics_helpers->at_malloc)(pointer);           
40010424:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
40010428:	9f c0 40 00 	call  %g1                                      
4001042c:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  *pointer = return_this;                                             
40010430:	f8 27 40 00 	st  %i4, [ %i5 ]                               
  return 0;                                                           
}                                                                     
40010434:	81 c7 e0 08 	ret                                            
40010438:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      
  /*                                                                  
   *  Do not attempt to allocate memory if not in correct system state.
   */                                                                 
  if ( _System_state_Is_up(_System_state_Get()) &&                    
       !malloc_is_system_state_OK() )                                 
4001043c:	7f ff cf fd 	call  40004430 <malloc_is_system_state_OK>     
40010440:	01 00 00 00 	nop                                            
  *pointer = NULL;                                                    
                                                                      
  /*                                                                  
   *  Do not attempt to allocate memory if not in correct system state.
   */                                                                 
  if ( _System_state_Is_up(_System_state_Get()) &&                    
40010444:	80 8a 20 ff 	btst  0xff, %o0                                
40010448:	12 bf ff e7 	bne  400103e4 <rtems_memalign+0x20>            <== ALWAYS TAKEN
4001044c:	01 00 00 00 	nop                                            
                                                                      
  /*                                                                  
   *  Parameter error checks                                          
   */                                                                 
  if ( !pointer )                                                     
    return EINVAL;                                                    
40010450:	81 c7 e0 08 	ret                                            
40010454:	91 e8 20 16 	restore  %g0, 0x16, %o0                        
40010458:	81 c7 e0 08 	ret                                            
4001045c:	81 e8 00 00 	restore                                        
                                                                      

4000938c <rtems_mkdir>: return (retval); } int rtems_mkdir(const char *path, mode_t mode) {
4000938c:	9d e3 bf 58 	save  %sp, -168, %sp                           
  int success = 0;                                                    
  char *dup_path = strdup(path);                                      
40009390:	40 00 6d ad 	call  40024a44 <strdup>                        
40009394:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
  if (dup_path != NULL) {                                             
40009398:	b6 92 20 00 	orcc  %o0, 0, %i3                              
4000939c:	02 80 00 69 	be  40009540 <rtems_mkdir+0x1b4>               
400093a0:	01 00 00 00 	nop                                            
  char *p;                                                            
                                                                      
  p = path;                                                           
  oumask = 0;                                                         
  retval = 1;                                                         
  if (p[0] == '/')    /* Skip leading '/'. */                         
400093a4:	c2 0e c0 00 	ldub  [ %i3 ], %g1                             
400093a8:	83 28 60 18 	sll  %g1, 0x18, %g1                            
400093ac:	85 38 60 18 	sra  %g1, 0x18, %g2                            
400093b0:	80 a0 a0 2f 	cmp  %g2, 0x2f                                 
400093b4:	02 80 00 57 	be  40009510 <rtems_mkdir+0x184>               
400093b8:	ba 10 00 1b 	mov  %i3, %i5                                  
    ++p;                                                              
  for (first = 1, last = 0; !last ; ++p) {                            
    if (p[0] == '\0')                                                 
400093bc:	83 38 60 18 	sra  %g1, 0x18, %g1                            
  char *p;                                                            
                                                                      
  p = path;                                                           
  oumask = 0;                                                         
  retval = 1;                                                         
  if (p[0] == '/')    /* Skip leading '/'. */                         
400093c0:	b4 10 20 00 	clr  %i2                                       
400093c4:	84 10 20 01 	mov  1, %g2                                    
        retval = 0;                                                   
        break;                                                        
      }                                                               
    }                                                                 
    if (!last)                                                        
        *p = '/';                                                     
400093c8:	b0 10 20 2f 	mov  0x2f, %i0                                 
    if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
      if (errno == EEXIST || errno == EISDIR) {                       
        if (stat(path, &sb) < 0) {                                    
          retval = 0;                                                 
          break;                                                      
        } else if (!S_ISDIR(sb.st_mode)) {                            
400093cc:	23 00 00 3c 	sethi  %hi(0xf000), %l1                        
  oumask = 0;                                                         
  retval = 1;                                                         
  if (p[0] == '/')    /* Skip leading '/'. */                         
    ++p;                                                              
  for (first = 1, last = 0; !last ; ++p) {                            
    if (p[0] == '\0')                                                 
400093d0:	80 a0 60 00 	cmp  %g1, 0                                    
400093d4:	02 80 00 0b 	be  40009400 <rtems_mkdir+0x74>                <== NEVER TAKEN
400093d8:	21 00 00 10 	sethi  %hi(0x4000), %l0                        
      last = 1;                                                       
    else if (p[0] != '/')                                             
400093dc:	80 a0 60 2f 	cmp  %g1, 0x2f                                 
400093e0:	22 80 00 2f 	be,a   4000949c <rtems_mkdir+0x110>            
400093e4:	c2 4f 60 01 	ldsb  [ %i5 + 1 ], %g1                         
400093e8:	c2 0f 60 01 	ldub  [ %i5 + 1 ], %g1                         
400093ec:	83 28 60 18 	sll  %g1, 0x18, %g1                            
  oumask = 0;                                                         
  retval = 1;                                                         
  if (p[0] == '/')    /* Skip leading '/'. */                         
    ++p;                                                              
  for (first = 1, last = 0; !last ; ++p) {                            
    if (p[0] == '\0')                                                 
400093f0:	83 38 60 18 	sra  %g1, 0x18, %g1                            
400093f4:	80 a0 60 00 	cmp  %g1, 0                                    
400093f8:	12 bf ff f9 	bne  400093dc <rtems_mkdir+0x50>               
400093fc:	ba 07 60 01 	inc  %i5                                       
      last = 1;                                                       
    else if (p[0] != '/')                                             
      continue;                                                       
    *p = '\0';                                                        
40009400:	c0 2f 40 00 	clrb  [ %i5 ]                                  
40009404:	b8 10 20 01 	mov  1, %i4                                    
    if (!last && p[1] == '\0')                                        
      last = 1;                                                       
    if (first) {                                                      
40009408:	80 a0 a0 00 	cmp  %g2, 0                                    
4000940c:	12 80 00 1d 	bne  40009480 <rtems_mkdir+0xf4>               
40009410:	01 00 00 00 	nop                                            
      oumask = umask(0);                                              
      numask = oumask & ~(S_IWUSR | S_IXUSR);                         
      (void)umask(numask);                                            
      first = 0;                                                      
    }                                                                 
    if (last)                                                         
40009414:	80 a7 20 00 	cmp  %i4, 0                                    
40009418:	12 80 00 0a 	bne  40009440 <rtems_mkdir+0xb4>               
4000941c:	90 10 00 1b 	mov  %i3, %o0                                  
      (void)umask(oumask);                                            
    if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
40009420:	7f ff fc a4 	call  400086b0 <mkdir>                         
40009424:	92 10 21 ff 	mov  0x1ff, %o1                                
40009428:	80 a2 20 00 	cmp  %o0, 0                                    
4000942c:	06 80 00 20 	bl  400094ac <rtems_mkdir+0x120>               
40009430:	01 00 00 00 	nop                                            
        retval = 0;                                                   
        break;                                                        
      }                                                               
    }                                                                 
    if (!last)                                                        
        *p = '/';                                                     
40009434:	f0 2f 40 00 	stb  %i0, [ %i5 ]                              
40009438:	10 bf ff ec 	b  400093e8 <rtems_mkdir+0x5c>                 
4000943c:	84 10 20 00 	clr  %g2                                       
      numask = oumask & ~(S_IWUSR | S_IXUSR);                         
      (void)umask(numask);                                            
      first = 0;                                                      
    }                                                                 
    if (last)                                                         
      (void)umask(oumask);                                            
40009440:	40 00 0a a0 	call  4000bec0 <umask>                         
40009444:	90 10 00 1a 	mov  %i2, %o0                                  
    if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
40009448:	90 10 00 1b 	mov  %i3, %o0                                  
4000944c:	7f ff fc 99 	call  400086b0 <mkdir>                         
40009450:	92 10 00 19 	mov  %i1, %o1                                  
40009454:	80 a2 20 00 	cmp  %o0, 0                                    
40009458:	06 80 00 15 	bl  400094ac <rtems_mkdir+0x120>               
4000945c:	01 00 00 00 	nop                                            
40009460:	ba 10 20 01 	mov  1, %i5	! 1 <PROM_START+0x1>               
  int success = 0;                                                    
  char *dup_path = strdup(path);                                      
                                                                      
  if (dup_path != NULL) {                                             
    success = build(dup_path, mode);                                  
    free(dup_path);                                                   
40009464:	7f ff fa b9 	call  40007f48 <free>                          
40009468:	90 10 00 1b 	mov  %i3, %o0                                  
  }                                                                   
                                                                      
  return success != 0 ? 0 : -1;                                       
4000946c:	80 a7 60 00 	cmp  %i5, 0                                    
40009470:	02 80 00 34 	be  40009540 <rtems_mkdir+0x1b4>               <== NEVER TAKEN
40009474:	b0 10 20 00 	clr  %i0                                       
}                                                                     
40009478:	81 c7 e0 08 	ret                                            
4000947c:	81 e8 00 00 	restore                                        
       *    mkdir [-m mode] dir                                       
       *                                                              
       * We change the user's umask and then restore it,              
       * instead of doing chmod's.                                    
       */                                                             
      oumask = umask(0);                                              
40009480:	40 00 0a 90 	call  4000bec0 <umask>                         
40009484:	90 10 20 00 	clr  %o0                                       
40009488:	b4 10 00 08 	mov  %o0, %i2                                  
      numask = oumask & ~(S_IWUSR | S_IXUSR);                         
      (void)umask(numask);                                            
4000948c:	40 00 0a 8d 	call  4000bec0 <umask>                         
40009490:	90 0a 3f 3f 	and  %o0, -193, %o0                            
      first = 0;                                                      
    }                                                                 
    if (last)                                                         
40009494:	10 bf ff e1 	b  40009418 <rtems_mkdir+0x8c>                 
40009498:	80 a7 20 00 	cmp  %i4, 0                                    
  for (first = 1, last = 0; !last ; ++p) {                            
    if (p[0] == '\0')                                                 
      last = 1;                                                       
    else if (p[0] != '/')                                             
      continue;                                                       
    *p = '\0';                                                        
4000949c:	c0 2f 40 00 	clrb  [ %i5 ]                                  
400094a0:	80 a0 00 01 	cmp  %g0, %g1                                  
400094a4:	10 bf ff d9 	b  40009408 <rtems_mkdir+0x7c>                 
400094a8:	b8 60 3f ff 	subx  %g0, -1, %i4                             
      first = 0;                                                      
    }                                                                 
    if (last)                                                         
      (void)umask(oumask);                                            
    if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
      if (errno == EEXIST || errno == EISDIR) {                       
400094ac:	40 00 65 23 	call  40022938 <__errno>                       
400094b0:	01 00 00 00 	nop                                            
400094b4:	c2 02 00 00 	ld  [ %o0 ], %g1                               
400094b8:	80 a0 60 11 	cmp  %g1, 0x11                                 
400094bc:	02 80 00 08 	be  400094dc <rtems_mkdir+0x150>               
400094c0:	90 10 00 1b 	mov  %i3, %o0                                  
400094c4:	40 00 65 1d 	call  40022938 <__errno>                       
400094c8:	01 00 00 00 	nop                                            
400094cc:	c2 02 00 00 	ld  [ %o0 ], %g1                               
400094d0:	80 a0 60 15 	cmp  %g1, 0x15                                 
400094d4:	12 80 00 28 	bne  40009574 <rtems_mkdir+0x1e8>              <== ALWAYS TAKEN
400094d8:	90 10 00 1b 	mov  %i3, %o0                                  
        if (stat(path, &sb) < 0) {                                    
400094dc:	40 00 00 2a 	call  40009584 <stat>                          
400094e0:	92 07 bf b8 	add  %fp, -72, %o1                             
400094e4:	80 a2 20 00 	cmp  %o0, 0                                    
400094e8:	06 80 00 23 	bl  40009574 <rtems_mkdir+0x1e8>               <== NEVER TAKEN
400094ec:	c2 07 bf c4 	ld  [ %fp + -60 ], %g1                         
          retval = 0;                                                 
          break;                                                      
        } else if (!S_ISDIR(sb.st_mode)) {                            
400094f0:	82 08 40 11 	and  %g1, %l1, %g1                             
400094f4:	80 a0 40 10 	cmp  %g1, %l0                                  
400094f8:	12 80 00 0a 	bne  40009520 <rtems_mkdir+0x194>              
400094fc:	80 a7 20 00 	cmp  %i4, 0                                    
          else                                                        
            errno = ENOTDIR;                                          
          retval = 0;                                                 
          break;                                                      
        }                                                             
        if (last)                                                     
40009500:	22 bf ff ce 	be,a   40009438 <rtems_mkdir+0xac>             
40009504:	f0 2f 40 00 	stb  %i0, [ %i5 ]                              
          retval = 2;                                                 
40009508:	10 bf ff d7 	b  40009464 <rtems_mkdir+0xd8>                 
4000950c:	ba 10 20 02 	mov  2, %i5                                    
40009510:	c2 0e e0 01 	ldub  [ %i3 + 1 ], %g1                         
                                                                      
  p = path;                                                           
  oumask = 0;                                                         
  retval = 1;                                                         
  if (p[0] == '/')    /* Skip leading '/'. */                         
    ++p;                                                              
40009514:	ba 06 e0 01 	add  %i3, 1, %i5                               
40009518:	10 bf ff a9 	b  400093bc <rtems_mkdir+0x30>                 
4000951c:	83 28 60 18 	sll  %g1, 0x18, %g1                            
      if (errno == EEXIST || errno == EISDIR) {                       
        if (stat(path, &sb) < 0) {                                    
          retval = 0;                                                 
          break;                                                      
        } else if (!S_ISDIR(sb.st_mode)) {                            
          if (last)                                                   
40009520:	02 80 00 0a 	be  40009548 <rtems_mkdir+0x1bc>               
40009524:	01 00 00 00 	nop                                            
            errno = EEXIST;                                           
40009528:	40 00 65 04 	call  40022938 <__errno>                       
4000952c:	01 00 00 00 	nop                                            
40009530:	82 10 20 11 	mov  0x11, %g1	! 11 <PROM_START+0x11>          
40009534:	c2 22 00 00 	st  %g1, [ %o0 ]                               
  int success = 0;                                                    
  char *dup_path = strdup(path);                                      
                                                                      
  if (dup_path != NULL) {                                             
    success = build(dup_path, mode);                                  
    free(dup_path);                                                   
40009538:	7f ff fa 84 	call  40007f48 <free>                          
4000953c:	90 10 00 1b 	mov  %i3, %o0                                  
  }                                                                   
                                                                      
  return success != 0 ? 0 : -1;                                       
40009540:	81 c7 e0 08 	ret                                            
40009544:	91 e8 3f ff 	restore  %g0, -1, %o0                          
          break;                                                      
        } else if (!S_ISDIR(sb.st_mode)) {                            
          if (last)                                                   
            errno = EEXIST;                                           
          else                                                        
            errno = ENOTDIR;                                          
40009548:	40 00 64 fc 	call  40022938 <__errno>                       
4000954c:	01 00 00 00 	nop                                            
40009550:	82 10 20 14 	mov  0x14, %g1	! 14 <PROM_START+0x14>          
40009554:	c2 22 00 00 	st  %g1, [ %o0 ]                               
    }                                                                 
    if (!last)                                                        
        *p = '/';                                                     
  }                                                                   
  if (!first && !last)                                                
    (void)umask(oumask);                                              
40009558:	40 00 0a 5a 	call  4000bec0 <umask>                         
4000955c:	90 10 00 1a 	mov  %i2, %o0                                  
  int success = 0;                                                    
  char *dup_path = strdup(path);                                      
                                                                      
  if (dup_path != NULL) {                                             
    success = build(dup_path, mode);                                  
    free(dup_path);                                                   
40009560:	90 10 00 1b 	mov  %i3, %o0                                  
40009564:	7f ff fa 79 	call  40007f48 <free>                          
40009568:	b0 10 3f ff 	mov  -1, %i0                                   
4000956c:	81 c7 e0 08 	ret                                            
40009570:	81 e8 00 00 	restore                                        
      }                                                               
    }                                                                 
    if (!last)                                                        
        *p = '/';                                                     
  }                                                                   
  if (!first && !last)                                                
40009574:	80 a7 20 00 	cmp  %i4, 0                                    
40009578:	02 bf ff f8 	be  40009558 <rtems_mkdir+0x1cc>               <== NEVER TAKEN
4000957c:	90 10 00 1b 	mov  %i3, %o0                                  
40009580:	30 bf ff f9 	b,a   40009564 <rtems_mkdir+0x1d8>             
                                                                      

40008d68 <rtems_object_get_class_information>: rtems_status_code rtems_object_get_class_information( int the_api, int the_class, rtems_object_api_class_information *info ) {
40008d68:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int                  i;                                             
                                                                      
  /*                                                                  
   * Validate parameters and look up information structure.           
   */                                                                 
  if ( !info )                                                        
40008d6c:	80 a6 a0 00 	cmp  %i2, 0                                    
40008d70:	02 80 00 21 	be  40008df4 <rtems_object_get_class_information+0x8c>
40008d74:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  obj_info = _Objects_Get_information( the_api, the_class );          
40008d78:	93 2e 60 10 	sll  %i1, 0x10, %o1                            
40008d7c:	90 10 00 18 	mov  %i0, %o0                                  
40008d80:	40 00 07 cc 	call  4000acb0 <_Objects_Get_information>      
40008d84:	93 32 60 10 	srl  %o1, 0x10, %o1                            
  if ( !obj_info )                                                    
40008d88:	80 a2 20 00 	cmp  %o0, 0                                    
40008d8c:	02 80 00 1a 	be  40008df4 <rtems_object_get_class_information+0x8c>
40008d90:	82 10 20 0a 	mov  0xa, %g1                                  
   * Return information about this object class to the user.          
   */                                                                 
  info->minimum_id  = obj_info->minimum_id;                           
  info->maximum_id  = obj_info->maximum_id;                           
  info->auto_extend = obj_info->auto_extend;                          
  info->maximum     = obj_info->maximum;                              
40008d94:	c8 12 20 10 	lduh  [ %o0 + 0x10 ], %g4                      
    return RTEMS_INVALID_NUMBER;                                      
                                                                      
  /*                                                                  
   * Return information about this object class to the user.          
   */                                                                 
  info->minimum_id  = obj_info->minimum_id;                           
40008d98:	c6 02 20 08 	ld  [ %o0 + 8 ], %g3                           
  info->maximum_id  = obj_info->maximum_id;                           
40008d9c:	c4 02 20 0c 	ld  [ %o0 + 0xc ], %g2                         
  info->auto_extend = obj_info->auto_extend;                          
40008da0:	c2 0a 20 12 	ldub  [ %o0 + 0x12 ], %g1                      
    return RTEMS_INVALID_NUMBER;                                      
                                                                      
  /*                                                                  
   * Return information about this object class to the user.          
   */                                                                 
  info->minimum_id  = obj_info->minimum_id;                           
40008da4:	c6 26 80 00 	st  %g3, [ %i2 ]                               
  info->maximum_id  = obj_info->maximum_id;                           
40008da8:	c4 26 a0 04 	st  %g2, [ %i2 + 4 ]                           
  info->auto_extend = obj_info->auto_extend;                          
40008dac:	c2 2e a0 0c 	stb  %g1, [ %i2 + 0xc ]                        
  info->maximum     = obj_info->maximum;                              
                                                                      
  for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )               
40008db0:	80 a1 20 00 	cmp  %g4, 0                                    
40008db4:	02 80 00 12 	be  40008dfc <rtems_object_get_class_information+0x94><== NEVER TAKEN
40008db8:	c8 26 a0 08 	st  %g4, [ %i2 + 8 ]                           
40008dbc:	fa 02 20 1c 	ld  [ %o0 + 0x1c ], %i5                        
40008dc0:	86 10 20 01 	mov  1, %g3                                    
40008dc4:	82 10 20 01 	mov  1, %g1                                    
40008dc8:	84 10 20 00 	clr  %g2                                       
    if ( !obj_info->local_table[i] )                                  
40008dcc:	87 28 e0 02 	sll  %g3, 2, %g3                               
40008dd0:	c6 07 40 03 	ld  [ %i5 + %g3 ], %g3                         
  info->minimum_id  = obj_info->minimum_id;                           
  info->maximum_id  = obj_info->maximum_id;                           
  info->auto_extend = obj_info->auto_extend;                          
  info->maximum     = obj_info->maximum;                              
                                                                      
  for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )               
40008dd4:	82 00 60 01 	inc  %g1                                       
    if ( !obj_info->local_table[i] )                                  
      unallocated++;                                                  
40008dd8:	80 a0 00 03 	cmp  %g0, %g3                                  
40008ddc:	84 60 bf ff 	subx  %g2, -1, %g2                             
  info->minimum_id  = obj_info->minimum_id;                           
  info->maximum_id  = obj_info->maximum_id;                           
  info->auto_extend = obj_info->auto_extend;                          
  info->maximum     = obj_info->maximum;                              
                                                                      
  for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )               
40008de0:	80 a1 00 01 	cmp  %g4, %g1                                  
40008de4:	1a bf ff fa 	bcc  40008dcc <rtems_object_get_class_information+0x64>
40008de8:	86 10 00 01 	mov  %g1, %g3                                  
    if ( !obj_info->local_table[i] )                                  
      unallocated++;                                                  
                                                                      
  info->unallocated = unallocated;                                    
40008dec:	c4 26 a0 10 	st  %g2, [ %i2 + 0x10 ]                        
                                                                      
  return RTEMS_SUCCESSFUL;                                            
40008df0:	82 10 20 00 	clr  %g1                                       
}                                                                     
40008df4:	81 c7 e0 08 	ret                                            
40008df8:	91 e8 00 01 	restore  %g0, %g1, %o0                         
  info->minimum_id  = obj_info->minimum_id;                           
  info->maximum_id  = obj_info->maximum_id;                           
  info->auto_extend = obj_info->auto_extend;                          
  info->maximum     = obj_info->maximum;                              
                                                                      
  for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )               
40008dfc:	84 10 20 00 	clr  %g2                                       <== NOT EXECUTED
    if ( !obj_info->local_table[i] )                                  
      unallocated++;                                                  
                                                                      
  info->unallocated = unallocated;                                    
                                                                      
  return RTEMS_SUCCESSFUL;                                            
40008e00:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
                                                                      
  for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )               
    if ( !obj_info->local_table[i] )                                  
      unallocated++;                                                  
                                                                      
  info->unallocated = unallocated;                                    
40008e04:	10 bf ff fc 	b  40008df4 <rtems_object_get_class_information+0x8c><== NOT EXECUTED
40008e08:	c4 26 a0 10 	st  %g2, [ %i2 + 0x10 ]                        <== NOT EXECUTED
                                                                      

40002fd4 <rtems_panic>: void rtems_panic( const char *printf_format, ... ) {
40002fd4:	9d e3 bf 98 	save  %sp, -104, %sp                           <== NOT EXECUTED
  va_list arglist;                                                    
                                                                      
  va_start(arglist, printf_format);                                   
40002fd8:	82 07 a0 48 	add  %fp, 0x48, %g1                            <== NOT EXECUTED
  (void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);     
40002fdc:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
40002fe0:	94 10 00 01 	mov  %g1, %o2                                  <== NOT EXECUTED
  ...                                                                 
)                                                                     
{                                                                     
  va_list arglist;                                                    
                                                                      
  va_start(arglist, printf_format);                                   
40002fe4:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          <== NOT EXECUTED
40002fe8:	f2 27 a0 48 	st  %i1, [ %fp + 0x48 ]                        <== NOT EXECUTED
40002fec:	f4 27 a0 4c 	st  %i2, [ %fp + 0x4c ]                        <== NOT EXECUTED
40002ff0:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]                        <== NOT EXECUTED
40002ff4:	f8 27 a0 54 	st  %i4, [ %fp + 0x54 ]                        <== NOT EXECUTED
40002ff8:	fa 27 a0 58 	st  %i5, [ %fp + 0x58 ]                        <== NOT EXECUTED
  (void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);     
40002ffc:	7f ff ff 77 	call  40002dd8 <rtems_verror>                  <== NOT EXECUTED
40003000:	11 08 00 00 	sethi  %hi(0x20000000), %o0                    <== NOT EXECUTED
  va_end(arglist);                                                    
                                                                      
  rtems_error(0, "fatal error, exiting");                             
40003004:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
40003008:	13 10 00 72 	sethi  %hi(0x4001c800), %o1                    <== NOT EXECUTED
4000300c:	7f ff ff d0 	call  40002f4c <rtems_error>                   <== NOT EXECUTED
40003010:	92 12 62 10 	or  %o1, 0x210, %o1	! 4001ca10 <IMFS_node_control_default+0xa0><== NOT EXECUTED
  _exit(errno);                                                       
40003014:	40 00 31 cb 	call  4000f740 <__errno>                       <== NOT EXECUTED
40003018:	01 00 00 00 	nop                                            <== NOT EXECUTED
4000301c:	40 00 02 50 	call  4000395c <_exit>                         <== NOT EXECUTED
40003020:	d0 02 00 00 	ld  [ %o0 ], %o0                               <== NOT EXECUTED
                                                                      

40008804 <rtems_partition_create>: uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, rtems_id *id ) {
40008804:	9d e3 bf a0 	save  %sp, -96, %sp                            
  register Partition_Control *the_partition;                          
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
40008808:	80 a6 20 00 	cmp  %i0, 0                                    
4000880c:	12 80 00 04 	bne  4000881c <rtems_partition_create+0x18>    
40008810:	82 10 20 03 	mov  3, %g1                                    
    );                                                                
#endif                                                                
                                                                      
  _Thread_Enable_dispatch();                                          
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
40008814:	81 c7 e0 08 	ret                                            
40008818:	91 e8 00 01 	restore  %g0, %g1, %o0                         
  register Partition_Control *the_partition;                          
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
    return RTEMS_INVALID_NAME;                                        
                                                                      
  if ( !starting_address )                                            
4000881c:	80 a6 60 00 	cmp  %i1, 0                                    
40008820:	02 bf ff fd 	be  40008814 <rtems_partition_create+0x10>     
40008824:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !id )                                                          
40008828:	80 a7 60 00 	cmp  %i5, 0                                    
4000882c:	02 bf ff fa 	be  40008814 <rtems_partition_create+0x10>     <== NEVER TAKEN
40008830:	80 a6 e0 00 	cmp  %i3, 0                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( length == 0 || buffer_size == 0 || length < buffer_size ||     
40008834:	02 bf ff f8 	be  40008814 <rtems_partition_create+0x10>     
40008838:	82 10 20 08 	mov  8, %g1                                    
4000883c:	80 a6 a0 00 	cmp  %i2, 0                                    
40008840:	02 bf ff f5 	be  40008814 <rtems_partition_create+0x10>     
40008844:	80 a6 80 1b 	cmp  %i2, %i3                                  
40008848:	0a bf ff f3 	bcs  40008814 <rtems_partition_create+0x10>    
4000884c:	80 8e e0 07 	btst  7, %i3                                   
40008850:	12 bf ff f1 	bne  40008814 <rtems_partition_create+0x10>    
40008854:	80 8e 60 07 	btst  7, %i1                                   
         !_Partition_Is_buffer_size_aligned( buffer_size ) )          
    return RTEMS_INVALID_SIZE;                                        
                                                                      
  if ( !_Addresses_Is_aligned( starting_address ) )                   
40008858:	12 bf ff ef 	bne  40008814 <rtems_partition_create+0x10>    
4000885c:	82 10 20 09 	mov  9, %g1                                    
   *                                                                  
   * This rountine increments the thread dispatch level               
   */                                                                 
  RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
  {                                                                   
    uint32_t level = _Thread_Dispatch_disable_level;                  
40008860:	03 10 00 8e 	sethi  %hi(0x40023800), %g1                    
40008864:	c4 00 60 c0 	ld  [ %g1 + 0xc0 ], %g2	! 400238c0 <_Thread_Dispatch_disable_level>
                                                                      
    ++level;                                                          
40008868:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
4000886c:	c4 20 60 c0 	st  %g2, [ %g1 + 0xc0 ]                        
 *  This function allocates a partition control block from            
 *  the inactive chain of free partition control blocks.              
 */                                                                   
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Allocate ( void )  
{                                                                     
  return (Partition_Control *) _Objects_Allocate( &_Partition_Information );
40008870:	23 10 00 8d 	sethi  %hi(0x40023400), %l1                    
40008874:	40 00 07 6f 	call  4000a630 <_Objects_Allocate>             
40008878:	90 14 62 bc 	or  %l1, 0x2bc, %o0	! 400236bc <_Partition_Information>
                                                                      
  _Thread_Disable_dispatch();               /* prevents deletion */   
                                                                      
  the_partition = _Partition_Allocate();                              
                                                                      
  if ( !the_partition ) {                                             
4000887c:	a0 92 20 00 	orcc  %o0, 0, %l0                              
40008880:	02 80 00 1a 	be  400088e8 <rtems_partition_create+0xe4>     
40008884:	92 10 00 1b 	mov  %i3, %o1                                  
#endif                                                                
                                                                      
  the_partition->starting_address      = starting_address;            
  the_partition->length                = length;                      
  the_partition->buffer_size           = buffer_size;                 
  the_partition->attribute_set         = attribute_set;               
40008888:	f8 24 20 1c 	st  %i4, [ %l0 + 0x1c ]                        
    _Thread_Enable_dispatch();                                        
    return RTEMS_TOO_MANY;                                            
  }                                                                   
#endif                                                                
                                                                      
  the_partition->starting_address      = starting_address;            
4000888c:	f2 24 20 10 	st  %i1, [ %l0 + 0x10 ]                        
  the_partition->length                = length;                      
40008890:	f4 24 20 14 	st  %i2, [ %l0 + 0x14 ]                        
  the_partition->buffer_size           = buffer_size;                 
40008894:	f6 24 20 18 	st  %i3, [ %l0 + 0x18 ]                        
  the_partition->attribute_set         = attribute_set;               
  the_partition->number_of_used_blocks = 0;                           
40008898:	c0 24 20 20 	clr  [ %l0 + 0x20 ]                            
                                                                      
  _Chain_Initialize( &the_partition->Memory, starting_address,        
                        length / buffer_size, buffer_size );          
4000889c:	40 00 47 d1 	call  4001a7e0 <.udiv>                         
400088a0:	90 10 00 1a 	mov  %i2, %o0                                  
  the_partition->length                = length;                      
  the_partition->buffer_size           = buffer_size;                 
  the_partition->attribute_set         = attribute_set;               
  the_partition->number_of_used_blocks = 0;                           
                                                                      
  _Chain_Initialize( &the_partition->Memory, starting_address,        
400088a4:	92 10 00 19 	mov  %i1, %o1                                  
                        length / buffer_size, buffer_size );          
400088a8:	94 10 00 08 	mov  %o0, %o2                                  
  the_partition->length                = length;                      
  the_partition->buffer_size           = buffer_size;                 
  the_partition->attribute_set         = attribute_set;               
  the_partition->number_of_used_blocks = 0;                           
                                                                      
  _Chain_Initialize( &the_partition->Memory, starting_address,        
400088ac:	96 10 00 1b 	mov  %i3, %o3                                  
400088b0:	b8 04 20 24 	add  %l0, 0x24, %i4                            
400088b4:	40 00 04 a5 	call  40009b48 <_Chain_Initialize>             
400088b8:	90 10 00 1c 	mov  %i4, %o0                                  
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
400088bc:	c4 14 20 0a 	lduh  [ %l0 + 0xa ], %g2                       
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
400088c0:	a2 14 62 bc 	or  %l1, 0x2bc, %l1                            
400088c4:	c6 04 60 1c 	ld  [ %l1 + 0x1c ], %g3                        
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
400088c8:	c2 04 20 08 	ld  [ %l0 + 8 ], %g1                           
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
400088cc:	85 28 a0 02 	sll  %g2, 2, %g2                               
400088d0:	e0 20 c0 02 	st  %l0, [ %g3 + %g2 ]                         
    information,                                                      
    _Objects_Get_index( the_object->id ),                             
    the_object                                                        
  );                                                                  
                                                                      
  the_object->name = name;                                            
400088d4:	f0 24 20 0c 	st  %i0, [ %l0 + 0xc ]                         
      name,                                                           
      0                  /* Not used */                               
    );                                                                
#endif                                                                
                                                                      
  _Thread_Enable_dispatch();                                          
400088d8:	40 00 0c a2 	call  4000bb60 <_Thread_Enable_dispatch>       
400088dc:	c2 27 40 00 	st  %g1, [ %i5 ]                               
  return RTEMS_SUCCESSFUL;                                            
400088e0:	10 bf ff cd 	b  40008814 <rtems_partition_create+0x10>      
400088e4:	82 10 20 00 	clr  %g1                                       
  _Thread_Disable_dispatch();               /* prevents deletion */   
                                                                      
  the_partition = _Partition_Allocate();                              
                                                                      
  if ( !the_partition ) {                                             
    _Thread_Enable_dispatch();                                        
400088e8:	40 00 0c 9e 	call  4000bb60 <_Thread_Enable_dispatch>       
400088ec:	01 00 00 00 	nop                                            
    return RTEMS_TOO_MANY;                                            
400088f0:	10 bf ff c9 	b  40008814 <rtems_partition_create+0x10>      
400088f4:	82 10 20 05 	mov  5, %g1	! 5 <PROM_START+0x5>               
                                                                      

40014fdc <rtems_partition_return_buffer>: rtems_status_code rtems_partition_return_buffer( rtems_id id, void *buffer ) {
40014fdc:	9d e3 bf 98 	save  %sp, -104, %sp                           
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get (              
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (Partition_Control *)                                        
40014fe0:	11 10 00 f4 	sethi  %hi(0x4003d000), %o0                    
40014fe4:	92 10 00 18 	mov  %i0, %o1                                  
40014fe8:	90 12 22 64 	or  %o0, 0x264, %o0                            
40014fec:	40 00 15 26 	call  4001a484 <_Objects_Get>                  
40014ff0:	94 07 bf fc 	add  %fp, -4, %o2                              
  register Partition_Control *the_partition;                          
  Objects_Locations           location;                               
                                                                      
  the_partition = _Partition_Get( id, &location );                    
  switch ( location ) {                                               
40014ff4:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40014ff8:	80 a0 60 00 	cmp  %g1, 0                                    
40014ffc:	12 80 00 19 	bne  40015060 <rtems_partition_return_buffer+0x84>
40015000:	ba 10 00 08 	mov  %o0, %i5                                  
)                                                                     
{                                                                     
  void *starting;                                                     
  void *ending;                                                       
                                                                      
  starting = the_partition->starting_address;                         
40015004:	d0 02 20 10 	ld  [ %o0 + 0x10 ], %o0                        
40015008:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
4001500c:	82 02 00 01 	add  %o0, %g1, %g1                             
  ending   = _Addresses_Add_offset( starting, the_partition->length );
                                                                      
  return (                                                            
    _Addresses_Is_in_range( the_buffer, starting, ending ) &&         
40015010:	80 a6 40 01 	cmp  %i1, %g1                                  
40015014:	18 80 00 15 	bgu  40015068 <rtems_partition_return_buffer+0x8c><== NEVER TAKEN
40015018:	80 a6 40 08 	cmp  %i1, %o0                                  
4001501c:	0a 80 00 13 	bcs  40015068 <rtems_partition_return_buffer+0x8c>
40015020:	01 00 00 00 	nop                                            
  offset = (uint32_t) _Addresses_Subtract(                            
    the_buffer,                                                       
    the_partition->starting_address                                   
  );                                                                  
                                                                      
  return ((offset % the_partition->buffer_size) == 0);                
40015024:	d2 07 60 18 	ld  [ %i5 + 0x18 ], %o1                        
40015028:	40 00 5a e1 	call  4002bbac <.urem>                         
4001502c:	90 26 40 08 	sub  %i1, %o0, %o0                             
                                                                      
  starting = the_partition->starting_address;                         
  ending   = _Addresses_Add_offset( starting, the_partition->length );
                                                                      
  return (                                                            
    _Addresses_Is_in_range( the_buffer, starting, ending ) &&         
40015030:	80 a2 20 00 	cmp  %o0, 0                                    
40015034:	12 80 00 0d 	bne  40015068 <rtems_partition_return_buffer+0x8c>
40015038:	90 07 60 24 	add  %i5, 0x24, %o0                            
RTEMS_INLINE_ROUTINE void _Partition_Free_buffer (                    
  Partition_Control *the_partition,                                   
  Chain_Node        *the_buffer                                       
)                                                                     
{                                                                     
  _Chain_Append( &the_partition->Memory, the_buffer );                
4001503c:	40 00 0d 11 	call  40018480 <_Chain_Append>                 
40015040:	92 10 00 19 	mov  %i1, %o1                                  
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) {    
        _Partition_Free_buffer( the_partition, buffer );              
        the_partition->number_of_used_blocks -= 1;                    
40015044:	c2 07 60 20 	ld  [ %i5 + 0x20 ], %g1                        
        _Thread_Enable_dispatch();                                    
        return RTEMS_SUCCESSFUL;                                      
40015048:	b0 10 20 00 	clr  %i0                                       
  switch ( location ) {                                               
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) {    
        _Partition_Free_buffer( the_partition, buffer );              
        the_partition->number_of_used_blocks -= 1;                    
4001504c:	82 00 7f ff 	add  %g1, -1, %g1                              
        _Thread_Enable_dispatch();                                    
40015050:	40 00 18 f0 	call  4001b410 <_Thread_Enable_dispatch>       
40015054:	c2 27 60 20 	st  %g1, [ %i5 + 0x20 ]                        
40015058:	81 c7 e0 08 	ret                                            
4001505c:	81 e8 00 00 	restore                                        
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
40015060:	81 c7 e0 08 	ret                                            
40015064:	91 e8 20 04 	restore  %g0, 4, %o0                           
        _Partition_Free_buffer( the_partition, buffer );              
        the_partition->number_of_used_blocks -= 1;                    
        _Thread_Enable_dispatch();                                    
        return RTEMS_SUCCESSFUL;                                      
      }                                                               
      _Thread_Enable_dispatch();                                      
40015068:	40 00 18 ea 	call  4001b410 <_Thread_Enable_dispatch>       
4001506c:	b0 10 20 09 	mov  9, %i0                                    
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
40015070:	81 c7 e0 08 	ret                                            
40015074:	81 e8 00 00 	restore                                        
                                                                      

40037900 <rtems_rate_monotonic_period>: rtems_status_code rtems_rate_monotonic_period( rtems_id id, rtems_interval length ) {
40037900:	9d e3 bf 98 	save  %sp, -104, %sp                           
40037904:	11 10 01 a3 	sethi  %hi(0x40068c00), %o0                    
40037908:	92 10 00 18 	mov  %i0, %o1                                  
4003790c:	90 12 23 78 	or  %o0, 0x378, %o0                            
40037910:	7f ff 44 18 	call  40008970 <_Objects_Get>                  
40037914:	94 07 bf fc 	add  %fp, -4, %o2                              
  rtems_rate_monotonic_period_states   local_state;                   
  ISR_Level                            level;                         
                                                                      
  the_period = _Rate_monotonic_Get( id, &location );                  
                                                                      
  switch ( location ) {                                               
40037918:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4003791c:	80 a0 60 00 	cmp  %g1, 0                                    
40037920:	12 80 00 0d 	bne  40037954 <rtems_rate_monotonic_period+0x54>
40037924:	ba 10 00 08 	mov  %o0, %i5                                  
    case OBJECTS_LOCAL:                                               
      if ( !_Thread_Is_executing( the_period->owner ) ) {             
40037928:	c4 02 20 40 	ld  [ %o0 + 0x40 ], %g2                        
                                                                      
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (                      
  const Thread_Control *the_thread                                    
)                                                                     
{                                                                     
  return ( the_thread == _Thread_Executing );                         
4003792c:	39 10 01 a2 	sethi  %hi(0x40068800), %i4                    
40037930:	b8 17 21 b0 	or  %i4, 0x1b0, %i4	! 400689b0 <_Per_CPU_Information>
40037934:	c2 07 20 10 	ld  [ %i4 + 0x10 ], %g1                        
40037938:	80 a0 80 01 	cmp  %g2, %g1                                  
4003793c:	02 80 00 08 	be  4003795c <rtems_rate_monotonic_period+0x5c>
40037940:	80 a6 60 00 	cmp  %i1, 0                                    
        _Thread_Enable_dispatch();                                    
40037944:	7f ff 47 c2 	call  4000984c <_Thread_Enable_dispatch>       
40037948:	b0 10 20 17 	mov  0x17, %i0                                 
4003794c:	81 c7 e0 08 	ret                                            
40037950:	81 e8 00 00 	restore                                        
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
40037954:	81 c7 e0 08 	ret                                            
40037958:	91 e8 20 04 	restore  %g0, 4, %o0                           
      if ( !_Thread_Is_executing( the_period->owner ) ) {             
        _Thread_Enable_dispatch();                                    
        return RTEMS_NOT_OWNER_OF_RESOURCE;                           
      }                                                               
                                                                      
      if ( length == RTEMS_PERIOD_STATUS ) {                          
4003795c:	12 80 00 0e 	bne  40037994 <rtems_rate_monotonic_period+0x94>
40037960:	01 00 00 00 	nop                                            
        switch ( the_period->state ) {                                
40037964:	c2 02 20 38 	ld  [ %o0 + 0x38 ], %g1                        
40037968:	80 a0 60 04 	cmp  %g1, 4                                    
4003796c:	18 80 00 06 	bgu  40037984 <rtems_rate_monotonic_period+0x84><== NEVER TAKEN
40037970:	b0 10 20 00 	clr  %i0                                       
40037974:	83 28 60 02 	sll  %g1, 2, %g1                               
40037978:	05 10 01 88 	sethi  %hi(0x40062000), %g2                    
4003797c:	84 10 a3 50 	or  %g2, 0x350, %g2	! 40062350 <CSWTCH.24>     
40037980:	f0 00 80 01 	ld  [ %g2 + %g1 ], %i0                         
          id,                                                         
          NULL                                                        
        );                                                            
                                                                      
        _Watchdog_Insert_ticks( &the_period->Timer, length );         
        _Thread_Enable_dispatch();                                    
40037984:	7f ff 47 b2 	call  4000984c <_Thread_Enable_dispatch>       
40037988:	01 00 00 00 	nop                                            
4003798c:	81 c7 e0 08 	ret                                            
40037990:	81 e8 00 00 	restore                                        
        }                                                             
        _Thread_Enable_dispatch();                                    
        return( return_value );                                       
      }                                                               
                                                                      
      _ISR_Disable( level );                                          
40037994:	7f ff 29 38 	call  40001e74 <sparc_disable_interrupts>      
40037998:	01 00 00 00 	nop                                            
4003799c:	b4 10 00 08 	mov  %o0, %i2                                  
      if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {           
400379a0:	f6 07 60 38 	ld  [ %i5 + 0x38 ], %i3                        
400379a4:	80 a6 e0 00 	cmp  %i3, 0                                    
400379a8:	02 80 00 1c 	be  40037a18 <rtems_rate_monotonic_period+0x118>
400379ac:	80 a6 e0 02 	cmp  %i3, 2                                    
        _Watchdog_Insert_ticks( &the_period->Timer, length );         
        _Thread_Enable_dispatch();                                    
        return RTEMS_SUCCESSFUL;                                      
      }                                                               
                                                                      
      if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {             
400379b0:	02 80 00 2e 	be  40037a68 <rtems_rate_monotonic_period+0x168>
400379b4:	80 a6 e0 04 	cmp  %i3, 4                                    
                                                                      
        _Thread_Enable_dispatch();                                    
        return RTEMS_SUCCESSFUL;                                      
      }                                                               
                                                                      
      if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {            
400379b8:	12 bf ff e5 	bne  4003794c <rtems_rate_monotonic_period+0x4c><== NEVER TAKEN
400379bc:	b0 10 20 04 	mov  4, %i0                                    
        /*                                                            
         *  Update statistics from the concluding period              
         */                                                           
        _Rate_monotonic_Update_statistics( the_period );              
400379c0:	7f ff ff 5e 	call  40037738 <_Rate_monotonic_Update_statistics>
400379c4:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
        _ISR_Enable( level );                                         
400379c8:	7f ff 29 2f 	call  40001e84 <sparc_enable_interrupts>       
400379cc:	90 10 00 1a 	mov  %i2, %o0                                  
                                                                      
        the_period->state = RATE_MONOTONIC_ACTIVE;                    
400379d0:	82 10 20 02 	mov  2, %g1                                    
400379d4:	92 07 60 10 	add  %i5, 0x10, %o1                            
400379d8:	c2 27 60 38 	st  %g1, [ %i5 + 0x38 ]                        
        the_period->next_length = length;                             
400379dc:	f2 27 60 3c 	st  %i1, [ %i5 + 0x3c ]                        
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
400379e0:	f2 27 60 1c 	st  %i1, [ %i5 + 0x1c ]                        
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
400379e4:	11 10 01 a1 	sethi  %hi(0x40068400), %o0                    
400379e8:	7f ff 4a d5 	call  4000a53c <_Watchdog_Insert>              
400379ec:	90 12 21 38 	or  %o0, 0x138, %o0	! 40068538 <_Watchdog_Ticks_chain>
400379f0:	d0 07 60 40 	ld  [ %i5 + 0x40 ], %o0                        
400379f4:	d2 07 60 3c 	ld  [ %i5 + 0x3c ], %o1                        
400379f8:	03 10 01 90 	sethi  %hi(0x40064000), %g1                    
400379fc:	c2 00 62 14 	ld  [ %g1 + 0x214 ], %g1	! 40064214 <_Scheduler+0x34>
40037a00:	9f c0 40 00 	call  %g1                                      
40037a04:	b0 10 20 06 	mov  6, %i0                                    
                                                                      
        _Watchdog_Insert_ticks( &the_period->Timer, length );         
        _Scheduler_Release_job(the_period->owner, the_period->next_length);
        _Thread_Enable_dispatch();                                    
40037a08:	7f ff 47 91 	call  4000984c <_Thread_Enable_dispatch>       
40037a0c:	01 00 00 00 	nop                                            
40037a10:	81 c7 e0 08 	ret                                            
40037a14:	81 e8 00 00 	restore                                        
        return( return_value );                                       
      }                                                               
                                                                      
      _ISR_Disable( level );                                          
      if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {           
        _ISR_Enable( level );                                         
40037a18:	7f ff 29 1b 	call  40001e84 <sparc_enable_interrupts>       
40037a1c:	01 00 00 00 	nop                                            
        the_period->next_length = length;                             
                                                                      
        /*                                                            
         *  Baseline statistics information for the beginning of a period.
         */                                                           
        _Rate_monotonic_Initiate_statistics( the_period );            
40037a20:	90 10 00 1d 	mov  %i5, %o0                                  
40037a24:	7f ff ff 94 	call  40037874 <_Rate_monotonic_Initiate_statistics>
40037a28:	f2 27 60 3c 	st  %i1, [ %i5 + 0x3c ]                        
                                                                      
        the_period->state = RATE_MONOTONIC_ACTIVE;                    
40037a2c:	82 10 20 02 	mov  2, %g1                                    
40037a30:	c2 27 60 38 	st  %g1, [ %i5 + 0x38 ]                        
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
  the_watchdog->routine   = routine;                                  
40037a34:	03 10 00 de 	sethi  %hi(0x40037800), %g1                    
40037a38:	82 10 62 dc 	or  %g1, 0x2dc, %g1	! 40037adc <_Rate_monotonic_Timeout>
  the_watchdog->id        = id;                                       
40037a3c:	f0 27 60 30 	st  %i0, [ %i5 + 0x30 ]                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
40037a40:	92 07 60 10 	add  %i5, 0x10, %o1                            
40037a44:	11 10 01 a1 	sethi  %hi(0x40068400), %o0                    
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
40037a48:	c0 27 60 18 	clr  [ %i5 + 0x18 ]                            
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
40037a4c:	90 12 21 38 	or  %o0, 0x138, %o0                            
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
  the_watchdog->routine   = routine;                                  
  the_watchdog->id        = id;                                       
  the_watchdog->user_data = user_data;                                
40037a50:	c0 27 60 34 	clr  [ %i5 + 0x34 ]                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
  the_watchdog->routine   = routine;                                  
40037a54:	c2 27 60 2c 	st  %g1, [ %i5 + 0x2c ]                        
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
40037a58:	f2 27 60 1c 	st  %i1, [ %i5 + 0x1c ]                        
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
40037a5c:	7f ff 4a b8 	call  4000a53c <_Watchdog_Insert>              
40037a60:	b0 10 20 00 	clr  %i0                                       
40037a64:	30 bf ff c8 	b,a   40037984 <rtems_rate_monotonic_period+0x84>
                                                                      
      if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {             
        /*                                                            
         *  Update statistics from the concluding period.             
         */                                                           
        _Rate_monotonic_Update_statistics( the_period );              
40037a68:	7f ff ff 34 	call  40037738 <_Rate_monotonic_Update_statistics>
40037a6c:	90 10 00 1d 	mov  %i5, %o0                                  
        /*                                                            
         *  This tells the _Rate_monotonic_Timeout that this task is  
         *  in the process of blocking on the period and that we      
         *  may be changing the length of the next period.            
         */                                                           
        the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING;         
40037a70:	82 10 20 01 	mov  1, %g1                                    
        the_period->next_length = length;                             
40037a74:	f2 27 60 3c 	st  %i1, [ %i5 + 0x3c ]                        
        /*                                                            
         *  This tells the _Rate_monotonic_Timeout that this task is  
         *  in the process of blocking on the period and that we      
         *  may be changing the length of the next period.            
         */                                                           
        the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING;         
40037a78:	c2 27 60 38 	st  %g1, [ %i5 + 0x38 ]                        
        the_period->next_length = length;                             
                                                                      
        _ISR_Enable( level );                                         
40037a7c:	7f ff 29 02 	call  40001e84 <sparc_enable_interrupts>       
40037a80:	90 10 00 1a 	mov  %i2, %o0                                  
                                                                      
        _Thread_Executing->Wait.id = the_period->Object.id;           
40037a84:	c2 07 20 10 	ld  [ %i4 + 0x10 ], %g1                        
40037a88:	c4 07 60 08 	ld  [ %i5 + 8 ], %g2                           
        _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
40037a8c:	90 10 00 01 	mov  %g1, %o0                                  
40037a90:	13 00 00 10 	sethi  %hi(0x4000), %o1                        
40037a94:	7f ff 49 be 	call  4000a18c <_Thread_Set_state>             
40037a98:	c4 20 60 20 	st  %g2, [ %g1 + 0x20 ]                        
                                                                      
        /*                                                            
         *  Did the watchdog timer expire while we were actually blocking
         *  on it?                                                    
         */                                                           
        _ISR_Disable( level );                                        
40037a9c:	7f ff 28 f6 	call  40001e74 <sparc_disable_interrupts>      
40037aa0:	01 00 00 00 	nop                                            
          local_state = the_period->state;                            
40037aa4:	f4 07 60 38 	ld  [ %i5 + 0x38 ], %i2                        
          the_period->state = RATE_MONOTONIC_ACTIVE;                  
40037aa8:	f6 27 60 38 	st  %i3, [ %i5 + 0x38 ]                        
        _ISR_Enable( level );                                         
40037aac:	7f ff 28 f6 	call  40001e84 <sparc_enable_interrupts>       
40037ab0:	01 00 00 00 	nop                                            
                                                                      
        /*                                                            
         *  If it did, then we want to unblock ourself and continue as
         *  if nothing happen.  The period was reset in the timeout routine.
         */                                                           
        if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING )   
40037ab4:	80 a6 a0 03 	cmp  %i2, 3                                    
40037ab8:	22 80 00 06 	be,a   40037ad0 <rtems_rate_monotonic_period+0x1d0>
40037abc:	d0 07 20 10 	ld  [ %i4 + 0x10 ], %o0                        
          _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
                                                                      
        _Thread_Enable_dispatch();                                    
40037ac0:	7f ff 47 63 	call  4000984c <_Thread_Enable_dispatch>       
40037ac4:	b0 10 20 00 	clr  %i0                                       
40037ac8:	81 c7 e0 08 	ret                                            
40037acc:	81 e8 00 00 	restore                                        
        /*                                                            
         *  If it did, then we want to unblock ourself and continue as
         *  if nothing happen.  The period was reset in the timeout routine.
         */                                                           
        if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING )   
          _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
40037ad0:	7f ff 46 72 	call  40009498 <_Thread_Clear_state>           
40037ad4:	13 00 00 10 	sethi  %hi(0x4000), %o1                        
40037ad8:	30 bf ff fa 	b,a   40037ac0 <rtems_rate_monotonic_period+0x1c0>
                                                                      

40029380 <rtems_rate_monotonic_report_statistics_with_plugin>: void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) {
40029380:	9d e3 bf 38 	save  %sp, -200, %sp                           
  rtems_id                               id;                          
  rtems_rate_monotonic_period_statistics the_stats;                   
  rtems_rate_monotonic_period_status     the_status;                  
  char                                   name[5];                     
                                                                      
  if ( !print )                                                       
40029384:	80 a6 60 00 	cmp  %i1, 0                                    
40029388:	02 80 00 48 	be  400294a8 <rtems_rate_monotonic_report_statistics_with_plugin+0x128><== NEVER TAKEN
4002938c:	90 10 00 18 	mov  %i0, %o0                                  
    return;                                                           
                                                                      
  (*print)( context, "Period information by period\n" );              
40029390:	13 10 01 7d 	sethi  %hi(0x4005f400), %o1                    
40029394:	9f c6 40 00 	call  %i1                                      
40029398:	92 12 62 30 	or  %o1, 0x230, %o1	! 4005f630 <_TOD_Days_per_month+0x68>
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    (*print)( context, "--- CPU times are in seconds ---\n" );        
4002939c:	90 10 00 18 	mov  %i0, %o0                                  
400293a0:	13 10 01 7d 	sethi  %hi(0x4005f400), %o1                    
400293a4:	9f c6 40 00 	call  %i1                                      
400293a8:	92 12 62 50 	or  %o1, 0x250, %o1	! 4005f650 <_TOD_Days_per_month+0x88>
    (*print)( context, "--- Wall times are in seconds ---\n" );       
400293ac:	90 10 00 18 	mov  %i0, %o0                                  
400293b0:	13 10 01 7d 	sethi  %hi(0x4005f400), %o1                    
400293b4:	9f c6 40 00 	call  %i1                                      
400293b8:	92 12 62 78 	or  %o1, 0x278, %o1	! 4005f678 <_TOD_Days_per_month+0xb0>
  Be sure to test the various cases.                                  
  (*print)( context,"\                                                
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");                                                                 
*/                                                                    
  (*print)( context, "   ID     OWNER COUNT MISSED     "              
400293bc:	90 10 00 18 	mov  %i0, %o0                                  
400293c0:	13 10 01 7d 	sethi  %hi(0x4005f400), %o1                    
400293c4:	9f c6 40 00 	call  %i1                                      
400293c8:	92 12 62 a0 	or  %o1, 0x2a0, %o1	! 4005f6a0 <_TOD_Days_per_month+0xd8>
       #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                     
          "          "                                                
       #endif                                                         
          "   WALL TIME\n"                                            
  );                                                                  
  (*print)( context, "                               "                
400293cc:	90 10 00 18 	mov  %i0, %o0                                  
400293d0:	13 10 01 7d 	sethi  %hi(0x4005f400), %o1                    
400293d4:	9f c6 40 00 	call  %i1                                      
400293d8:	92 12 62 f0 	or  %o1, 0x2f0, %o1	! 4005f6f0 <_TOD_Days_per_month+0x128>
                                                                      
  /*                                                                  
   * Cycle through all possible ids and try to report on each one.  If it
   * is a period that is inactive, we just get an error back.  No big deal.
   */                                                                 
  for ( id=_Rate_monotonic_Information.minimum_id ;                   
400293dc:	39 10 01 a3 	sethi  %hi(0x40068c00), %i4                    
400293e0:	b8 17 23 78 	or  %i4, 0x378, %i4	! 40068f78 <_Rate_monotonic_Information>
400293e4:	fa 07 20 08 	ld  [ %i4 + 8 ], %i5                           
400293e8:	c2 07 20 0c 	ld  [ %i4 + 0xc ], %g1                         
400293ec:	80 a7 40 01 	cmp  %i5, %g1                                  
400293f0:	18 80 00 2e 	bgu  400294a8 <rtems_rate_monotonic_report_statistics_with_plugin+0x128><== NEVER TAKEN
400293f4:	35 10 01 7d 	sethi  %hi(0x4005f400), %i2                    
      struct timespec *min_cpu = &the_stats.min_cpu_time;             
      struct timespec *max_cpu = &the_stats.max_cpu_time;             
      struct timespec *total_cpu = &the_stats.total_cpu_time;         
                                                                      
      _Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
      (*print)( context,                                              
400293f8:	27 10 01 7d 	sethi  %hi(0x4005f400), %l3                    
      struct timespec *min_wall = &the_stats.min_wall_time;           
      struct timespec *max_wall = &the_stats.max_wall_time;           
      struct timespec *total_wall = &the_stats.total_wall_time;       
                                                                      
      _Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
      (*print)( context,                                              
400293fc:	25 10 01 7d 	sethi  %hi(0x4005f400), %l2                    
                                                                      
    /*                                                                
     *  If the count is zero, don't print statistics                  
     */                                                               
    if (the_stats.count == 0) {                                       
      (*print)( context, "\n" );                                      
40029400:	37 10 01 83 	sethi  %hi(0x40060c00), %i3                    
    rtems_object_get_name( the_status.owner, sizeof(name), name );    
                                                                      
    /*                                                                
     *  Print part of report line that is not dependent on granularity
     */                                                               
    (*print)( context,                                                
40029404:	b4 16 a3 40 	or  %i2, 0x340, %i2                            
      struct timespec *min_cpu = &the_stats.min_cpu_time;             
      struct timespec *max_cpu = &the_stats.max_cpu_time;             
      struct timespec *total_cpu = &the_stats.total_cpu_time;         
                                                                      
      _Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
      (*print)( context,                                              
40029408:	a6 14 e3 58 	or  %l3, 0x358, %l3                            
      struct timespec *min_wall = &the_stats.min_wall_time;           
      struct timespec *max_wall = &the_stats.max_wall_time;           
      struct timespec *total_wall = &the_stats.total_wall_time;       
                                                                      
      _Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
      (*print)( context,                                              
4002940c:	a4 14 a3 78 	or  %l2, 0x378, %l2                            
                                                                      
    /*                                                                
     *  If the count is zero, don't print statistics                  
     */                                                               
    if (the_stats.count == 0) {                                       
      (*print)( context, "\n" );                                      
40029410:	10 80 00 06 	b  40029428 <rtems_rate_monotonic_report_statistics_with_plugin+0xa8>
40029414:	b6 16 e0 00 	mov  %i3, %i3                                  
   * Cycle through all possible ids and try to report on each one.  If it
   * is a period that is inactive, we just get an error back.  No big deal.
   */                                                                 
  for ( id=_Rate_monotonic_Information.minimum_id ;                   
        id <= _Rate_monotonic_Information.maximum_id ;                
        id++ ) {                                                      
40029418:	ba 07 60 01 	inc  %i5                                       
                                                                      
  /*                                                                  
   * Cycle through all possible ids and try to report on each one.  If it
   * is a period that is inactive, we just get an error back.  No big deal.
   */                                                                 
  for ( id=_Rate_monotonic_Information.minimum_id ;                   
4002941c:	80 a0 40 1d 	cmp  %g1, %i5                                  
40029420:	0a 80 00 22 	bcs  400294a8 <rtems_rate_monotonic_report_statistics_with_plugin+0x128>
40029424:	01 00 00 00 	nop                                            
        id <= _Rate_monotonic_Information.maximum_id ;                
        id++ ) {                                                      
    status = rtems_rate_monotonic_get_statistics( id, &the_stats );   
40029428:	90 10 00 1d 	mov  %i5, %o0                                  
4002942c:	40 00 37 df 	call  400373a8 <rtems_rate_monotonic_get_statistics>
40029430:	92 07 bf c8 	add  %fp, -56, %o1                             
    if ( status != RTEMS_SUCCESSFUL )                                 
40029434:	80 a2 20 00 	cmp  %o0, 0                                    
40029438:	32 bf ff f8 	bne,a   40029418 <rtems_rate_monotonic_report_statistics_with_plugin+0x98>
4002943c:	c2 07 20 0c 	ld  [ %i4 + 0xc ], %g1                         
    #if defined(RTEMS_DEBUG)                                          
      status = rtems_rate_monotonic_get_status( id, &the_status );    
      if ( status != RTEMS_SUCCESSFUL )                               
        continue;                                                     
    #else                                                             
      (void) rtems_rate_monotonic_get_status( id, &the_status );      
40029440:	92 07 bf b0 	add  %fp, -80, %o1                             
40029444:	40 00 38 4b 	call  40037570 <rtems_rate_monotonic_get_status>
40029448:	90 10 00 1d 	mov  %i5, %o0                                  
    #endif                                                            
                                                                      
    rtems_object_get_name( the_status.owner, sizeof(name), name );    
4002944c:	d0 07 bf b0 	ld  [ %fp + -80 ], %o0                         
40029450:	94 07 bf a0 	add  %fp, -96, %o2                             
40029454:	7f ff 97 6e 	call  4000f20c <rtems_object_get_name>         
40029458:	92 10 20 05 	mov  5, %o1                                    
                                                                      
    /*                                                                
     *  Print part of report line that is not dependent on granularity
     */                                                               
    (*print)( context,                                                
4002945c:	d8 1f bf c8 	ldd  [ %fp + -56 ], %o4                        
40029460:	92 10 00 1a 	mov  %i2, %o1                                  
40029464:	94 10 00 1d 	mov  %i5, %o2                                  
40029468:	90 10 00 18 	mov  %i0, %o0                                  
4002946c:	9f c6 40 00 	call  %i1                                      
40029470:	96 07 bf a0 	add  %fp, -96, %o3                             
    );                                                                
                                                                      
    /*                                                                
     *  If the count is zero, don't print statistics                  
     */                                                               
    if (the_stats.count == 0) {                                       
40029474:	c2 07 bf c8 	ld  [ %fp + -56 ], %g1                         
      struct timespec  cpu_average;                                   
      struct timespec *min_cpu = &the_stats.min_cpu_time;             
      struct timespec *max_cpu = &the_stats.max_cpu_time;             
      struct timespec *total_cpu = &the_stats.total_cpu_time;         
                                                                      
      _Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
40029478:	94 07 bf a8 	add  %fp, -88, %o2                             
4002947c:	90 07 bf e0 	add  %fp, -32, %o0                             
    );                                                                
                                                                      
    /*                                                                
     *  If the count is zero, don't print statistics                  
     */                                                               
    if (the_stats.count == 0) {                                       
40029480:	80 a0 60 00 	cmp  %g1, 0                                    
40029484:	12 80 00 0b 	bne  400294b0 <rtems_rate_monotonic_report_statistics_with_plugin+0x130>
40029488:	92 10 00 1b 	mov  %i3, %o1                                  
      (*print)( context, "\n" );                                      
4002948c:	9f c6 40 00 	call  %i1                                      
40029490:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
  /*                                                                  
   * Cycle through all possible ids and try to report on each one.  If it
   * is a period that is inactive, we just get an error back.  No big deal.
   */                                                                 
  for ( id=_Rate_monotonic_Information.minimum_id ;                   
40029494:	c2 07 20 0c 	ld  [ %i4 + 0xc ], %g1                         
        id <= _Rate_monotonic_Information.maximum_id ;                
        id++ ) {                                                      
40029498:	ba 07 60 01 	inc  %i5                                       
                                                                      
  /*                                                                  
   * Cycle through all possible ids and try to report on each one.  If it
   * is a period that is inactive, we just get an error back.  No big deal.
   */                                                                 
  for ( id=_Rate_monotonic_Information.minimum_id ;                   
4002949c:	80 a0 40 1d 	cmp  %g1, %i5                                  
400294a0:	1a bf ff e3 	bcc  4002942c <rtems_rate_monotonic_report_statistics_with_plugin+0xac><== ALWAYS TAKEN
400294a4:	90 10 00 1d 	mov  %i5, %o0                                  
400294a8:	81 c7 e0 08 	ret                                            
400294ac:	81 e8 00 00 	restore                                        
      struct timespec  cpu_average;                                   
      struct timespec *min_cpu = &the_stats.min_cpu_time;             
      struct timespec *max_cpu = &the_stats.max_cpu_time;             
      struct timespec *total_cpu = &the_stats.total_cpu_time;         
                                                                      
      _Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
400294b0:	40 00 03 5e 	call  4002a228 <_Timespec_Divide_by_integer>   
400294b4:	92 10 00 01 	mov  %g1, %o1                                  
      (*print)( context,                                              
400294b8:	d0 07 bf d4 	ld  [ %fp + -44 ], %o0                         
400294bc:	40 00 ae e2 	call  40055044 <.div>                          
400294c0:	92 10 23 e8 	mov  0x3e8, %o1                                
400294c4:	aa 10 00 08 	mov  %o0, %l5                                  
400294c8:	d0 07 bf dc 	ld  [ %fp + -36 ], %o0                         
400294cc:	40 00 ae de 	call  40055044 <.div>                          
400294d0:	92 10 23 e8 	mov  0x3e8, %o1                                
400294d4:	c2 07 bf a8 	ld  [ %fp + -88 ], %g1                         
400294d8:	a2 10 00 08 	mov  %o0, %l1                                  
400294dc:	d0 07 bf ac 	ld  [ %fp + -84 ], %o0                         
400294e0:	e0 07 bf d0 	ld  [ %fp + -48 ], %l0                         
400294e4:	e8 07 bf d8 	ld  [ %fp + -40 ], %l4                         
400294e8:	c2 23 a0 5c 	st  %g1, [ %sp + 0x5c ]                        
400294ec:	40 00 ae d6 	call  40055044 <.div>                          
400294f0:	92 10 23 e8 	mov  0x3e8, %o1                                
400294f4:	96 10 00 15 	mov  %l5, %o3                                  
400294f8:	98 10 00 14 	mov  %l4, %o4                                  
400294fc:	9a 10 00 11 	mov  %l1, %o5                                  
40029500:	d0 23 a0 60 	st  %o0, [ %sp + 0x60 ]                        
40029504:	92 10 00 13 	mov  %l3, %o1                                  
40029508:	94 10 00 10 	mov  %l0, %o2                                  
4002950c:	9f c6 40 00 	call  %i1                                      
40029510:	90 10 00 18 	mov  %i0, %o0                                  
      struct timespec  wall_average;                                  
      struct timespec *min_wall = &the_stats.min_wall_time;           
      struct timespec *max_wall = &the_stats.max_wall_time;           
      struct timespec *total_wall = &the_stats.total_wall_time;       
                                                                      
      _Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
40029514:	d2 07 bf c8 	ld  [ %fp + -56 ], %o1                         
40029518:	94 07 bf a8 	add  %fp, -88, %o2                             
4002951c:	40 00 03 43 	call  4002a228 <_Timespec_Divide_by_integer>   
40029520:	90 07 bf f8 	add  %fp, -8, %o0                              
      (*print)( context,                                              
40029524:	d0 07 bf ec 	ld  [ %fp + -20 ], %o0                         
40029528:	40 00 ae c7 	call  40055044 <.div>                          
4002952c:	92 10 23 e8 	mov  0x3e8, %o1                                
40029530:	a8 10 00 08 	mov  %o0, %l4                                  
40029534:	d0 07 bf f4 	ld  [ %fp + -12 ], %o0                         
40029538:	40 00 ae c3 	call  40055044 <.div>                          
4002953c:	92 10 23 e8 	mov  0x3e8, %o1                                
40029540:	c2 07 bf a8 	ld  [ %fp + -88 ], %g1                         
40029544:	a0 10 00 08 	mov  %o0, %l0                                  
40029548:	d0 07 bf ac 	ld  [ %fp + -84 ], %o0                         
4002954c:	ea 07 bf e8 	ld  [ %fp + -24 ], %l5                         
40029550:	e2 07 bf f0 	ld  [ %fp + -16 ], %l1                         
40029554:	92 10 23 e8 	mov  0x3e8, %o1                                
40029558:	40 00 ae bb 	call  40055044 <.div>                          
4002955c:	c2 23 a0 5c 	st  %g1, [ %sp + 0x5c ]                        
40029560:	92 10 00 12 	mov  %l2, %o1                                  
40029564:	d0 23 a0 60 	st  %o0, [ %sp + 0x60 ]                        
40029568:	94 10 00 15 	mov  %l5, %o2                                  
4002956c:	90 10 00 18 	mov  %i0, %o0                                  
40029570:	96 10 00 14 	mov  %l4, %o3                                  
40029574:	98 10 00 11 	mov  %l1, %o4                                  
40029578:	9f c6 40 00 	call  %i1                                      
4002957c:	9a 10 00 10 	mov  %l0, %o5                                  
                                                                      
  /*                                                                  
   * Cycle through all possible ids and try to report on each one.  If it
   * is a period that is inactive, we just get an error back.  No big deal.
   */                                                                 
  for ( id=_Rate_monotonic_Information.minimum_id ;                   
40029580:	10 bf ff a6 	b  40029418 <rtems_rate_monotonic_report_statistics_with_plugin+0x98>
40029584:	c2 07 20 0c 	ld  [ %i4 + 0xc ], %g1                         
                                                                      

400295a0 <rtems_rate_monotonic_reset_all_statistics>: /* * rtems_rate_monotonic_reset_all_statistics */ void rtems_rate_monotonic_reset_all_statistics( void ) {
400295a0:	9d e3 bf a0 	save  %sp, -96, %sp                            
   *                                                                  
   * This rountine increments the thread dispatch level               
   */                                                                 
  RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
  {                                                                   
    uint32_t level = _Thread_Dispatch_disable_level;                  
400295a4:	03 10 01 a1 	sethi  %hi(0x40068400), %g1                    
400295a8:	c4 00 60 a0 	ld  [ %g1 + 0xa0 ], %g2	! 400684a0 <_Thread_Dispatch_disable_level>
                                                                      
    ++level;                                                          
400295ac:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
400295b0:	c4 20 60 a0 	st  %g2, [ %g1 + 0xa0 ]                        
                                                                      
    /*                                                                
     * Cycle through all possible ids and try to reset each one.  If it
     * is a period that is inactive, we just get an error back.  No big deal.
     */                                                               
    for ( id=_Rate_monotonic_Information.minimum_id ;                 
400295b4:	39 10 01 a3 	sethi  %hi(0x40068c00), %i4                    
400295b8:	b8 17 23 78 	or  %i4, 0x378, %i4	! 40068f78 <_Rate_monotonic_Information>
400295bc:	fa 07 20 08 	ld  [ %i4 + 8 ], %i5                           
400295c0:	c2 07 20 0c 	ld  [ %i4 + 0xc ], %g1                         
400295c4:	80 a7 40 01 	cmp  %i5, %g1                                  
400295c8:	18 80 00 09 	bgu  400295ec <rtems_rate_monotonic_reset_all_statistics+0x4c><== NEVER TAKEN
400295cc:	01 00 00 00 	nop                                            
          id <= _Rate_monotonic_Information.maximum_id ;              
          id++ ) {                                                    
      (void) rtems_rate_monotonic_reset_statistics( id );             
400295d0:	40 00 00 09 	call  400295f4 <rtems_rate_monotonic_reset_statistics>
400295d4:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
    /*                                                                
     * Cycle through all possible ids and try to reset each one.  If it
     * is a period that is inactive, we just get an error back.  No big deal.
     */                                                               
    for ( id=_Rate_monotonic_Information.minimum_id ;                 
400295d8:	c2 07 20 0c 	ld  [ %i4 + 0xc ], %g1                         
          id <= _Rate_monotonic_Information.maximum_id ;              
          id++ ) {                                                    
400295dc:	ba 07 60 01 	inc  %i5                                       
                                                                      
    /*                                                                
     * Cycle through all possible ids and try to reset each one.  If it
     * is a period that is inactive, we just get an error back.  No big deal.
     */                                                               
    for ( id=_Rate_monotonic_Information.minimum_id ;                 
400295e0:	80 a0 40 1d 	cmp  %g1, %i5                                  
400295e4:	1a bf ff fb 	bcc  400295d0 <rtems_rate_monotonic_reset_all_statistics+0x30>
400295e8:	01 00 00 00 	nop                                            
    }                                                                 
                                                                      
  /*                                                                  
   *  Done so exit thread dispatching disabled critical section.      
   */                                                                 
  _Thread_Enable_dispatch();                                          
400295ec:	7f ff 80 98 	call  4000984c <_Thread_Enable_dispatch>       
400295f0:	81 e8 00 00 	restore                                        
                                                                      

400082f4 <rtems_rbheap_allocate>: return big_enough; } void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size) {
400082f4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  void *ptr = NULL;                                                   
  rtems_chain_control *free_chain = &control->free_chunk_chain;       
  rtems_rbtree_control *chunk_tree = &control->chunk_tree;            
  uintptr_t alignment = control->alignment;                           
400082f8:	fa 06 20 30 	ld  [ %i0 + 0x30 ], %i5                        
                                                                      
#include <stdlib.h>                                                   
                                                                      
static uintptr_t align_up(uintptr_t alignment, uintptr_t value)       
{                                                                     
  uintptr_t excess = value % alignment;                               
400082fc:	90 10 00 19 	mov  %i1, %o0                                  
40008300:	40 00 2f 87 	call  4001411c <.urem>                         
40008304:	92 10 00 1d 	mov  %i5, %o1                                  
                                                                      
  if (excess > 0) {                                                   
40008308:	80 a2 20 00 	cmp  %o0, 0                                    
4000830c:	02 80 00 26 	be  400083a4 <rtems_rbheap_allocate+0xb0>      <== ALWAYS TAKEN
40008310:	b6 10 00 19 	mov  %i1, %i3                                  
    value += alignment - excess;                                      
40008314:	ba 06 40 1d 	add  %i1, %i5, %i5                             <== NOT EXECUTED
40008318:	b6 27 40 08 	sub  %i5, %o0, %i3                             <== NOT EXECUTED
4000831c:	80 a6 c0 19 	cmp  %i3, %i1                                  <== NOT EXECUTED
40008320:	82 60 3f ff 	subx  %g0, -1, %g1                             <== NOT EXECUTED
  rtems_chain_control *free_chain = &control->free_chunk_chain;       
  rtems_rbtree_control *chunk_tree = &control->chunk_tree;            
  uintptr_t alignment = control->alignment;                           
  uintptr_t aligned_size = align_up(alignment, size);                 
                                                                      
  if (size > 0 && size <= aligned_size) {                             
40008324:	80 88 60 ff 	btst  0xff, %g1                                
40008328:	02 80 00 1d 	be  4000839c <rtems_rbheap_allocate+0xa8>      <== NEVER TAKEN
4000832c:	80 a6 60 00 	cmp  %i1, 0                                    
40008330:	02 80 00 1b 	be  4000839c <rtems_rbheap_allocate+0xa8>      
40008334:	82 06 20 04 	add  %i0, 4, %g1                               
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return _Chain_Head( the_chain )->next;                              
40008338:	fa 06 00 00 	ld  [ %i0 ], %i5                               
{                                                                     
  rtems_chain_node *current = rtems_chain_first(free_chain);          
  const rtems_chain_node *tail = rtems_chain_tail(free_chain);        
  rtems_rbheap_chunk *big_enough = NULL;                              
                                                                      
  while (current != tail && big_enough == NULL) {                     
4000833c:	80 a7 40 01 	cmp  %i5, %g1                                  
40008340:	02 80 00 17 	be  4000839c <rtems_rbheap_allocate+0xa8>      
40008344:	01 00 00 00 	nop                                            
    rtems_rbheap_chunk *free_chunk = (rtems_rbheap_chunk *) current;  
                                                                      
    if (free_chunk->size >= size) {                                   
40008348:	f8 07 60 1c 	ld  [ %i5 + 0x1c ], %i4                        
4000834c:	80 a6 c0 1c 	cmp  %i3, %i4                                  
40008350:	38 80 00 10 	bgu,a   40008390 <rtems_rbheap_allocate+0x9c>  
40008354:	fa 07 40 00 	ld  [ %i5 ], %i5                               
  uintptr_t aligned_size = align_up(alignment, size);                 
                                                                      
  if (size > 0 && size <= aligned_size) {                             
    rtems_rbheap_chunk *free_chunk = search_free_chunk(free_chain, aligned_size);
                                                                      
    if (free_chunk != NULL) {                                         
40008358:	80 a7 60 00 	cmp  %i5, 0                                    
4000835c:	02 80 00 10 	be  4000839c <rtems_rbheap_allocate+0xa8>      <== NEVER TAKEN
40008360:	80 a7 00 1b 	cmp  %i4, %i3                                  
      uintptr_t free_size = free_chunk->size;                         
                                                                      
      if (free_size > aligned_size) {                                 
40008364:	18 80 00 12 	bgu  400083ac <rtems_rbheap_allocate+0xb8>     
40008368:	01 00 00 00 	nop                                            
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
4000836c:	c4 07 40 00 	ld  [ %i5 ], %g2                               
  previous       = the_node->previous;                                
40008370:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
          ptr = (void *) new_chunk->begin;                            
        }                                                             
      } else {                                                        
        rtems_chain_extract_unprotected(&free_chunk->chain_node);     
        rtems_chain_set_off_chain(&free_chunk->chain_node);           
        ptr = (void *) free_chunk->begin;                             
40008374:	f0 07 60 18 	ld  [ %i5 + 0x18 ], %i0                        
  next->previous = previous;                                          
40008378:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]                           
  previous->next = next;                                              
4000837c:	c4 20 40 00 	st  %g2, [ %g1 ]                               
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(                       
  Chain_Node *node                                                    
)                                                                     
{                                                                     
  node->next = node->previous = NULL;                                 
40008380:	c0 27 60 04 	clr  [ %i5 + 4 ]                               
40008384:	c0 27 40 00 	clr  [ %i5 ]                                   
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  return ptr;                                                         
}                                                                     
40008388:	81 c7 e0 08 	ret                                            
4000838c:	81 e8 00 00 	restore                                        
{                                                                     
  rtems_chain_node *current = rtems_chain_first(free_chain);          
  const rtems_chain_node *tail = rtems_chain_tail(free_chain);        
  rtems_rbheap_chunk *big_enough = NULL;                              
                                                                      
  while (current != tail && big_enough == NULL) {                     
40008390:	80 a0 40 1d 	cmp  %g1, %i5                                  
40008394:	32 bf ff ee 	bne,a   4000834c <rtems_rbheap_allocate+0x58>  <== NEVER TAKEN
40008398:	f8 07 60 1c 	ld  [ %i5 + 0x1c ], %i4                        <== NOT EXECUTED
  return big_enough;                                                  
}                                                                     
                                                                      
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{                                                                     
  void *ptr = NULL;                                                   
4000839c:	81 c7 e0 08 	ret                                            
400083a0:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      
static uintptr_t align_up(uintptr_t alignment, uintptr_t value)       
{                                                                     
  uintptr_t excess = value % alignment;                               
                                                                      
  if (excess > 0) {                                                   
400083a4:	10 bf ff e0 	b  40008324 <rtems_rbheap_allocate+0x30>       
400083a8:	82 10 20 01 	mov  1, %g1                                    
                                                                      
    if (free_chunk != NULL) {                                         
      uintptr_t free_size = free_chunk->size;                         
                                                                      
      if (free_size > aligned_size) {                                 
        rtems_rbheap_chunk *new_chunk = get_chunk(control);           
400083ac:	7f ff ff 46 	call  400080c4 <get_chunk>                     
400083b0:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
        if (new_chunk != NULL) {                                      
400083b4:	b4 92 20 00 	orcc  %o0, 0, %i2                              
400083b8:	02 bf ff f9 	be  4000839c <rtems_rbheap_allocate+0xa8>      <== NEVER TAKEN
400083bc:	b8 27 00 1b 	sub  %i4, %i3, %i4                             
          uintptr_t new_free_size = free_size - aligned_size;         
                                                                      
          free_chunk->size = new_free_size;                           
          new_chunk->begin = free_chunk->begin + new_free_size;       
400083c0:	c2 07 60 18 	ld  [ %i5 + 0x18 ], %g1                        
        rtems_rbheap_chunk *new_chunk = get_chunk(control);           
                                                                      
        if (new_chunk != NULL) {                                      
          uintptr_t new_free_size = free_size - aligned_size;         
                                                                      
          free_chunk->size = new_free_size;                           
400083c4:	f8 27 60 1c 	st  %i4, [ %i5 + 0x1c ]                        
          new_chunk->begin = free_chunk->begin + new_free_size;       
          new_chunk->size = aligned_size;                             
400083c8:	f6 26 a0 1c 	st  %i3, [ %i2 + 0x1c ]                        
                                                                      
        if (new_chunk != NULL) {                                      
          uintptr_t new_free_size = free_size - aligned_size;         
                                                                      
          free_chunk->size = new_free_size;                           
          new_chunk->begin = free_chunk->begin + new_free_size;       
400083cc:	b8 07 00 01 	add  %i4, %g1, %i4                             
400083d0:	c0 26 a0 04 	clr  [ %i2 + 4 ]                               
400083d4:	f8 26 a0 18 	st  %i4, [ %i2 + 0x18 ]                        
400083d8:	c0 26 80 00 	clr  [ %i2 ]                                   
static void insert_into_tree(                                         
  rtems_rbtree_control *tree,                                         
  rtems_rbheap_chunk *chunk                                           
)                                                                     
{                                                                     
  _RBTree_Insert_unprotected(tree, &chunk->tree_node);                
400083dc:	90 06 20 18 	add  %i0, 0x18, %o0                            
400083e0:	40 00 06 fd 	call  40009fd4 <_RBTree_Insert_unprotected>    
400083e4:	92 06 a0 08 	add  %i2, 8, %o1                               
          free_chunk->size = new_free_size;                           
          new_chunk->begin = free_chunk->begin + new_free_size;       
          new_chunk->size = aligned_size;                             
          rtems_chain_set_off_chain(&new_chunk->chain_node);          
          insert_into_tree(chunk_tree, new_chunk);                    
          ptr = (void *) new_chunk->begin;                            
400083e8:	f0 06 a0 18 	ld  [ %i2 + 0x18 ], %i0                        
400083ec:	81 c7 e0 08 	ret                                            
400083f0:	81 e8 00 00 	restore                                        
                                                                      

40008538 <rtems_rbheap_extend_descriptors_with_malloc>: /* Do nothing */ } void rtems_rbheap_extend_descriptors_with_malloc(rtems_rbheap_control *control) {
40008538:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
  rtems_rbheap_chunk *chunk = malloc(sizeof(*chunk));                 
4000853c:	7f ff ec de 	call  400038b4 <malloc>                        <== NOT EXECUTED
40008540:	90 10 20 20 	mov  0x20, %o0                                 <== NOT EXECUTED
                                                                      
  if (chunk != NULL) {                                                
40008544:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40008548:	02 80 00 07 	be  40008564 <rtems_rbheap_extend_descriptors_with_malloc+0x2c><== NOT EXECUTED
4000854c:	84 06 20 0c 	add  %i0, 0xc, %g2                             <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
40008550:	c2 06 20 0c 	ld  [ %i0 + 0xc ], %g1                         <== NOT EXECUTED
  after_node->next      = the_node;                                   
40008554:	d0 26 20 0c 	st  %o0, [ %i0 + 0xc ]                         <== NOT EXECUTED
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
40008558:	c4 22 20 04 	st  %g2, [ %o0 + 4 ]                           <== NOT EXECUTED
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
  the_node->next        = before_node;                                
4000855c:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
  before_node->previous = the_node;                                   
40008560:	d0 20 60 04 	st  %o0, [ %g1 + 4 ]                           <== NOT EXECUTED
40008564:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40008568:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

400083f4 <rtems_rbheap_free>: _RBTree_Extract_unprotected(chunk_tree, &b->tree_node); } } rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr) {
400083f4:	9d e3 bf 80 	save  %sp, -128, %sp                           
400083f8:	b4 10 00 18 	mov  %i0, %i2                                  
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  if (ptr != NULL) {                                                  
400083fc:	80 a6 60 00 	cmp  %i1, 0                                    
40008400:	02 80 00 2a 	be  400084a8 <rtems_rbheap_free+0xb4>          
40008404:	b0 10 20 00 	clr  %i0                                       
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Find_unprotected(           
    RBTree_Control *the_rbtree,                                       
    RBTree_Node *the_node                                             
    )                                                                 
{                                                                     
  RBTree_Node* iter_node = the_rbtree->root;                          
40008408:	fa 06 a0 1c 	ld  [ %i2 + 0x1c ], %i5                        
                                                                      
#define NULL_PAGE rtems_rbheap_chunk_of_node(NULL)                    
                                                                      
static rtems_rbheap_chunk *find(rtems_rbtree_control *chunk_tree, uintptr_t key)
{                                                                     
  rtems_rbheap_chunk chunk = { .begin = key };                        
4000840c:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
40008410:	c0 27 bf e0 	clr  [ %fp + -32 ]                             
40008414:	c0 27 bf e4 	clr  [ %fp + -28 ]                             
40008418:	c0 27 bf e8 	clr  [ %fp + -24 ]                             
4000841c:	c0 27 bf ec 	clr  [ %fp + -20 ]                             
40008420:	c0 27 bf f0 	clr  [ %fp + -16 ]                             
40008424:	c0 27 bf f4 	clr  [ %fp + -12 ]                             
40008428:	f2 27 bf f8 	st  %i1, [ %fp + -8 ]                          
  RBTree_Node* found = NULL;                                          
  int compare_result;                                                 
  while (iter_node) {                                                 
4000842c:	80 a7 60 00 	cmp  %i5, 0                                    
40008430:	02 80 00 3e 	be  40008528 <rtems_rbheap_free+0x134>         <== NEVER TAKEN
40008434:	b8 06 a0 18 	add  %i2, 0x18, %i4                            
40008438:	b6 10 20 00 	clr  %i3                                       
    compare_result = the_rbtree->compare_function(the_node, iter_node);
4000843c:	c2 07 20 10 	ld  [ %i4 + 0x10 ], %g1                        
40008440:	92 10 00 1d 	mov  %i5, %o1                                  
40008444:	9f c0 40 00 	call  %g1                                      
40008448:	90 07 bf e8 	add  %fp, -24, %o0                             
                                                                      
RTEMS_INLINE_ROUTINE bool _RBTree_Is_greater(                         
  int compare_result                                                  
)                                                                     
{                                                                     
  return compare_result > 0;                                          
4000844c:	83 3a 20 1f 	sra  %o0, 0x1f, %g1                            
  RBTree_Node* iter_node = the_rbtree->root;                          
  RBTree_Node* found = NULL;                                          
  int compare_result;                                                 
  while (iter_node) {                                                 
    compare_result = the_rbtree->compare_function(the_node, iter_node);
    if ( _RBTree_Is_equal( compare_result ) ) {                       
40008450:	80 a2 20 00 	cmp  %o0, 0                                    
                                                                      
RTEMS_INLINE_ROUTINE bool _RBTree_Is_greater(                         
  int compare_result                                                  
)                                                                     
{                                                                     
  return compare_result > 0;                                          
40008454:	82 20 40 08 	sub  %g1, %o0, %g1                             
40008458:	83 30 60 1f 	srl  %g1, 0x1f, %g1                            
        break;                                                        
    }                                                                 
                                                                      
    RBTree_Direction dir =                                            
      (RBTree_Direction) _RBTree_Is_greater( compare_result );        
    iter_node = iter_node->child[dir];                                
4000845c:	83 28 60 02 	sll  %g1, 2, %g1                               
  RBTree_Node* iter_node = the_rbtree->root;                          
  RBTree_Node* found = NULL;                                          
  int compare_result;                                                 
  while (iter_node) {                                                 
    compare_result = the_rbtree->compare_function(the_node, iter_node);
    if ( _RBTree_Is_equal( compare_result ) ) {                       
40008460:	12 80 00 06 	bne  40008478 <rtems_rbheap_free+0x84>         
40008464:	82 07 40 01 	add  %i5, %g1, %g1                             
      found = iter_node;                                              
      if ( the_rbtree->is_unique )                                    
40008468:	c4 0f 20 14 	ldub  [ %i4 + 0x14 ], %g2                      
4000846c:	80 a0 a0 00 	cmp  %g2, 0                                    
40008470:	12 80 00 10 	bne  400084b0 <rtems_rbheap_free+0xbc>         <== ALWAYS TAKEN
40008474:	b6 10 00 1d 	mov  %i5, %i3                                  
        break;                                                        
    }                                                                 
                                                                      
    RBTree_Direction dir =                                            
      (RBTree_Direction) _RBTree_Is_greater( compare_result );        
    iter_node = iter_node->child[dir];                                
40008478:	fa 00 60 04 	ld  [ %g1 + 4 ], %i5                           
    )                                                                 
{                                                                     
  RBTree_Node* iter_node = the_rbtree->root;                          
  RBTree_Node* found = NULL;                                          
  int compare_result;                                                 
  while (iter_node) {                                                 
4000847c:	80 a7 60 00 	cmp  %i5, 0                                    
40008480:	32 bf ff f0 	bne,a   40008440 <rtems_rbheap_free+0x4c>      
40008484:	c2 07 20 10 	ld  [ %i4 + 0x10 ], %g1                        
                                                                      
  return rtems_rbheap_chunk_of_node(                                  
40008488:	ba 06 ff f8 	add  %i3, -8, %i5                              
  if (ptr != NULL) {                                                  
    rtems_chain_control *free_chain = &control->free_chunk_chain;     
    rtems_rbtree_control *chunk_tree = &control->chunk_tree;          
    rtems_rbheap_chunk *chunk = find(chunk_tree, (uintptr_t) ptr);    
                                                                      
    if (chunk != NULL_PAGE) {                                         
4000848c:	80 a7 7f f8 	cmp  %i5, -8                                   
40008490:	02 80 00 06 	be  400084a8 <rtems_rbheap_free+0xb4>          
40008494:	b0 10 20 04 	mov  4, %i0                                    
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(                   
  const Chain_Node *node                                              
)                                                                     
{                                                                     
  return (node->next == NULL) && (node->previous == NULL);            
40008498:	c2 06 ff f8 	ld  [ %i3 + -8 ], %g1                          
4000849c:	80 a0 60 00 	cmp  %g1, 0                                    
400084a0:	02 80 00 06 	be  400084b8 <rtems_rbheap_free+0xc4>          
400084a4:	b0 10 20 0e 	mov  0xe, %i0                                  
      sc = RTEMS_INVALID_ID;                                          
    }                                                                 
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
400084a8:	81 c7 e0 08 	ret                                            
400084ac:	81 e8 00 00 	restore                                        
                                                                      
static rtems_rbheap_chunk *find(rtems_rbtree_control *chunk_tree, uintptr_t key)
{                                                                     
  rtems_rbheap_chunk chunk = { .begin = key };                        
                                                                      
  return rtems_rbheap_chunk_of_node(                                  
400084b0:	10 bf ff f7 	b  4000848c <rtems_rbheap_free+0x98>           
400084b4:	ba 06 ff f8 	add  %i3, -8, %i5                              
400084b8:	c2 06 ff fc 	ld  [ %i3 + -4 ], %g1                          
400084bc:	80 a0 60 00 	cmp  %g1, 0                                    
400084c0:	12 bf ff fa 	bne  400084a8 <rtems_rbheap_free+0xb4>         <== NEVER TAKEN
400084c4:	92 10 20 00 	clr  %o1                                       
static rtems_rbheap_chunk *get_next(                                  
  const rtems_rbheap_chunk *chunk,                                    
  RBTree_Direction dir                                                
)                                                                     
{                                                                     
  return rtems_rbheap_chunk_of_node(                                  
400084c8:	40 00 07 92 	call  4000a310 <_RBTree_Next_unprotected>      
400084cc:	90 10 00 1b 	mov  %i3, %o0                                  
400084d0:	92 10 20 01 	mov  1, %o1                                    
400084d4:	b2 10 00 08 	mov  %o0, %i1                                  
400084d8:	40 00 07 8e 	call  4000a310 <_RBTree_Next_unprotected>      
400084dc:	90 10 00 1b 	mov  %i3, %o0                                  
    if (chunk != NULL_PAGE) {                                         
      if (!rtems_rbheap_is_chunk_free(chunk)) {                       
        rtems_rbheap_chunk *pred = get_next(chunk, RBT_LEFT);         
        rtems_rbheap_chunk *succ = get_next(chunk, RBT_RIGHT);        
                                                                      
        check_and_merge(free_chain, chunk_tree, chunk, succ);         
400084e0:	92 10 00 1c 	mov  %i4, %o1                                  
static rtems_rbheap_chunk *get_next(                                  
  const rtems_rbheap_chunk *chunk,                                    
  RBTree_Direction dir                                                
)                                                                     
{                                                                     
  return rtems_rbheap_chunk_of_node(                                  
400084e4:	96 02 3f f8 	add  %o0, -8, %o3                              
    if (chunk != NULL_PAGE) {                                         
      if (!rtems_rbheap_is_chunk_free(chunk)) {                       
        rtems_rbheap_chunk *pred = get_next(chunk, RBT_LEFT);         
        rtems_rbheap_chunk *succ = get_next(chunk, RBT_RIGHT);        
                                                                      
        check_and_merge(free_chain, chunk_tree, chunk, succ);         
400084e8:	94 10 00 1d 	mov  %i5, %o2                                  
400084ec:	7f ff ff 10 	call  4000812c <check_and_merge>               
400084f0:	90 10 00 1a 	mov  %i2, %o0                                  
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
400084f4:	c2 06 80 00 	ld  [ %i2 ], %g1                               
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
400084f8:	f4 26 ff fc 	st  %i2, [ %i3 + -4 ]                          
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
400084fc:	fa 26 80 00 	st  %i5, [ %i2 ]                               
  the_node->next        = before_node;                                
40008500:	c2 26 ff f8 	st  %g1, [ %i3 + -8 ]                          
  before_node->previous = the_node;                                   
40008504:	fa 20 60 04 	st  %i5, [ %g1 + 4 ]                           
        add_to_chain(free_chain, chunk);                              
        check_and_merge(free_chain, chunk_tree, chunk, pred);         
40008508:	90 10 00 1a 	mov  %i2, %o0                                  
4000850c:	92 10 00 1c 	mov  %i4, %o1                                  
40008510:	94 10 00 1d 	mov  %i5, %o2                                  
40008514:	96 06 7f f8 	add  %i1, -8, %o3                              
40008518:	7f ff ff 05 	call  4000812c <check_and_merge>               
4000851c:	b0 10 20 00 	clr  %i0                                       
40008520:	81 c7 e0 08 	ret                                            
40008524:	81 e8 00 00 	restore                                        
      sc = RTEMS_INVALID_ID;                                          
    }                                                                 
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
40008528:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000852c:	91 e8 20 04 	restore  %g0, 4, %o0                           <== NOT EXECUTED
                                                                      

400081c4 <rtems_rbheap_initialize>: uintptr_t area_size, uintptr_t alignment, rtems_rbheap_extend_descriptors extend_descriptors, void *handler_arg ) {
400081c4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  if (alignment > 0) {                                                
400081c8:	80 a6 e0 00 	cmp  %i3, 0                                    
400081cc:	12 80 00 04 	bne  400081dc <rtems_rbheap_initialize+0x18>   
400081d0:	82 10 20 0a 	mov  0xa, %g1                                  
  } else {                                                            
    sc = RTEMS_INVALID_NUMBER;                                        
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
400081d4:	81 c7 e0 08 	ret                                            
400081d8:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      
#include <stdlib.h>                                                   
                                                                      
static uintptr_t align_up(uintptr_t alignment, uintptr_t value)       
{                                                                     
  uintptr_t excess = value % alignment;                               
400081dc:	90 10 00 19 	mov  %i1, %o0                                  
400081e0:	92 10 00 1b 	mov  %i3, %o1                                  
400081e4:	40 00 2f ce 	call  4001411c <.urem>                         
400081e8:	b4 06 40 1a 	add  %i1, %i2, %i2                             
                                                                      
  if (excess > 0) {                                                   
400081ec:	80 a2 20 00 	cmp  %o0, 0                                    
400081f0:	32 80 00 09 	bne,a   40008214 <rtems_rbheap_initialize+0x50>
400081f4:	a0 06 40 1b 	add  %i1, %i3, %l0                             
400081f8:	82 10 20 01 	mov  1, %g1                                    
    uintptr_t begin = (uintptr_t) area_begin;                         
    uintptr_t end = begin + area_size;                                
    uintptr_t aligned_begin = align_up(alignment, begin);             
    uintptr_t aligned_end = align_down(alignment, end);               
                                                                      
    if (begin < end && begin <= aligned_begin && aligned_begin < aligned_end) {
400081fc:	80 88 60 ff 	btst  0xff, %g1                                
40008200:	12 80 00 0b 	bne  4000822c <rtems_rbheap_initialize+0x68>   <== ALWAYS TAKEN
40008204:	a0 10 00 19 	mov  %i1, %l0                                  
        insert_into_tree(chunk_tree, first);                          
      } else {                                                        
        sc = RTEMS_NO_MEMORY;                                         
      }                                                               
    } else {                                                          
      sc = RTEMS_INVALID_ADDRESS;                                     
40008208:	82 10 20 09 	mov  9, %g1                                    <== NOT EXECUTED
  } else {                                                            
    sc = RTEMS_INVALID_NUMBER;                                        
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
4000820c:	81 c7 e0 08 	ret                                            
40008210:	91 e8 00 01 	restore  %g0, %g1, %o0                         
static uintptr_t align_up(uintptr_t alignment, uintptr_t value)       
{                                                                     
  uintptr_t excess = value % alignment;                               
                                                                      
  if (excess > 0) {                                                   
    value += alignment - excess;                                      
40008214:	a0 24 00 08 	sub  %l0, %o0, %l0                             
40008218:	80 a4 00 19 	cmp  %l0, %i1                                  
4000821c:	82 60 3f ff 	subx  %g0, -1, %g1                             
    uintptr_t begin = (uintptr_t) area_begin;                         
    uintptr_t end = begin + area_size;                                
    uintptr_t aligned_begin = align_up(alignment, begin);             
    uintptr_t aligned_end = align_down(alignment, end);               
                                                                      
    if (begin < end && begin <= aligned_begin && aligned_begin < aligned_end) {
40008220:	80 88 60 ff 	btst  0xff, %g1                                
40008224:	02 bf ff fa 	be  4000820c <rtems_rbheap_initialize+0x48>    
40008228:	82 10 20 09 	mov  9, %g1                                    
4000822c:	80 a6 40 1a 	cmp  %i1, %i2                                  
40008230:	1a bf ff f7 	bcc  4000820c <rtems_rbheap_initialize+0x48>   
40008234:	82 10 20 09 	mov  9, %g1                                    
  return value;                                                       
}                                                                     
                                                                      
static uintptr_t align_down(uintptr_t alignment, uintptr_t value)     
{                                                                     
  uintptr_t excess = value % alignment;                               
40008238:	90 10 00 1a 	mov  %i2, %o0                                  
4000823c:	40 00 2f b8 	call  4001411c <.urem>                         
40008240:	92 10 00 1b 	mov  %i3, %o1                                  
                                                                      
  return value - excess;                                              
40008244:	b4 26 80 08 	sub  %i2, %o0, %i2                             
    uintptr_t begin = (uintptr_t) area_begin;                         
    uintptr_t end = begin + area_size;                                
    uintptr_t aligned_begin = align_up(alignment, begin);             
    uintptr_t aligned_end = align_down(alignment, end);               
                                                                      
    if (begin < end && begin <= aligned_begin && aligned_begin < aligned_end) {
40008248:	80 a4 00 1a 	cmp  %l0, %i2                                  
4000824c:	1a bf ff e2 	bcc  400081d4 <rtems_rbheap_initialize+0x10>   
40008250:	82 10 20 09 	mov  9, %g1                                    
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
40008254:	82 06 20 04 	add  %i0, 4, %g1                               
                                                                      
  head->next = tail;                                                  
40008258:	c2 26 00 00 	st  %g1, [ %i0 ]                               
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
4000825c:	82 06 20 0c 	add  %i0, 0xc, %g1                             
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
  tail->previous = head;                                              
40008260:	c2 26 20 14 	st  %g1, [ %i0 + 0x14 ]                        
  the_rbtree->permanent_null   = NULL;                                
  the_rbtree->root             = NULL;                                
  the_rbtree->first[0]         = NULL;                                
  the_rbtree->first[1]         = NULL;                                
  the_rbtree->compare_function = compare_function;                    
  the_rbtree->is_unique        = is_unique;                           
40008264:	82 10 20 01 	mov  1, %g1                                    
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
40008268:	84 06 20 10 	add  %i0, 0x10, %g2                            
4000826c:	c2 2e 20 2c 	stb  %g1, [ %i0 + 0x2c ]                       
{                                                                     
  the_rbtree->permanent_null   = NULL;                                
  the_rbtree->root             = NULL;                                
  the_rbtree->first[0]         = NULL;                                
  the_rbtree->first[1]         = NULL;                                
  the_rbtree->compare_function = compare_function;                    
40008270:	03 10 00 20 	sethi  %hi(0x40008000), %g1                    
40008274:	82 10 60 b4 	or  %g1, 0xb4, %g1	! 400080b4 <chunk_compare>  
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
40008278:	c0 26 20 04 	clr  [ %i0 + 4 ]                               
4000827c:	c2 26 20 28 	st  %g1, [ %i0 + 0x28 ]                        
  tail->previous = head;                                              
40008280:	f0 26 20 08 	st  %i0, [ %i0 + 8 ]                           
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
40008284:	c0 26 20 10 	clr  [ %i0 + 0x10 ]                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
40008288:	c4 26 20 0c 	st  %g2, [ %i0 + 0xc ]                         
    RBTree_Control          *the_rbtree,                              
    RBTree_Compare_function  compare_function,                        
    bool                     is_unique                                
    )                                                                 
{                                                                     
  the_rbtree->permanent_null   = NULL;                                
4000828c:	c0 26 20 18 	clr  [ %i0 + 0x18 ]                            
  the_rbtree->root             = NULL;                                
40008290:	c0 26 20 1c 	clr  [ %i0 + 0x1c ]                            
  the_rbtree->first[0]         = NULL;                                
40008294:	c0 26 20 20 	clr  [ %i0 + 0x20 ]                            
  the_rbtree->first[1]         = NULL;                                
40008298:	c0 26 20 24 	clr  [ %i0 + 0x24 ]                            
      rtems_rbheap_chunk *first = NULL;                               
                                                                      
      rtems_chain_initialize_empty(free_chain);                       
      rtems_chain_initialize_empty(&control->spare_descriptor_chain); 
      rtems_rbtree_initialize_empty(chunk_tree, chunk_compare, true); 
      control->alignment = alignment;                                 
4000829c:	f6 26 20 30 	st  %i3, [ %i0 + 0x30 ]                        
      control->handler_arg = handler_arg;                             
400082a0:	fa 26 20 38 	st  %i5, [ %i0 + 0x38 ]                        
      control->extend_descriptors = extend_descriptors;               
400082a4:	f8 26 20 34 	st  %i4, [ %i0 + 0x34 ]                        
                                                                      
      first = get_chunk(control);                                     
400082a8:	7f ff ff 87 	call  400080c4 <get_chunk>                     
400082ac:	90 10 00 18 	mov  %i0, %o0                                  
        first->begin = aligned_begin;                                 
        first->size = aligned_end - aligned_begin;                    
        add_to_chain(free_chain, first);                              
        insert_into_tree(chunk_tree, first);                          
      } else {                                                        
        sc = RTEMS_NO_MEMORY;                                         
400082b0:	82 10 20 1a 	mov  0x1a, %g1                                 
      control->alignment = alignment;                                 
      control->handler_arg = handler_arg;                             
      control->extend_descriptors = extend_descriptors;               
                                                                      
      first = get_chunk(control);                                     
      if (first != NULL) {                                            
400082b4:	80 a2 20 00 	cmp  %o0, 0                                    
400082b8:	02 bf ff c7 	be  400081d4 <rtems_rbheap_initialize+0x10>    
400082bc:	92 10 00 08 	mov  %o0, %o1                                  
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
400082c0:	c2 06 00 00 	ld  [ %i0 ], %g1                               
        first->begin = aligned_begin;                                 
        first->size = aligned_end - aligned_begin;                    
400082c4:	b4 26 80 10 	sub  %i2, %l0, %i2                             
      control->handler_arg = handler_arg;                             
      control->extend_descriptors = extend_descriptors;               
                                                                      
      first = get_chunk(control);                                     
      if (first != NULL) {                                            
        first->begin = aligned_begin;                                 
400082c8:	e0 22 20 18 	st  %l0, [ %o0 + 0x18 ]                        
        first->size = aligned_end - aligned_begin;                    
400082cc:	f4 22 20 1c 	st  %i2, [ %o0 + 0x1c ]                        
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
400082d0:	f0 22 20 04 	st  %i0, [ %o0 + 4 ]                           
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
400082d4:	d0 26 00 00 	st  %o0, [ %i0 ]                               
  the_node->next        = before_node;                                
400082d8:	c2 22 00 00 	st  %g1, [ %o0 ]                               
  before_node->previous = the_node;                                   
400082dc:	d0 20 60 04 	st  %o0, [ %g1 + 4 ]                           
static void insert_into_tree(                                         
  rtems_rbtree_control *tree,                                         
  rtems_rbheap_chunk *chunk                                           
)                                                                     
{                                                                     
  _RBTree_Insert_unprotected(tree, &chunk->tree_node);                
400082e0:	92 02 60 08 	add  %o1, 8, %o1                               
400082e4:	40 00 07 3c 	call  40009fd4 <_RBTree_Insert_unprotected>    
400082e8:	90 06 20 18 	add  %i0, 0x18, %o0                            
  uintptr_t alignment,                                                
  rtems_rbheap_extend_descriptors extend_descriptors,                 
  void *handler_arg                                                   
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
400082ec:	10 bf ff ba 	b  400081d4 <rtems_rbheap_initialize+0x10>     
400082f0:	82 10 20 00 	clr  %g1                                       
                                                                      

4001b0e0 <rtems_rfs_bitmap_create_search>: int rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control) {
4001b0e0:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_rfs_bitmap_map map;                                           
  size_t               size;                                          
  rtems_rfs_bitmap_bit bit;                                           
  int                  rc;                                            
                                                                      
  rc = rtems_rfs_bitmap_load_map (control, &map);                     
4001b0e4:	90 10 00 18 	mov  %i0, %o0                                  
  return 0;                                                           
}                                                                     
                                                                      
int                                                                   
rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control)    
{                                                                     
4001b0e8:	ba 10 00 18 	mov  %i0, %i5                                  
  rtems_rfs_bitmap_map map;                                           
  size_t               size;                                          
  rtems_rfs_bitmap_bit bit;                                           
  int                  rc;                                            
                                                                      
  rc = rtems_rfs_bitmap_load_map (control, &map);                     
4001b0ec:	7f ff fe 32 	call  4001a9b4 <rtems_rfs_bitmap_load_map>     
4001b0f0:	92 07 bf fc 	add  %fp, -4, %o1                              
  if (rc > 0)                                                         
4001b0f4:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001b0f8:	24 80 00 04 	ble,a   4001b108 <rtems_rfs_bitmap_create_search+0x28>
4001b0fc:	de 07 60 14 	ld  [ %i5 + 0x14 ], %o7                        
      bit++;                                                          
    map++;                                                            
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
4001b100:	81 c7 e0 08 	ret                                            
4001b104:	81 e8 00 00 	restore                                        
  if (rc > 0)                                                         
    return rc;                                                        
                                                                      
  control->free = 0;                                                  
  search_map = control->search_bits;                                  
  size = control->size;                                               
4001b108:	f8 07 60 0c 	ld  [ %i5 + 0xc ], %i4                         
                                                                      
  rc = rtems_rfs_bitmap_load_map (control, &map);                     
  if (rc > 0)                                                         
    return rc;                                                        
                                                                      
  control->free = 0;                                                  
4001b10c:	c0 27 60 10 	clr  [ %i5 + 0x10 ]                            
  search_map = control->search_bits;                                  
  size = control->size;                                               
  bit = 0;                                                            
                                                                      
  *search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;                       
4001b110:	82 10 3f ff 	mov  -1, %g1                                   
4001b114:	c2 23 c0 00 	st  %g1, [ %o7 ]                               
4001b118:	f4 07 bf fc 	ld  [ %fp + -4 ], %i2                          
    return rc;                                                        
                                                                      
  control->free = 0;                                                  
  search_map = control->search_bits;                                  
  size = control->size;                                               
  bit = 0;                                                            
4001b11c:	b2 10 20 00 	clr  %i1                                       
                                                                      
rtems_rfs_bitmap_element                                              
rtems_rfs_bitmap_mask (unsigned int size)                             
{                                                                     
  rtems_rfs_bitmap_element mask = RTEMS_RFS_BITMAP_ELEMENT_FULL_MASK; 
  mask >>= (rtems_rfs_bitmap_element_bits () - size);                 
4001b120:	98 10 20 20 	mov  0x20, %o4                                 
4001b124:	9a 10 3f ff 	mov  -1, %o5                                   
  search_map = control->search_bits;                                  
  size = control->size;                                               
  bit = 0;                                                            
                                                                      
  *search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;                       
  while (size)                                                        
4001b128:	80 a7 20 00 	cmp  %i4, 0                                    
4001b12c:	02 80 00 20 	be  4001b1ac <rtems_rfs_bitmap_create_search+0xcc><== NEVER TAKEN
4001b130:	b6 10 20 01 	mov  1, %i3                                    
  {                                                                   
    rtems_rfs_bitmap_element bits;                                    
    int                      available;                               
    if (size < rtems_rfs_bitmap_element_bits ())                      
4001b134:	80 a7 20 1f 	cmp  %i4, 0x1f                                 
4001b138:	38 80 00 1f 	bgu,a   4001b1b4 <rtems_rfs_bitmap_create_search+0xd4>
4001b13c:	c6 06 80 00 	ld  [ %i2 ], %g3                               
{                                                                     
  /*                                                                  
   * Use the normal bit operators because we do not change the bits just merge
   * the 2 separate parts.                                            
   */                                                                 
  bits1 &= mask;                                                      
4001b140:	c2 06 80 00 	ld  [ %i2 ], %g1                               
                                                                      
rtems_rfs_bitmap_element                                              
rtems_rfs_bitmap_mask (unsigned int size)                             
{                                                                     
  rtems_rfs_bitmap_element mask = RTEMS_RFS_BITMAP_ELEMENT_FULL_MASK; 
  mask >>= (rtems_rfs_bitmap_element_bits () - size);                 
4001b144:	86 23 00 1c 	sub  %o4, %i4, %g3                             
    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;                                               
4001b148:	88 10 00 1c 	mov  %i4, %g4                                  
                                                                      
rtems_rfs_bitmap_element                                              
rtems_rfs_bitmap_mask (unsigned int size)                             
{                                                                     
  rtems_rfs_bitmap_element mask = RTEMS_RFS_BITMAP_ELEMENT_FULL_MASK; 
  mask >>= (rtems_rfs_bitmap_element_bits () - size);                 
4001b14c:	87 33 40 03 	srl  %o5, %g3, %g3                             
    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;                                               
4001b150:	b0 10 00 1c 	mov  %i4, %i0                                  
{                                                                     
  /*                                                                  
   * Use the normal bit operators because we do not change the bits just merge
   * the 2 separate parts.                                            
   */                                                                 
  bits1 &= mask;                                                      
4001b154:	86 08 c0 01 	and  %g3, %g1, %g3                             
    {                                                                 
      bits      = *map;                                               
      available = rtems_rfs_bitmap_element_bits ();                   
    }                                                                 
                                                                      
    if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET))  
4001b158:	80 a0 e0 00 	cmp  %g3, 0                                    
4001b15c:	02 80 00 0e 	be  4001b194 <rtems_rfs_bitmap_create_search+0xb4>
4001b160:	80 a6 60 20 	cmp  %i1, 0x20                                 
4001b164:	82 10 20 00 	clr  %g1                                       
 */                                                                   
static bool                                                           
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,               
                       rtems_rfs_bitmap_bit     bit)                  
{                                                                     
  return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);                     
4001b168:	85 2e c0 01 	sll  %i3, %g1, %g2                             
      rtems_rfs_bitmap_set (*search_map, bit);                        
    else                                                              
    {                                                                 
      int b;                                                          
      for (b = 0; b < available; b++)                                 
        if (!rtems_rfs_bitmap_test (bits, b))                         
4001b16c:	80 88 80 03 	btst  %g2, %g3                                 
4001b170:	02 80 00 05 	be  4001b184 <rtems_rfs_bitmap_create_search+0xa4>
4001b174:	82 00 60 01 	inc  %g1                                       
          control->free++;                                            
4001b178:	c4 07 60 10 	ld  [ %i5 + 0x10 ], %g2                        
4001b17c:	84 00 a0 01 	inc  %g2                                       
4001b180:	c4 27 60 10 	st  %g2, [ %i5 + 0x10 ]                        
    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++)                                 
4001b184:	80 a1 00 01 	cmp  %g4, %g1                                  
4001b188:	14 bf ff f9 	bg  4001b16c <rtems_rfs_bitmap_create_search+0x8c>
4001b18c:	85 2e c0 01 	sll  %i3, %g1, %g2                             
          control->free++;                                            
    }                                                                 
                                                                      
    size -= available;                                                
                                                                      
    if (bit == rtems_rfs_bitmap_element_bits ())                      
4001b190:	80 a6 60 20 	cmp  %i1, 0x20                                 
4001b194:	02 80 00 0b 	be  4001b1c0 <rtems_rfs_bitmap_create_search+0xe0>
4001b198:	b8 27 00 18 	sub  %i4, %i0, %i4                             
      bit = 0;                                                        
      search_map++;                                                   
      *search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;                   
    }                                                                 
    else                                                              
      bit++;                                                          
4001b19c:	b2 06 60 01 	inc  %i1                                       
  search_map = control->search_bits;                                  
  size = control->size;                                               
  bit = 0;                                                            
                                                                      
  *search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;                       
  while (size)                                                        
4001b1a0:	80 a7 20 00 	cmp  %i4, 0                                    
4001b1a4:	12 bf ff e4 	bne  4001b134 <rtems_rfs_bitmap_create_search+0x54>
4001b1a8:	b4 06 a0 04 	add  %i2, 4, %i2                               
    else                                                              
      bit++;                                                          
    map++;                                                            
  }                                                                   
                                                                      
  return 0;                                                           
4001b1ac:	81 c7 e0 08 	ret                                            
4001b1b0:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                     rtems_rfs_bitmap_mask_section (0, size));
      available = size;                                               
    }                                                                 
    else                                                              
    {                                                                 
      bits      = *map;                                               
4001b1b4:	b0 10 20 20 	mov  0x20, %i0                                 
      available = rtems_rfs_bitmap_element_bits ();                   
4001b1b8:	10 bf ff e8 	b  4001b158 <rtems_rfs_bitmap_create_search+0x78>
4001b1bc:	88 10 20 20 	mov  0x20, %g4                                 
                                                                      
    if (bit == rtems_rfs_bitmap_element_bits ())                      
    {                                                                 
      bit = 0;                                                        
      search_map++;                                                   
      *search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;                   
4001b1c0:	82 10 3f ff 	mov  -1, %g1                                   
                                                                      
    size -= available;                                                
                                                                      
    if (bit == rtems_rfs_bitmap_element_bits ())                      
    {                                                                 
      bit = 0;                                                        
4001b1c4:	b2 10 20 00 	clr  %i1                                       
      search_map++;                                                   
      *search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;                   
4001b1c8:	c2 23 e0 04 	st  %g1, [ %o7 + 4 ]                           
    size -= available;                                                
                                                                      
    if (bit == rtems_rfs_bitmap_element_bits ())                      
    {                                                                 
      bit = 0;                                                        
      search_map++;                                                   
4001b1cc:	10 bf ff f5 	b  4001b1a0 <rtems_rfs_bitmap_create_search+0xc0>
4001b1d0:	9e 03 e0 04 	add  %o7, 4, %o7                               
                                                                      

4001a9b4 <rtems_rfs_bitmap_load_map>: * @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) {
4001a9b4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rc;                                                             
                                                                      
  if (!control->buffer)                                               
4001a9b8:	c2 06 00 00 	ld  [ %i0 ], %g1                               
 * @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)             
{                                                                     
4001a9bc:	ba 10 00 18 	mov  %i0, %i5                                  
  int rc;                                                             
                                                                      
  if (!control->buffer)                                               
4001a9c0:	80 a0 60 00 	cmp  %g1, 0                                    
4001a9c4:	02 80 00 0f 	be  4001aa00 <rtems_rfs_bitmap_load_map+0x4c>  
4001a9c8:	b0 10 20 06 	mov  6, %i0                                    
    return ENXIO;                                                     
                                                                      
  *map = NULL;                                                        
4001a9cc:	c0 26 40 00 	clr  [ %i1 ]                                   
                                                                      
  rc = rtems_rfs_buffer_handle_request (control->fs,                  
4001a9d0:	d4 07 60 08 	ld  [ %i5 + 8 ], %o2                           
4001a9d4:	d0 07 60 04 	ld  [ %i5 + 4 ], %o0                           
4001a9d8:	d2 07 40 00 	ld  [ %i5 ], %o1                               
4001a9dc:	40 00 07 11 	call  4001c620 <rtems_rfs_buffer_handle_request>
4001a9e0:	96 10 20 01 	mov  1, %o3                                    
                                        control->buffer,              
                                        control->block,               
                                        true);                        
  if (rc)                                                             
4001a9e4:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001a9e8:	12 80 00 06 	bne  4001aa00 <rtems_rfs_bitmap_load_map+0x4c> <== NEVER TAKEN
4001a9ec:	01 00 00 00 	nop                                            
    return rc;                                                        
                                                                      
  *map = rtems_rfs_buffer_data (control->buffer);                     
4001a9f0:	c2 07 40 00 	ld  [ %i5 ], %g1                               
4001a9f4:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
4001a9f8:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        
4001a9fc:	c2 26 40 00 	st  %g1, [ %i1 ]                               
  return 0;                                                           
}                                                                     
4001aa00:	81 c7 e0 08 	ret                                            
4001aa04:	81 e8 00 00 	restore                                        
                                                                      

4001aff8 <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) {
4001aff8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int                  rc = 0;                                        
                                                                      
  /*                                                                  
   * By default we assume the allocation failed.                      
   */                                                                 
  *allocated = false;                                                 
4001affc:	c0 2e 80 00 	clrb  [ %i2 ]                                  
   * of bits from the original seed above then below. That is search from the
   * seed up then from the seed down a window number of bits, then repeat the
   * process from the window distance from the seed, again above then 
   * below. Keep moving out until all bits have been searched.        
   */                                                                 
  upper_seed = seed;                                                  
4001b000:	ba 10 00 19 	mov  %i1, %i5                                  
   * 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))          
4001b004:	80 a7 60 00 	cmp  %i5, 0                                    
4001b008:	06 80 00 1f 	bl  4001b084 <rtems_rfs_bitmap_map_alloc+0x8c> 
4001b00c:	80 a6 60 00 	cmp  %i1, 0                                    
4001b010:	c2 06 20 0c 	ld  [ %i0 + 0xc ], %g1                         
4001b014:	80 a7 40 01 	cmp  %i5, %g1                                  
4001b018:	1a 80 00 1b 	bcc  4001b084 <rtems_rfs_bitmap_map_alloc+0x8c>
4001b01c:	80 a6 60 00 	cmp  %i1, 0                                    
    /*                                                                
     * Search up first so bits allocated in succession are grouped together.
     */                                                               
    if (upper_seed < control->size)                                   
    {                                                                 
      *bit = upper_seed;                                              
4001b020:	fa 26 c0 00 	st  %i5, [ %i3 ]                               
      rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
4001b024:	90 10 00 18 	mov  %i0, %o0                                  
4001b028:	92 10 00 1b 	mov  %i3, %o1                                  
4001b02c:	94 10 00 1a 	mov  %i2, %o2                                  
4001b030:	7f ff fe 76 	call  4001aa08 <rtems_rfs_search_map_for_clear_bit.constprop.1>
4001b034:	96 10 20 01 	mov  1, %o3                                    
                                               window, 1);            
      if ((rc > 0) || *allocated)                                     
4001b038:	80 a2 20 00 	cmp  %o0, 0                                    
4001b03c:	14 80 00 27 	bg  4001b0d8 <rtems_rfs_bitmap_map_alloc+0xe0> <== NEVER TAKEN
4001b040:	01 00 00 00 	nop                                            
4001b044:	c2 0e 80 00 	ldub  [ %i2 ], %g1                             
4001b048:	80 a0 60 00 	cmp  %g1, 0                                    
4001b04c:	12 80 00 23 	bne  4001b0d8 <rtems_rfs_bitmap_map_alloc+0xe0>
4001b050:	80 a6 60 00 	cmp  %i1, 0                                    
        break;                                                        
    }                                                                 
                                                                      
    if (lower_seed >= 0)                                              
4001b054:	36 80 00 15 	bge,a   4001b0a8 <rtems_rfs_bitmap_map_alloc+0xb0>
4001b058:	f2 26 c0 00 	st  %i1, [ %i3 ]                               
                                                                      
    /*                                                                
     * 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)                                   
4001b05c:	c2 06 20 0c 	ld  [ %i0 + 0xc ], %g1                         
4001b060:	80 a0 40 1d 	cmp  %g1, %i5                                  
4001b064:	38 80 00 02 	bgu,a   4001b06c <rtems_rfs_bitmap_map_alloc+0x74>
4001b068:	ba 07 68 00 	add  %i5, 0x800, %i5                           
      upper_seed += window;                                           
    if (lower_seed >= 0)                                              
4001b06c:	80 a6 60 00 	cmp  %i1, 0                                    
4001b070:	06 bf ff e5 	bl  4001b004 <rtems_rfs_bitmap_map_alloc+0xc>  
4001b074:	80 a7 60 00 	cmp  %i5, 0                                    
   * 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))          
4001b078:	16 bf ff e6 	bge  4001b010 <rtems_rfs_bitmap_map_alloc+0x18><== ALWAYS TAKEN
4001b07c:	b2 06 78 00 	add  %i1, -2048, %i1                           
         || ((lower_seed >= 0) && (lower_seed < control->size)))      
4001b080:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
4001b084:	06 80 00 15 	bl  4001b0d8 <rtems_rfs_bitmap_map_alloc+0xe0> 
4001b088:	01 00 00 00 	nop                                            
4001b08c:	c2 06 20 0c 	ld  [ %i0 + 0xc ], %g1                         
4001b090:	80 a6 40 01 	cmp  %i1, %g1                                  
4001b094:	1a 80 00 11 	bcc  4001b0d8 <rtems_rfs_bitmap_map_alloc+0xe0>
4001b098:	80 a0 40 1d 	cmp  %g1, %i5                                  
  {                                                                   
    /*                                                                
     * Search up first so bits allocated in succession are grouped together.
     */                                                               
    if (upper_seed < control->size)                                   
4001b09c:	38 bf ff e2 	bgu,a   4001b024 <rtems_rfs_bitmap_map_alloc+0x2c><== NEVER TAKEN
4001b0a0:	fa 26 c0 00 	st  %i5, [ %i3 ]                               <== NOT EXECUTED
        break;                                                        
    }                                                                 
                                                                      
    if (lower_seed >= 0)                                              
    {                                                                 
      *bit = lower_seed;                                              
4001b0a4:	f2 26 c0 00 	st  %i1, [ %i3 ]                               
      rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
4001b0a8:	90 10 00 18 	mov  %i0, %o0                                  
4001b0ac:	92 10 00 1b 	mov  %i3, %o1                                  
4001b0b0:	94 10 00 1a 	mov  %i2, %o2                                  
4001b0b4:	7f ff fe 55 	call  4001aa08 <rtems_rfs_search_map_for_clear_bit.constprop.1>
4001b0b8:	96 10 3f ff 	mov  -1, %o3                                   
                                               window, -1);           
      if ((rc > 0) || *allocated)                                     
4001b0bc:	80 a2 20 00 	cmp  %o0, 0                                    
4001b0c0:	14 80 00 06 	bg  4001b0d8 <rtems_rfs_bitmap_map_alloc+0xe0> <== NEVER TAKEN
4001b0c4:	01 00 00 00 	nop                                            
4001b0c8:	c2 0e 80 00 	ldub  [ %i2 ], %g1                             
4001b0cc:	80 a0 60 00 	cmp  %g1, 0                                    
4001b0d0:	22 bf ff e4 	be,a   4001b060 <rtems_rfs_bitmap_map_alloc+0x68>
4001b0d4:	c2 06 20 0c 	ld  [ %i0 + 0xc ], %g1                         
    if (lower_seed >= 0)                                              
      lower_seed -= window;                                           
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
4001b0d8:	81 c7 e0 08 	ret                                            
4001b0dc:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

4001ace0 <rtems_rfs_bitmap_mask>: rtems_rfs_bitmap_element rtems_rfs_bitmap_mask (unsigned int size) { rtems_rfs_bitmap_element mask = RTEMS_RFS_BITMAP_ELEMENT_FULL_MASK; mask >>= (rtems_rfs_bitmap_element_bits () - size);
4001ace0:	82 10 3f ff 	mov  -1, %g1                                   <== NOT EXECUTED
4001ace4:	90 20 00 08 	neg  %o0                                       <== NOT EXECUTED
  return mask;                                                        
}                                                                     
4001ace8:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
4001acec:	91 30 40 08 	srl  %g1, %o0, %o0                             <== NOT EXECUTED
                                                                      

4001acf0 <rtems_rfs_bitmap_mask_section>: rtems_rfs_bitmap_element rtems_rfs_bitmap_mask_section (unsigned int start, unsigned int end) {
4001acf0:	82 10 00 08 	mov  %o0, %g1                                  <== NOT EXECUTED
  rtems_rfs_bitmap_element mask = 0;                                  
  if (end > start)                                                    
4001acf4:	80 a2 40 01 	cmp  %o1, %g1                                  <== NOT EXECUTED
4001acf8:	08 80 00 06 	bleu  4001ad10 <rtems_rfs_bitmap_mask_section+0x20><== NOT EXECUTED
4001acfc:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
                                                                      
rtems_rfs_bitmap_element                                              
rtems_rfs_bitmap_mask (unsigned int size)                             
{                                                                     
  rtems_rfs_bitmap_element mask = RTEMS_RFS_BITMAP_ELEMENT_FULL_MASK; 
  mask >>= (rtems_rfs_bitmap_element_bits () - size);                 
4001ad00:	92 20 40 09 	sub  %g1, %o1, %o1                             <== NOT EXECUTED
4001ad04:	90 10 3f ff 	mov  -1, %o0                                   <== NOT EXECUTED
4001ad08:	91 32 00 09 	srl  %o0, %o1, %o0                             <== 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)                                                    
    mask = rtems_rfs_bitmap_mask (end - start) << start;              
4001ad0c:	91 2a 00 01 	sll  %o0, %g1, %o0                             <== NOT EXECUTED
  return mask;                                                        
}                                                                     
4001ad10:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
                                                                      

4001b430 <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) {
4001b430:	9d e3 bf a0 	save  %sp, -96, %sp                            
                                                                      
  /*                                                                  
   * 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);     
4001b434:	96 10 20 01 	mov  1, %o3                                    
4001b438:	90 10 00 18 	mov  %i0, %o0                                  
4001b43c:	92 10 00 19 	mov  %i1, %o1                                  
4001b440:	40 00 04 78 	call  4001c620 <rtems_rfs_buffer_handle_request>
4001b444:	94 10 00 1a 	mov  %i2, %o2                                  
  if (rc > 0)                                                         
4001b448:	80 a2 20 00 	cmp  %o0, 0                                    
4001b44c:	24 80 00 04 	ble,a   4001b45c <rtems_rfs_block_find_indirect+0x2c><== ALWAYS TAKEN
4001b450:	c4 06 60 08 	ld  [ %i1 + 8 ], %g2                           
    *result = 0;                                                      
    rc = EIO;                                                         
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
4001b454:	81 c7 e0 08 	ret                                            
4001b458:	91 e8 00 08 	restore  %g0, %o0, %o0                         
   */                                                                 
  rc = rtems_rfs_buffer_handle_request (fs, buffer, block, true);     
  if (rc > 0)                                                         
    return rc;                                                        
                                                                      
  *result = rtems_rfs_block_get_number (buffer, offset);              
4001b45c:	83 2e e0 02 	sll  %i3, 2, %g1                               
4001b460:	c6 00 a0 1c 	ld  [ %g2 + 0x1c ], %g3                        
  if ((*result + 1) == 0)                                             
    *result = 0;                                                      
                                                                      
  if (*result >= rtems_rfs_fs_blocks (fs))                            
4001b464:	c8 06 20 04 	ld  [ %i0 + 4 ], %g4                           
   */                                                                 
  rc = rtems_rfs_buffer_handle_request (fs, buffer, block, true);     
  if (rc > 0)                                                         
    return rc;                                                        
                                                                      
  *result = rtems_rfs_block_get_number (buffer, offset);              
4001b468:	fa 08 c0 01 	ldub  [ %g3 + %g1 ], %i5                       
4001b46c:	84 00 c0 01 	add  %g3, %g1, %g2                             
4001b470:	c2 08 a0 03 	ldub  [ %g2 + 3 ], %g1                         
4001b474:	c6 08 a0 01 	ldub  [ %g2 + 1 ], %g3                         
4001b478:	c4 08 a0 02 	ldub  [ %g2 + 2 ], %g2                         
4001b47c:	bb 2f 60 18 	sll  %i5, 0x18, %i5                            
4001b480:	85 28 a0 08 	sll  %g2, 8, %g2                               
4001b484:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
4001b488:	82 10 40 1d 	or  %g1, %i5, %g1                              
4001b48c:	82 10 40 03 	or  %g1, %g3, %g1                              
4001b490:	82 10 40 02 	or  %g1, %g2, %g1                              
  if ((*result + 1) == 0)                                             
    *result = 0;                                                      
4001b494:	84 38 00 01 	xnor  %g0, %g1, %g2                            
4001b498:	80 a0 00 02 	cmp  %g0, %g2                                  
4001b49c:	84 60 20 00 	subx  %g0, 0, %g2                              
4001b4a0:	82 08 40 02 	and  %g1, %g2, %g1                             
4001b4a4:	c2 27 00 00 	st  %g1, [ %i4 ]                               
                                                                      
  if (*result >= rtems_rfs_fs_blocks (fs))                            
4001b4a8:	80 a1 00 01 	cmp  %g4, %g1                                  
4001b4ac:	18 bf ff ea 	bgu  4001b454 <rtems_rfs_block_find_indirect+0x24><== ALWAYS TAKEN
4001b4b0:	90 10 20 00 	clr  %o0                                       
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_FIND))                 
4001b4b4:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001b4b8:	7f ff e2 7b 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001b4bc:	13 00 00 04 	sethi  %hi(0x1000), %o1                        <== NOT EXECUTED
4001b4c0:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001b4c4:	32 80 00 06 	bne,a   4001b4dc <rtems_rfs_block_find_indirect+0xac><== NOT EXECUTED
4001b4c8:	d2 07 00 00 	ld  [ %i4 ], %o1                               <== NOT EXECUTED
      printf ("rtems-rfs: block-find: invalid block in table:"        
              " block=%" PRId32 ", indirect=%" PRId32 "/%d\n", *result, block, offset);
    *result = 0;                                                      
4001b4cc:	c0 27 00 00 	clr  [ %i4 ]                                   <== NOT EXECUTED
4001b4d0:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
    rc = EIO;                                                         
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
4001b4d4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001b4d8:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
    *result = 0;                                                      
                                                                      
  if (*result >= rtems_rfs_fs_blocks (fs))                            
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_FIND))                 
      printf ("rtems-rfs: block-find: invalid block in table:"        
4001b4dc:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
4001b4e0:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
4001b4e4:	96 10 00 1b 	mov  %i3, %o3                                  <== NOT EXECUTED
4001b4e8:	40 00 22 a5 	call  40023f7c <printf>                        <== NOT EXECUTED
4001b4ec:	90 12 20 38 	or  %o0, 0x38, %o0                             <== NOT EXECUTED
              " block=%" PRId32 ", indirect=%" PRId32 "/%d\n", *result, block, offset);
    *result = 0;                                                      
4001b4f0:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001b4f4:	10 bf ff f8 	b  4001b4d4 <rtems_rfs_block_find_indirect+0xa4><== NOT EXECUTED
4001b4f8:	c0 27 00 00 	clr  [ %i4 ]                                   <== NOT EXECUTED
                                                                      

4001b55c <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) {
4001b55c:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
  if (pos == 0)                                                       
4001b560:	80 96 40 1a 	orcc  %i1, %i2, %g0                            <== NOT EXECUTED
4001b564:	02 80 00 11 	be  4001b5a8 <rtems_rfs_block_get_block_size+0x4c><== NOT EXECUTED
4001b568:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
    rtems_rfs_block_set_size_zero (size);                             
  else                                                                
  {                                                                   
    size->count  = pos / rtems_rfs_fs_block_size (fs) + 1;            
4001b56c:	fa 06 20 08 	ld  [ %i0 + 8 ], %i5                           <== NOT EXECUTED
4001b570:	96 10 00 1d 	mov  %i5, %o3                                  <== NOT EXECUTED
4001b574:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
4001b578:	40 00 56 d4 	call  400310c8 <__udivdi3>                     <== NOT EXECUTED
4001b57c:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
4001b580:	92 02 60 01 	inc  %o1                                       <== NOT EXECUTED
    size->offset = pos % rtems_rfs_fs_block_size (fs);                
4001b584:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
{                                                                     
  if (pos == 0)                                                       
    rtems_rfs_block_set_size_zero (size);                             
  else                                                                
  {                                                                   
    size->count  = pos / rtems_rfs_fs_block_size (fs) + 1;            
4001b588:	d2 26 c0 00 	st  %o1, [ %i3 ]                               <== NOT EXECUTED
    size->offset = pos % rtems_rfs_fs_block_size (fs);                
4001b58c:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
4001b590:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
4001b594:	40 00 57 a1 	call  40031418 <__umoddi3>                     <== NOT EXECUTED
4001b598:	96 10 00 1d 	mov  %i5, %o3                                  <== NOT EXECUTED
4001b59c:	d2 26 e0 04 	st  %o1, [ %i3 + 4 ]                           <== NOT EXECUTED
4001b5a0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001b5a4:	81 e8 00 00 	restore                                        <== 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;                                                    
4001b5a8:	c0 26 c0 00 	clr  [ %i3 ]                                   <== NOT EXECUTED
  size->offset = 0;                                                   
4001b5ac:	c0 26 e0 04 	clr  [ %i3 + 4 ]                               <== NOT EXECUTED
4001b5b0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001b5b4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4001b794 <rtems_rfs_block_map_close>: int rtems_rfs_block_map_close (rtems_rfs_file_system* fs, rtems_rfs_block_map* map) {
4001b794:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rc = 0;                                                         
  int brc;                                                            
                                                                      
  if (map->dirty && map->inode)                                       
4001b798:	c2 0e 40 00 	ldub  [ %i1 ], %g1                             
}                                                                     
                                                                      
int                                                                   
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,                 
                           rtems_rfs_block_map*   map)                
{                                                                     
4001b79c:	ba 10 00 18 	mov  %i0, %i5                                  
  int rc = 0;                                                         
  int brc;                                                            
                                                                      
  if (map->dirty && map->inode)                                       
4001b7a0:	80 a0 60 00 	cmp  %g1, 0                                    
4001b7a4:	02 80 00 0b 	be  4001b7d0 <rtems_rfs_block_map_close+0x3c>  
4001b7a8:	b0 10 20 00 	clr  %i0                                       
4001b7ac:	d2 06 60 04 	ld  [ %i1 + 4 ], %o1                           
4001b7b0:	80 a2 60 00 	cmp  %o1, 0                                    
4001b7b4:	22 80 00 08 	be,a   4001b7d4 <rtems_rfs_block_map_close+0x40><== NEVER TAKEN
4001b7b8:	92 06 60 38 	add  %i1, 0x38, %o1                            <== NOT EXECUTED
  {                                                                   
    brc = rtems_rfs_inode_load (fs, map->inode);                      
4001b7bc:	7f ff da e6 	call  40012354 <rtems_rfs_inode_load>          
4001b7c0:	90 10 00 1d 	mov  %i5, %o0                                  
    if (brc > 0)                                                      
4001b7c4:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001b7c8:	04 80 00 11 	ble  4001b80c <rtems_rfs_block_map_close+0x78> <== ALWAYS TAKEN
4001b7cc:	b8 10 00 19 	mov  %i1, %i4                                  
 */                                                                   
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);                       
4001b7d0:	92 06 60 38 	add  %i1, 0x38, %o1                            
                                                                      
      map->dirty = false;                                             
    }                                                                 
  }                                                                   
                                                                      
  map->inode = NULL;                                                  
4001b7d4:	c0 26 60 04 	clr  [ %i1 + 4 ]                               
4001b7d8:	40 00 03 18 	call  4001c438 <rtems_rfs_buffer_handle_release>
4001b7dc:	90 10 00 1d 	mov  %i5, %o0                                  
4001b7e0:	90 10 00 1d 	mov  %i5, %o0                                  
  handle->dirty = false;                                              
4001b7e4:	c0 2e 60 38 	clrb  [ %i1 + 0x38 ]                           
  handle->bnum  = 0;                                                  
4001b7e8:	c0 26 60 3c 	clr  [ %i1 + 0x3c ]                            
  handle->buffer = NULL;                                              
4001b7ec:	c0 26 60 40 	clr  [ %i1 + 0x40 ]                            
 */                                                                   
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);                       
4001b7f0:	40 00 03 12 	call  4001c438 <rtems_rfs_buffer_handle_release>
4001b7f4:	92 06 60 44 	add  %i1, 0x44, %o1                            
  handle->dirty = false;                                              
4001b7f8:	c0 2e 60 44 	clrb  [ %i1 + 0x44 ]                           
  handle->bnum  = 0;                                                  
4001b7fc:	c0 26 60 48 	clr  [ %i1 + 0x48 ]                            
  handle->buffer = NULL;                                              
4001b800:	c0 26 60 4c 	clr  [ %i1 + 0x4c ]                            
    rc = brc;                                                         
  brc = rtems_rfs_buffer_handle_close (fs, &map->doubly_buffer);      
  if ((brc > 0) && (rc == 0))                                         
    rc = brc;                                                         
  return rc;                                                          
}                                                                     
4001b804:	81 c7 e0 08 	ret                                            
4001b808:	81 e8 00 00 	restore                                        
  int brc;                                                            
                                                                      
  if (map->dirty && map->inode)                                       
  {                                                                   
    brc = rtems_rfs_inode_load (fs, map->inode);                      
    if (brc > 0)                                                      
4001b80c:	88 10 20 00 	clr  %g4                                       
 */                                                                   
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);                      
4001b810:	b0 10 20 01 	mov  1, %i0                                    
    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]);    
4001b814:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
4001b818:	c4 07 20 24 	ld  [ %i4 + 0x24 ], %g2                        
 * @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);       
4001b81c:	f6 00 60 0c 	ld  [ %g1 + 0xc ], %i3                         
4001b820:	86 01 20 06 	add  %g4, 6, %g3                               
4001b824:	87 28 e0 02 	sll  %g3, 2, %g3                               
4001b828:	b6 06 c0 03 	add  %i3, %g3, %i3                             
4001b82c:	b5 30 a0 18 	srl  %g2, 0x18, %i2                            
4001b830:	f4 2e e0 04 	stb  %i2, [ %i3 + 4 ]                          
4001b834:	f6 00 60 0c 	ld  [ %g1 + 0xc ], %i3                         
4001b838:	b5 30 a0 10 	srl  %g2, 0x10, %i2                            
4001b83c:	b6 06 c0 03 	add  %i3, %g3, %i3                             
4001b840:	f4 2e e0 05 	stb  %i2, [ %i3 + 5 ]                          
4001b844:	f6 00 60 0c 	ld  [ %g1 + 0xc ], %i3                         
4001b848:	b5 30 a0 08 	srl  %g2, 8, %i2                               
4001b84c:	b6 06 c0 03 	add  %i3, %g3, %i3                             
4001b850:	f4 2e e0 06 	stb  %i2, [ %i3 + 6 ]                          
4001b854:	f6 00 60 0c 	ld  [ %g1 + 0xc ], %i3                         
                                                                      
    if (rc == 0)                                                      
    {                                                                 
      int b;                                                          
                                                                      
      for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)                    
4001b858:	88 01 20 01 	inc  %g4                                       
4001b85c:	86 06 c0 03 	add  %i3, %g3, %g3                             
4001b860:	c4 28 e0 07 	stb  %g2, [ %g3 + 7 ]                          
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
4001b864:	f0 28 60 10 	stb  %i0, [ %g1 + 0x10 ]                       
4001b868:	b8 07 20 04 	add  %i4, 4, %i4                               
4001b86c:	80 a1 20 05 	cmp  %g4, 5                                    
4001b870:	12 bf ff e9 	bne  4001b814 <rtems_rfs_block_map_close+0x80> 
4001b874:	82 10 20 01 	mov  1, %g1                                    
        rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);    
      rtems_rfs_inode_set_block_count (map->inode, map->size.count);  
4001b878:	c4 06 60 04 	ld  [ %i1 + 4 ], %g2                           
4001b87c:	c6 06 60 08 	ld  [ %i1 + 8 ], %g3                           
 * @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);      
4001b880:	c8 00 a0 0c 	ld  [ %g2 + 0xc ], %g4                         
4001b884:	b9 30 e0 18 	srl  %g3, 0x18, %i4                            
4001b888:	f8 29 20 0c 	stb  %i4, [ %g4 + 0xc ]                        
4001b88c:	c8 00 a0 0c 	ld  [ %g2 + 0xc ], %g4                         
4001b890:	b9 30 e0 10 	srl  %g3, 0x10, %i4                            
4001b894:	f8 29 20 0d 	stb  %i4, [ %g4 + 0xd ]                        
4001b898:	c8 00 a0 0c 	ld  [ %g2 + 0xc ], %g4                         
4001b89c:	b9 30 e0 08 	srl  %g3, 8, %i4                               
4001b8a0:	f8 29 20 0e 	stb  %i4, [ %g4 + 0xe ]                        
4001b8a4:	c8 00 a0 0c 	ld  [ %g2 + 0xc ], %g4                         
      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);            
4001b8a8:	90 10 00 1d 	mov  %i5, %o0                                  
4001b8ac:	c6 29 20 0f 	stb  %g3, [ %g4 + 0xf ]                        
      int b;                                                          
                                                                      
      for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)                    
        rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);    
      rtems_rfs_inode_set_block_count (map->inode, map->size.count);  
      rtems_rfs_inode_set_block_offset (map->inode, map->size.offset);
4001b8b0:	c8 06 60 04 	ld  [ %i1 + 4 ], %g4                           
 */                                                                   
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);    
4001b8b4:	f6 0e 60 0e 	ldub  [ %i1 + 0xe ], %i3                       
4001b8b8:	f8 01 20 0c 	ld  [ %g4 + 0xc ], %i4                         
 */                                                                   
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);                      
4001b8bc:	c2 28 a0 10 	stb  %g1, [ %g2 + 0x10 ]                       
 */                                                                   
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);    
4001b8c0:	c6 06 60 0c 	ld  [ %i1 + 0xc ], %g3                         
4001b8c4:	f6 2f 20 0a 	stb  %i3, [ %i4 + 0xa ]                        
4001b8c8:	c4 01 20 0c 	ld  [ %g4 + 0xc ], %g2                         
      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);            
4001b8cc:	94 10 20 01 	mov  1, %o2                                    
4001b8d0:	c6 28 a0 0b 	stb  %g3, [ %g2 + 0xb ]                        
                                                                      
      for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)                    
        rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);    
      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);
4001b8d4:	c6 06 60 04 	ld  [ %i1 + 4 ], %g3                           
4001b8d8:	c4 06 60 1c 	ld  [ %i1 + 0x1c ], %g2                        
 * @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);
4001b8dc:	f8 00 e0 0c 	ld  [ %g3 + 0xc ], %i4                         
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);                      
4001b8e0:	c2 29 20 10 	stb  %g1, [ %g4 + 0x10 ]                       
 * @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);
4001b8e4:	89 30 a0 18 	srl  %g2, 0x18, %g4                            
4001b8e8:	c8 2f 20 30 	stb  %g4, [ %i4 + 0x30 ]                       
4001b8ec:	c8 00 e0 0c 	ld  [ %g3 + 0xc ], %g4                         
4001b8f0:	b9 30 a0 10 	srl  %g2, 0x10, %i4                            
4001b8f4:	f8 29 20 31 	stb  %i4, [ %g4 + 0x31 ]                       
4001b8f8:	c8 00 e0 0c 	ld  [ %g3 + 0xc ], %g4                         
4001b8fc:	b9 30 a0 08 	srl  %g2, 8, %i4                               
4001b900:	f8 29 20 32 	stb  %i4, [ %g4 + 0x32 ]                       
4001b904:	c8 00 e0 0c 	ld  [ %g3 + 0xc ], %g4                         
4001b908:	c4 29 20 33 	stb  %g2, [ %g4 + 0x33 ]                       
      rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
4001b90c:	c4 06 60 04 	ld  [ %i1 + 4 ], %g2                           
4001b910:	c8 06 60 20 	ld  [ %i1 + 0x20 ], %g4                        
 * @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);
4001b914:	f8 00 a0 0c 	ld  [ %g2 + 0xc ], %i4                         
 */                                                                   
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);                      
4001b918:	c2 28 e0 10 	stb  %g1, [ %g3 + 0x10 ]                       
 * @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);
4001b91c:	87 31 20 18 	srl  %g4, 0x18, %g3                            
4001b920:	c6 2f 20 34 	stb  %g3, [ %i4 + 0x34 ]                       
4001b924:	c6 00 a0 0c 	ld  [ %g2 + 0xc ], %g3                         
4001b928:	b9 31 20 10 	srl  %g4, 0x10, %i4                            
4001b92c:	f8 28 e0 35 	stb  %i4, [ %g3 + 0x35 ]                       
4001b930:	c6 00 a0 0c 	ld  [ %g2 + 0xc ], %g3                         
4001b934:	b9 31 20 08 	srl  %g4, 8, %i4                               
4001b938:	f8 28 e0 36 	stb  %i4, [ %g3 + 0x36 ]                       
4001b93c:	c6 00 a0 0c 	ld  [ %g2 + 0xc ], %g3                         
4001b940:	c8 28 e0 37 	stb  %g4, [ %g3 + 0x37 ]                       
                                                                      
      brc = rtems_rfs_inode_unload (fs, map->inode, true);            
4001b944:	d2 06 60 04 	ld  [ %i1 + 4 ], %o1                           
4001b948:	7f ff da e7 	call  400124e4 <rtems_rfs_inode_unload>        
4001b94c:	c2 28 a0 10 	stb  %g1, [ %g2 + 0x10 ]                       
      if (brc > 0)                                                    
        rc = brc;                                                     
                                                                      
      map->dirty = false;                                             
4001b950:	c0 2e 40 00 	clrb  [ %i1 ]                                  
4001b954:	82 38 00 08 	xnor  %g0, %o0, %g1                            
4001b958:	83 38 60 1f 	sra  %g1, 0x1f, %g1                            
4001b95c:	10 bf ff 9d 	b  4001b7d0 <rtems_rfs_block_map_close+0x3c>   
4001b960:	b0 0a 00 01 	and  %o0, %g1, %i0                             
                                                                      

4001b964 <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) {
4001b964:	9d e3 bf 98 	save  %sp, -104, %sp                           
  int rc = 0;                                                         
                                                                      
  *block = 0;                                                         
4001b968:	c0 26 c0 00 	clr  [ %i3 ]                                   
                                                                      
  /*                                                                  
   * Range checking here makes the remaining logic simpler.           
   */                                                                 
  if (rtems_rfs_block_pos_block_past_end (bpos, &map->size))          
4001b96c:	fa 06 80 00 	ld  [ %i2 ], %i5                               
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)               
{                                                                     
4001b970:	a0 10 00 18 	mov  %i0, %l0                                  
  *block = 0;                                                         
                                                                      
  /*                                                                  
   * Range checking here makes the remaining logic simpler.           
   */                                                                 
  if (rtems_rfs_block_pos_block_past_end (bpos, &map->size))          
4001b974:	80 a7 60 00 	cmp  %i5, 0                                    
4001b978:	02 80 00 05 	be  4001b98c <rtems_rfs_block_map_find+0x28>   
4001b97c:	f8 06 60 08 	ld  [ %i1 + 8 ], %i4                           
4001b980:	80 a7 20 00 	cmp  %i4, 0                                    
4001b984:	02 80 00 4b 	be  4001bab0 <rtems_rfs_block_map_find+0x14c>  <== NEVER TAKEN
4001b988:	b0 10 20 06 	mov  6, %i0                                    
4001b98c:	80 a7 40 1c 	cmp  %i5, %i4                                  
4001b990:	1a 80 00 48 	bcc  4001bab0 <rtems_rfs_block_map_find+0x14c> 
4001b994:	b0 10 20 06 	mov  6, %i0                                    
    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))         
4001b998:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1                        
4001b99c:	80 a7 40 01 	cmp  %i5, %g1                                  
4001b9a0:	22 80 00 14 	be,a   4001b9f0 <rtems_rfs_block_map_find+0x8c>
4001b9a4:	c2 06 60 18 	ld  [ %i1 + 0x18 ], %g1                        
    /*                                                                
     * 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)                    
4001b9a8:	80 a7 20 05 	cmp  %i4, 5                                    
4001b9ac:	38 80 00 16 	bgu,a   4001ba04 <rtems_rfs_block_map_find+0xa0>
4001b9b0:	e2 04 20 34 	ld  [ %l0 + 0x34 ], %l1                        
    {                                                                 
      *block = map->blocks[bpos->bno];                                
4001b9b4:	ba 07 60 08 	add  %i5, 8, %i5                               
4001b9b8:	bb 2f 60 02 	sll  %i5, 2, %i5                               
4001b9bc:	ba 06 40 1d 	add  %i1, %i5, %i5                             
4001b9c0:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
4001b9c4:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
    }                                                                 
  }                                                                   
                                                                      
  if (rc == 0)                                                        
  {                                                                   
    rtems_rfs_block_copy_bpos (&map->bpos, bpos);                     
4001b9c8:	c6 06 a0 08 	ld  [ %i2 + 8 ], %g3                           
4001b9cc:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1                           
4001b9d0:	c4 06 80 00 	ld  [ %i2 ], %g2                               
4001b9d4:	c6 26 60 18 	st  %g3, [ %i1 + 0x18 ]                        
4001b9d8:	c4 26 60 10 	st  %g2, [ %i1 + 0x10 ]                        
4001b9dc:	c2 26 60 14 	st  %g1, [ %i1 + 0x14 ]                        
    map->bpos.block = *block;                                         
4001b9e0:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
4001b9e4:	c2 26 60 18 	st  %g1, [ %i1 + 0x18 ]                        
  }                                                                   
                                                                      
  return rc;                                                          
}                                                                     
4001b9e8:	81 c7 e0 08 	ret                                            
4001b9ec:	91 e8 20 00 	restore  %g0, 0, %o0                           
    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))         
4001b9f0:	80 a0 60 00 	cmp  %g1, 0                                    
4001b9f4:	02 bf ff ee 	be  4001b9ac <rtems_rfs_block_map_find+0x48>   
4001b9f8:	80 a7 20 05 	cmp  %i4, 5                                    
     * 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)                    
    {                                                                 
      *block = map->blocks[bpos->bno];                                
4001b9fc:	10 bf ff f3 	b  4001b9c8 <rtems_rfs_block_map_find+0x64>    
4001ba00:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
       * 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;                      
4001ba04:	90 10 00 1d 	mov  %i5, %o0                                  
4001ba08:	40 00 52 f3 	call  400305d4 <.urem>                         
4001ba0c:	92 10 00 11 	mov  %l1, %o1                                  
      singly = bpos->bno / fs->blocks_per_block;                      
4001ba10:	92 10 00 11 	mov  %l1, %o1                                  
       * 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;                      
4001ba14:	a6 10 00 08 	mov  %o0, %l3                                  
      singly = bpos->bno / fs->blocks_per_block;                      
4001ba18:	7f ff 9b 22 	call  400026a0 <.udiv>                         
4001ba1c:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
      if (map->size.count <= fs->block_map_singly_blocks)             
4001ba20:	c2 04 20 38 	ld  [ %l0 + 0x38 ], %g1                        
       */                                                             
      rtems_rfs_block_no direct;                                      
      rtems_rfs_block_no singly;                                      
                                                                      
      direct = bpos->bno % fs->blocks_per_block;                      
      singly = bpos->bno / fs->blocks_per_block;                      
4001ba24:	d0 27 bf fc 	st  %o0, [ %fp + -4 ]                          
                                                                      
      if (map->size.count <= fs->block_map_singly_blocks)             
4001ba28:	80 a0 40 1c 	cmp  %g1, %i4                                  
4001ba2c:	1a 80 00 23 	bcc  4001bab8 <rtems_rfs_block_map_find+0x154> <== ALWAYS TAKEN
4001ba30:	ba 10 00 08 	mov  %o0, %i5                                  
         * The map is doubly indirect.                                
         */                                                           
        rtems_rfs_block_no doubly;                                    
                                                                      
        doubly  = singly / fs->blocks_per_block;                      
        singly %= fs->blocks_per_block;                               
4001ba34:	40 00 52 e8 	call  400305d4 <.urem>                         <== NOT EXECUTED
4001ba38:	92 10 00 11 	mov  %l1, %o1                                  <== NOT EXECUTED
                                                                      
        if (map->size.count < fs->block_map_doubly_blocks)            
4001ba3c:	c2 04 20 3c 	ld  [ %l0 + 0x3c ], %g1                        <== NOT EXECUTED
         * The map is doubly indirect.                                
         */                                                           
        rtems_rfs_block_no doubly;                                    
                                                                      
        doubly  = singly / fs->blocks_per_block;                      
        singly %= fs->blocks_per_block;                               
4001ba40:	d0 27 bf fc 	st  %o0, [ %fp + -4 ]                          <== NOT EXECUTED
4001ba44:	a4 10 00 08 	mov  %o0, %l2                                  <== NOT EXECUTED
                                                                      
        if (map->size.count < fs->block_map_doubly_blocks)            
4001ba48:	80 a0 40 1c 	cmp  %g1, %i4                                  <== NOT EXECUTED
4001ba4c:	08 80 00 19 	bleu  4001bab0 <rtems_rfs_block_map_find+0x14c><== NOT EXECUTED
4001ba50:	b0 10 20 06 	mov  6, %i0                                    <== NOT EXECUTED
        /*                                                            
         * The map is doubly indirect.                                
         */                                                           
        rtems_rfs_block_no doubly;                                    
                                                                      
        doubly  = singly / fs->blocks_per_block;                      
4001ba54:	92 10 00 11 	mov  %l1, %o1                                  <== NOT EXECUTED
4001ba58:	7f ff 9b 12 	call  400026a0 <.udiv>                         <== NOT EXECUTED
4001ba5c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
        singly %= fs->blocks_per_block;                               
                                                                      
        if (map->size.count < fs->block_map_doubly_blocks)            
        {                                                             
          rc = rtems_rfs_block_find_indirect (fs,                     
4001ba60:	90 02 20 08 	add  %o0, 8, %o0                               <== NOT EXECUTED
4001ba64:	83 2a 20 02 	sll  %o0, 2, %g1                               <== NOT EXECUTED
4001ba68:	82 06 40 01 	add  %i1, %g1, %g1                             <== NOT EXECUTED
4001ba6c:	d4 00 60 04 	ld  [ %g1 + 4 ], %o2                           <== NOT EXECUTED
4001ba70:	92 06 60 44 	add  %i1, 0x44, %o1                            <== NOT EXECUTED
4001ba74:	90 10 00 10 	mov  %l0, %o0                                  <== NOT EXECUTED
4001ba78:	96 10 00 12 	mov  %l2, %o3                                  <== NOT EXECUTED
4001ba7c:	7f ff fe 6d 	call  4001b430 <rtems_rfs_block_find_indirect> <== NOT EXECUTED
4001ba80:	98 07 bf fc 	add  %fp, -4, %o4                              <== NOT EXECUTED
                                              &map->doubly_buffer,    
                                              map->blocks[doubly],    
                                              singly, &singly);       
          if (rc == 0)                                                
4001ba84:	b0 92 20 00 	orcc  %o0, 0, %i0                              <== NOT EXECUTED
4001ba88:	12 80 00 0a 	bne  4001bab0 <rtems_rfs_block_map_find+0x14c> <== NOT EXECUTED
4001ba8c:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          <== NOT EXECUTED
          {                                                           
            rc = rtems_rfs_block_find_indirect (fs,                   
4001ba90:	90 10 00 10 	mov  %l0, %o0                                  
4001ba94:	92 06 60 38 	add  %i1, 0x38, %o1                            
4001ba98:	96 10 00 13 	mov  %l3, %o3                                  
4001ba9c:	7f ff fe 65 	call  4001b430 <rtems_rfs_block_find_indirect> 
4001baa0:	98 10 00 1b 	mov  %i3, %o4                                  
        }                                                             
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if (rc == 0)                                                        
4001baa4:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001baa8:	22 bf ff c9 	be,a   4001b9cc <rtems_rfs_block_map_find+0x68><== ALWAYS TAKEN
4001baac:	c6 06 a0 08 	ld  [ %i2 + 8 ], %g3                           
    rtems_rfs_block_copy_bpos (&map->bpos, bpos);                     
    map->bpos.block = *block;                                         
  }                                                                   
                                                                      
  return rc;                                                          
}                                                                     
4001bab0:	81 c7 e0 08 	ret                                            
4001bab4:	81 e8 00 00 	restore                                        
      {                                                               
        /*                                                            
         * This is a single indirect table of blocks anchored off a slot in the
         * inode.                                                     
         */                                                           
        rc = rtems_rfs_block_find_indirect (fs,                       
4001bab8:	82 02 20 08 	add  %o0, 8, %g1                               
4001babc:	83 28 60 02 	sll  %g1, 2, %g1                               
4001bac0:	82 06 40 01 	add  %i1, %g1, %g1                             
4001bac4:	10 bf ff f3 	b  4001ba90 <rtems_rfs_block_map_find+0x12c>   
4001bac8:	d4 00 60 04 	ld  [ %g1 + 4 ], %o2                           
                                                                      

4001bb74 <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) {
4001bb74:	9d e3 bf 98 	save  %sp, -104, %sp                           
  int b;                                                              
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))               
4001bb78:	90 10 20 00 	clr  %o0                                       
4001bb7c:	7f ff e0 ca 	call  40013ea4 <rtems_rfs_trace>               
4001bb80:	13 00 00 08 	sethi  %hi(0x2000), %o1                        
4001bb84:	80 8a 20 ff 	btst  0xff, %o0                                
4001bb88:	32 80 00 cf 	bne,a   4001bec4 <rtems_rfs_block_map_grow+0x350><== NEVER TAKEN
4001bb8c:	d4 06 60 08 	ld  [ %i1 + 8 ], %o2                           <== NOT EXECUTED
    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))
4001bb90:	c4 06 60 08 	ld  [ %i1 + 8 ], %g2                           
4001bb94:	c2 06 20 3c 	ld  [ %i0 + 0x3c ], %g1                        
4001bb98:	84 06 80 02 	add  %i2, %g2, %g2                             
4001bb9c:	80 a0 80 01 	cmp  %g2, %g1                                  
4001bba0:	0a 80 00 04 	bcs  4001bbb0 <rtems_rfs_block_map_grow+0x3c>  <== ALWAYS TAKEN
4001bba4:	ba 10 20 1b 	mov  0x1b, %i5                                 
    map->last_data_block = block;                                     
    map->dirty = true;                                                
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
4001bba8:	81 c7 e0 08 	ret                                            
4001bbac:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
                                                                      
  /*                                                                  
   * 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++)                                        
4001bbb0:	80 a6 a0 00 	cmp  %i2, 0                                    
4001bbb4:	02 80 00 de 	be  4001bf2c <rtems_rfs_block_map_grow+0x3b8>  <== NEVER TAKEN
4001bbb8:	b8 10 20 00 	clr  %i4                                       
4001bbbc:	d2 06 60 20 	ld  [ %i1 + 0x20 ], %o1                        
            return rc;                                                
          }                                                           
        }                                                             
      }                                                               
                                                                      
      rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
4001bbc0:	a2 10 20 01 	mov  1, %l1                                    
                                      singly,                         
                                      singly_block);                  
        }                                                             
        else                                                          
        {                                                             
          rc = rtems_rfs_buffer_handle_request (fs,                   
4001bbc4:	a6 06 60 44 	add  %i1, 0x44, %l3                            
          }                                                           
                                                                      
          singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
                                                     singly);         
                                                                      
          rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001bbc8:	10 80 00 11 	b  4001bc0c <rtems_rfs_block_map_grow+0x98>    
4001bbcc:	a4 06 60 38 	add  %i1, 0x38, %l2                            
                                       false, &block);                
    if (rc > 0)                                                       
      return rc;                                                      
                                                                      
    if (map->size.count < RTEMS_RFS_INODE_BLOCKS)                     
      map->blocks[map->size.count] = block;                           
4001bbd0:	82 07 60 08 	add  %i5, 8, %g1                               
4001bbd4:	83 28 60 02 	sll  %g1, 2, %g1                               
4001bbd8:	82 06 40 01 	add  %i1, %g1, %g1                             
4001bbdc:	d2 20 60 04 	st  %o1, [ %g1 + 4 ]                           
      }                                                               
                                                                      
      rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
    }                                                                 
                                                                      
    map->size.count++;                                                
4001bbe0:	ba 07 60 01 	inc  %i5                                       
    map->size.offset = 0;                                             
4001bbe4:	c0 26 60 0c 	clr  [ %i1 + 0xc ]                             
                                                                      
    if (b == 0)                                                       
4001bbe8:	80 a7 20 00 	cmp  %i4, 0                                    
4001bbec:	12 80 00 03 	bne  4001bbf8 <rtems_rfs_block_map_grow+0x84>  <== NEVER TAKEN
4001bbf0:	fa 26 60 08 	st  %i5, [ %i1 + 8 ]                           
      *new_block = block;                                             
4001bbf4:	d2 26 c0 00 	st  %o1, [ %i3 ]                               
    map->last_data_block = block;                                     
    map->dirty = true;                                                
4001bbf8:	e2 2e 40 00 	stb  %l1, [ %i1 ]                              
                                                                      
  /*                                                                  
   * 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++)                                        
4001bbfc:	b8 07 20 01 	inc  %i4                                       
4001bc00:	80 a7 00 1a 	cmp  %i4, %i2                                  
4001bc04:	02 80 00 ca 	be  4001bf2c <rtems_rfs_block_map_grow+0x3b8>  <== ALWAYS TAKEN
4001bc08:	d2 26 60 20 	st  %o1, [ %i1 + 0x20 ]                        
    /*                                                                
     * 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,      
4001bc0c:	90 10 00 18 	mov  %i0, %o0                                  
4001bc10:	94 10 20 00 	clr  %o2                                       
4001bc14:	7f ff d8 80 	call  40011e14 <rtems_rfs_group_bitmap_alloc>  
4001bc18:	96 07 bf f8 	add  %fp, -8, %o3                              
                                       false, &block);                
    if (rc > 0)                                                       
4001bc1c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001bc20:	14 bf ff e2 	bg  4001bba8 <rtems_rfs_block_map_grow+0x34>   
4001bc24:	01 00 00 00 	nop                                            
      return rc;                                                      
                                                                      
    if (map->size.count < RTEMS_RFS_INODE_BLOCKS)                     
4001bc28:	fa 06 60 08 	ld  [ %i1 + 8 ], %i5                           
4001bc2c:	80 a7 60 04 	cmp  %i5, 4                                    
4001bc30:	08 bf ff e8 	bleu  4001bbd0 <rtems_rfs_block_map_grow+0x5c> 
4001bc34:	d2 07 bf f8 	ld  [ %fp + -8 ], %o1                          
       * 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;                
4001bc38:	e0 06 20 34 	ld  [ %i0 + 0x34 ], %l0                        
4001bc3c:	90 10 00 1d 	mov  %i5, %o0                                  
4001bc40:	40 00 52 65 	call  400305d4 <.urem>                         
4001bc44:	92 10 00 10 	mov  %l0, %o1                                  
      singly = map->size.count / fs->blocks_per_block;                
4001bc48:	92 10 00 10 	mov  %l0, %o1                                  
       * 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;                
4001bc4c:	a8 10 00 08 	mov  %o0, %l4                                  
      singly = map->size.count / fs->blocks_per_block;                
4001bc50:	7f ff 9a 94 	call  400026a0 <.udiv>                         
4001bc54:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
      if (map->size.count < fs->block_map_singly_blocks)              
4001bc58:	c2 06 20 38 	ld  [ %i0 + 0x38 ], %g1                        
4001bc5c:	80 a7 40 01 	cmp  %i5, %g1                                  
4001bc60:	1a 80 00 31 	bcc  4001bd24 <rtems_rfs_block_map_grow+0x1b0> <== NEVER TAKEN
4001bc64:	aa 10 00 08 	mov  %o0, %l5                                  
         * 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) ||                                          
4001bc68:	80 a5 20 00 	cmp  %l4, 0                                    
4001bc6c:	02 80 00 06 	be  4001bc84 <rtems_rfs_block_map_grow+0x110>  <== NEVER TAKEN
4001bc70:	80 a5 20 05 	cmp  %l4, 5                                    
4001bc74:	12 80 00 8a 	bne  4001be9c <rtems_rfs_block_map_grow+0x328> 
4001bc78:	80 a2 20 00 	cmp  %o0, 0                                    
4001bc7c:	12 80 00 89 	bne  4001bea0 <rtems_rfs_block_map_grow+0x32c> <== NEVER TAKEN
4001bc80:	82 05 60 08 	add  %l5, 8, %g1                               
        {                                                             
          /*                                                          
           * Upping is when we move from direct to singly indirect.   
           */                                                         
          bool upping;                                                
          upping = map->size.count == RTEMS_RFS_INODE_BLOCKS;         
4001bc84:	ba 1f 60 05 	xor  %i5, 5, %i5                               
          rc = rtems_rfs_block_map_indirect_alloc (fs, map,           
4001bc88:	80 a0 00 1d 	cmp  %g0, %i5                                  
                                                   &map->singly_buffer,
                                                   &map->blocks[singly],
4001bc8c:	96 05 60 08 	add  %l5, 8, %o3                               
          /*                                                          
           * 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,           
4001bc90:	90 10 00 18 	mov  %i0, %o0                                  
                                                   &map->singly_buffer,
                                                   &map->blocks[singly],
4001bc94:	97 2a e0 02 	sll  %o3, 2, %o3                               
          /*                                                          
           * 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,           
4001bc98:	92 10 00 19 	mov  %i1, %o1                                  
                                                   &map->singly_buffer,
                                                   &map->blocks[singly],
4001bc9c:	96 06 40 0b 	add  %i1, %o3, %o3                             
          /*                                                          
           * 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,           
4001bca0:	94 10 00 12 	mov  %l2, %o2                                  
4001bca4:	96 02 e0 04 	add  %o3, 4, %o3                               
4001bca8:	7f ff fd 8f 	call  4001b2e4 <rtems_rfs_block_map_indirect_alloc>
4001bcac:	98 60 3f ff 	subx  %g0, -1, %o4                             
4001bcb0:	ba 10 00 08 	mov  %o0, %i5                                  
          singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
                                                     singly);         
                                                                      
          rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
                                                singly_block, true);  
          if (rc > 0)                                                 
4001bcb4:	80 a7 60 00 	cmp  %i5, 0                                    
4001bcb8:	14 80 00 a1 	bg  4001bf3c <rtems_rfs_block_map_grow+0x3c8>  <== NEVER TAKEN
4001bcbc:	d4 07 bf f8 	ld  [ %fp + -8 ], %o2                          
            return rc;                                                
          }                                                           
        }                                                             
      }                                                               
                                                                      
      rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
4001bcc0:	c2 06 60 40 	ld  [ %i1 + 0x40 ], %g1                        
4001bcc4:	c4 0f bf f8 	ldub  [ %fp + -8 ], %g2                        
4001bcc8:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        
4001bccc:	91 2d 20 02 	sll  %l4, 2, %o0                               
4001bcd0:	c4 28 40 08 	stb  %g2, [ %g1 + %o0 ]                        
4001bcd4:	c2 06 60 40 	ld  [ %i1 + 0x40 ], %g1                        
4001bcd8:	c4 17 bf f8 	lduh  [ %fp + -8 ], %g2                        
4001bcdc:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        
4001bce0:	82 00 40 08 	add  %g1, %o0, %g1                             
4001bce4:	c4 28 60 01 	stb  %g2, [ %g1 + 1 ]                          
4001bce8:	c2 06 60 40 	ld  [ %i1 + 0x40 ], %g1                        
4001bcec:	c4 07 bf f8 	ld  [ %fp + -8 ], %g2                          
4001bcf0:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        
4001bcf4:	85 30 a0 08 	srl  %g2, 8, %g2                               
4001bcf8:	82 00 40 08 	add  %g1, %o0, %g1                             
4001bcfc:	c4 28 60 02 	stb  %g2, [ %g1 + 2 ]                          
4001bd00:	c2 06 60 40 	ld  [ %i1 + 0x40 ], %g1                        
4001bd04:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        
4001bd08:	90 00 40 08 	add  %g1, %o0, %o0                             
4001bd0c:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
4001bd10:	c2 2a 20 03 	stb  %g1, [ %o0 + 3 ]                          
4001bd14:	e2 2e 60 38 	stb  %l1, [ %i1 + 0x38 ]                       
4001bd18:	fa 06 60 08 	ld  [ %i1 + 8 ], %i5                           
4001bd1c:	10 bf ff b1 	b  4001bbe0 <rtems_rfs_block_map_grow+0x6c>    
4001bd20:	d2 07 bf f8 	ld  [ %fp + -8 ], %o1                          
         * Doubly indirect tables are being used.                     
         */                                                           
        rtems_rfs_block_no doubly;                                    
        rtems_rfs_block_no singly_block;                              
                                                                      
        doubly  = singly / fs->blocks_per_block;                      
4001bd24:	7f ff 9a 5f 	call  400026a0 <.udiv>                         <== NOT EXECUTED
4001bd28:	92 10 00 10 	mov  %l0, %o1                                  <== NOT EXECUTED
        singly %= fs->blocks_per_block;                               
4001bd2c:	92 10 00 10 	mov  %l0, %o1                                  <== 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;                      
4001bd30:	ac 10 00 08 	mov  %o0, %l6                                  <== NOT EXECUTED
        singly %= fs->blocks_per_block;                               
4001bd34:	40 00 52 28 	call  400305d4 <.urem>                         <== NOT EXECUTED
4001bd38:	90 10 00 15 	mov  %l5, %o0                                  <== 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)                                              
4001bd3c:	80 a5 20 00 	cmp  %l4, 0                                    <== NOT EXECUTED
4001bd40:	12 80 00 38 	bne  4001be20 <rtems_rfs_block_map_grow+0x2ac> <== NOT EXECUTED
4001bd44:	a0 10 00 08 	mov  %o0, %l0                                  <== NOT EXECUTED
        {                                                             
          rc = rtems_rfs_block_map_indirect_alloc (fs, map,           
4001bd48:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001bd4c:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
4001bd50:	94 10 00 12 	mov  %l2, %o2                                  <== NOT EXECUTED
4001bd54:	96 07 bf fc 	add  %fp, -4, %o3                              <== NOT EXECUTED
4001bd58:	7f ff fd 63 	call  4001b2e4 <rtems_rfs_block_map_indirect_alloc><== NOT EXECUTED
4001bd5c:	98 10 20 00 	clr  %o4                                       <== NOT EXECUTED
                                                   &map->singly_buffer,
                                                   &singly_block,     
                                                   false);            
          if (rc > 0)                                                 
4001bd60:	ba 92 20 00 	orcc  %o0, 0, %i5                              <== NOT EXECUTED
4001bd64:	14 80 00 75 	bg  4001bf38 <rtems_rfs_block_map_grow+0x3c4>  <== NOT EXECUTED
4001bd68:	80 a4 20 00 	cmp  %l0, 0                                    <== 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) ||                                        
4001bd6c:	02 80 00 06 	be  4001bd84 <rtems_rfs_block_map_grow+0x210>  <== NOT EXECUTED
4001bd70:	80 a4 20 05 	cmp  %l0, 5                                    <== NOT EXECUTED
4001bd74:	12 80 00 5a 	bne  4001bedc <rtems_rfs_block_map_grow+0x368> <== NOT EXECUTED
4001bd78:	80 a5 a0 00 	cmp  %l6, 0                                    <== NOT EXECUTED
4001bd7c:	12 80 00 59 	bne  4001bee0 <rtems_rfs_block_map_grow+0x36c> <== NOT EXECUTED
4001bd80:	82 05 a0 08 	add  %l6, 8, %g1                               <== NOT EXECUTED
              ((doubly == 0) && (singly == RTEMS_RFS_INODE_BLOCKS)))  
          {                                                           
            bool upping;                                              
            upping = map->size.count == fs->block_map_singly_blocks;  
4001bd84:	c4 06 60 08 	ld  [ %i1 + 8 ], %g2                           <== NOT EXECUTED
4001bd88:	c2 06 20 38 	ld  [ %i0 + 0x38 ], %g1                        <== NOT EXECUTED
            rc = rtems_rfs_block_map_indirect_alloc (fs, map,         
                                                     &map->doubly_buffer,
                                                     &map->blocks[doubly],
4001bd8c:	96 05 a0 08 	add  %l6, 8, %o3                               <== NOT EXECUTED
           */                                                         
          if ((singly == 0) ||                                        
              ((doubly == 0) && (singly == RTEMS_RFS_INODE_BLOCKS)))  
          {                                                           
            bool upping;                                              
            upping = map->size.count == fs->block_map_singly_blocks;  
4001bd90:	82 18 80 01 	xor  %g2, %g1, %g1                             <== NOT EXECUTED
            rc = rtems_rfs_block_map_indirect_alloc (fs, map,         
4001bd94:	80 a0 00 01 	cmp  %g0, %g1                                  <== NOT EXECUTED
                                                     &map->doubly_buffer,
                                                     &map->blocks[doubly],
4001bd98:	97 2a e0 02 	sll  %o3, 2, %o3                               <== NOT EXECUTED
          if ((singly == 0) ||                                        
              ((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,         
4001bd9c:	98 60 3f ff 	subx  %g0, -1, %o4                             <== NOT EXECUTED
                                                     &map->doubly_buffer,
                                                     &map->blocks[doubly],
4001bda0:	96 06 40 0b 	add  %i1, %o3, %o3                             <== NOT EXECUTED
          if ((singly == 0) ||                                        
              ((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,         
4001bda4:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001bda8:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
4001bdac:	94 10 00 13 	mov  %l3, %o2                                  <== NOT EXECUTED
4001bdb0:	7f ff fd 4d 	call  4001b2e4 <rtems_rfs_block_map_indirect_alloc><== NOT EXECUTED
4001bdb4:	96 02 e0 04 	add  %o3, 4, %o3                               <== NOT EXECUTED
                                                     &map->doubly_buffer,
                                                     &map->blocks[doubly],
                                                     upping);         
            if (rc > 0)                                               
4001bdb8:	ba 92 20 00 	orcc  %o0, 0, %i5                              <== NOT EXECUTED
4001bdbc:	14 80 00 54 	bg  4001bf0c <rtems_rfs_block_map_grow+0x398>  <== NOT EXECUTED
4001bdc0:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          <== NOT EXECUTED
              rtems_rfs_group_bitmap_free (fs, false, block);         
              return rc;                                              
            }                                                         
          }                                                           
                                                                      
          rtems_rfs_block_set_number (&map->doubly_buffer,            
4001bdc4:	c2 06 60 4c 	ld  [ %i1 + 0x4c ], %g1                        <== NOT EXECUTED
4001bdc8:	c4 0f bf fc 	ldub  [ %fp + -4 ], %g2                        <== NOT EXECUTED
4001bdcc:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        <== NOT EXECUTED
4001bdd0:	a1 2c 20 02 	sll  %l0, 2, %l0                               <== NOT EXECUTED
4001bdd4:	c4 28 40 10 	stb  %g2, [ %g1 + %l0 ]                        <== NOT EXECUTED
4001bdd8:	c2 06 60 4c 	ld  [ %i1 + 0x4c ], %g1                        <== NOT EXECUTED
4001bddc:	c4 17 bf fc 	lduh  [ %fp + -4 ], %g2                        <== NOT EXECUTED
4001bde0:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        <== NOT EXECUTED
4001bde4:	82 00 40 10 	add  %g1, %l0, %g1                             <== NOT EXECUTED
4001bde8:	c4 28 60 01 	stb  %g2, [ %g1 + 1 ]                          <== NOT EXECUTED
4001bdec:	c2 06 60 4c 	ld  [ %i1 + 0x4c ], %g1                        <== NOT EXECUTED
4001bdf0:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          <== NOT EXECUTED
4001bdf4:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        <== NOT EXECUTED
4001bdf8:	85 30 a0 08 	srl  %g2, 8, %g2                               <== NOT EXECUTED
4001bdfc:	82 00 40 10 	add  %g1, %l0, %g1                             <== NOT EXECUTED
4001be00:	c4 28 60 02 	stb  %g2, [ %g1 + 2 ]                          <== NOT EXECUTED
4001be04:	c2 06 60 4c 	ld  [ %i1 + 0x4c ], %g1                        <== NOT EXECUTED
4001be08:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        <== NOT EXECUTED
4001be0c:	a0 00 40 10 	add  %g1, %l0, %l0                             <== NOT EXECUTED
4001be10:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          <== NOT EXECUTED
4001be14:	c2 2c 20 03 	stb  %g1, [ %l0 + 3 ]                          <== NOT EXECUTED
4001be18:	10 bf ff aa 	b  4001bcc0 <rtems_rfs_block_map_grow+0x14c>   <== NOT EXECUTED
4001be1c:	e2 2e 60 44 	stb  %l1, [ %i1 + 0x44 ]                       <== NOT EXECUTED
                                      singly,                         
                                      singly_block);                  
        }                                                             
        else                                                          
        {                                                             
          rc = rtems_rfs_buffer_handle_request (fs,                   
4001be20:	ac 05 a0 08 	add  %l6, 8, %l6                               <== NOT EXECUTED
4001be24:	ad 2d a0 02 	sll  %l6, 2, %l6                               <== NOT EXECUTED
4001be28:	ac 06 40 16 	add  %i1, %l6, %l6                             <== NOT EXECUTED
4001be2c:	d4 05 a0 04 	ld  [ %l6 + 4 ], %o2                           <== NOT EXECUTED
4001be30:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001be34:	92 10 00 13 	mov  %l3, %o1                                  <== NOT EXECUTED
4001be38:	40 00 01 fa 	call  4001c620 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
4001be3c:	96 10 20 01 	mov  1, %o3                                    <== NOT EXECUTED
                                                &map->doubly_buffer,  
                                                map->blocks[doubly],  
                                                true);                
          if (rc > 0)                                                 
4001be40:	ba 92 20 00 	orcc  %o0, 0, %i5                              <== NOT EXECUTED
4001be44:	14 80 00 3d 	bg  4001bf38 <rtems_rfs_block_map_grow+0x3c4>  <== NOT EXECUTED
4001be48:	a1 2c 20 02 	sll  %l0, 2, %l0                               <== NOT EXECUTED
          {                                                           
            rtems_rfs_group_bitmap_free (fs, false, block);           
            return rc;                                                
          }                                                           
                                                                      
          singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
4001be4c:	c2 06 60 4c 	ld  [ %i1 + 0x4c ], %g1                        <== NOT EXECUTED
4001be50:	c4 00 60 1c 	ld  [ %g1 + 0x1c ], %g2                        <== NOT EXECUTED
                                                     singly);         
                                                                      
          rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001be54:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
          {                                                           
            rtems_rfs_group_bitmap_free (fs, false, block);           
            return rc;                                                
          }                                                           
                                                                      
          singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
4001be58:	c6 08 80 10 	ldub  [ %g2 + %l0 ], %g3                       <== NOT EXECUTED
4001be5c:	82 00 80 10 	add  %g2, %l0, %g1                             <== NOT EXECUTED
4001be60:	d4 08 60 03 	ldub  [ %g1 + 3 ], %o2                         <== NOT EXECUTED
4001be64:	c4 08 60 01 	ldub  [ %g1 + 1 ], %g2                         <== NOT EXECUTED
4001be68:	c2 08 60 02 	ldub  [ %g1 + 2 ], %g1                         <== NOT EXECUTED
4001be6c:	87 28 e0 18 	sll  %g3, 0x18, %g3                            <== NOT EXECUTED
4001be70:	85 28 a0 10 	sll  %g2, 0x10, %g2                            <== NOT EXECUTED
4001be74:	83 28 60 08 	sll  %g1, 8, %g1                               <== NOT EXECUTED
4001be78:	94 12 80 03 	or  %o2, %g3, %o2                              <== NOT EXECUTED
                                                     singly);         
                                                                      
          rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001be7c:	92 10 00 12 	mov  %l2, %o1                                  <== NOT EXECUTED
          {                                                           
            rtems_rfs_group_bitmap_free (fs, false, block);           
            return rc;                                                
          }                                                           
                                                                      
          singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
4001be80:	94 12 80 02 	or  %o2, %g2, %o2                              <== NOT EXECUTED
                                                     singly);         
                                                                      
          rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001be84:	96 10 20 01 	mov  1, %o3                                    <== NOT EXECUTED
          {                                                           
            rtems_rfs_group_bitmap_free (fs, false, block);           
            return rc;                                                
          }                                                           
                                                                      
          singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
4001be88:	94 12 80 01 	or  %o2, %g1, %o2                              <== NOT EXECUTED
                                                     singly);         
                                                                      
          rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001be8c:	40 00 01 e5 	call  4001c620 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
4001be90:	d4 27 bf fc 	st  %o2, [ %fp + -4 ]                          <== NOT EXECUTED
4001be94:	10 bf ff 88 	b  4001bcb4 <rtems_rfs_block_map_grow+0x140>   <== NOT EXECUTED
4001be98:	ba 10 00 08 	mov  %o0, %i5                                  <== NOT EXECUTED
                                                   &map->blocks[singly],
                                                   upping);           
        }                                                             
        else                                                          
        {                                                             
          rc = rtems_rfs_buffer_handle_request (fs,  &map->singly_buffer,
4001be9c:	82 05 60 08 	add  %l5, 8, %g1                               
4001bea0:	83 28 60 02 	sll  %g1, 2, %g1                               
4001bea4:	82 06 40 01 	add  %i1, %g1, %g1                             
4001bea8:	d4 00 60 04 	ld  [ %g1 + 4 ], %o2                           
4001beac:	90 10 00 18 	mov  %i0, %o0                                  
4001beb0:	92 10 00 12 	mov  %l2, %o1                                  
4001beb4:	40 00 01 db 	call  4001c620 <rtems_rfs_buffer_handle_request>
4001beb8:	96 10 20 01 	mov  1, %o3                                    
4001bebc:	10 bf ff 7e 	b  4001bcb4 <rtems_rfs_block_map_grow+0x140>   
4001bec0:	ba 10 00 08 	mov  %o0, %i5                                  
                          rtems_rfs_block_no*    new_block)           
{                                                                     
  int b;                                                              
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))               
    printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n",
4001bec4:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
4001bec8:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
4001becc:	40 00 20 2c 	call  40023f7c <printf>                        <== NOT EXECUTED
4001bed0:	90 12 20 88 	or  %o0, 0x88, %o0	! 40036c88 <CSWTCH.2+0x98>  <== NOT EXECUTED
            blocks, map->size.count);                                 
                                                                      
  if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
4001bed4:	10 bf ff 30 	b  4001bb94 <rtems_rfs_block_map_grow+0x20>    <== NOT EXECUTED
4001bed8:	c4 06 60 08 	ld  [ %i1 + 8 ], %g2                           <== NOT EXECUTED
              return rc;                                              
            }                                                         
          }                                                           
          else                                                        
          {                                                           
            rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
4001bedc:	82 05 a0 08 	add  %l6, 8, %g1                               <== NOT EXECUTED
4001bee0:	83 28 60 02 	sll  %g1, 2, %g1                               <== NOT EXECUTED
4001bee4:	82 06 40 01 	add  %i1, %g1, %g1                             <== NOT EXECUTED
4001bee8:	d4 00 60 04 	ld  [ %g1 + 4 ], %o2                           <== NOT EXECUTED
4001beec:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001bef0:	92 10 00 13 	mov  %l3, %o1                                  <== NOT EXECUTED
4001bef4:	40 00 01 cb 	call  4001c620 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
4001bef8:	96 10 20 01 	mov  1, %o3                                    <== NOT EXECUTED
                                                  map->blocks[doubly], true);
            if (rc > 0)                                               
4001befc:	ba 92 20 00 	orcc  %o0, 0, %i5                              <== NOT EXECUTED
4001bf00:	24 bf ff b2 	ble,a   4001bdc8 <rtems_rfs_block_map_grow+0x254><== NOT EXECUTED
4001bf04:	c2 06 60 4c 	ld  [ %i1 + 0x4c ], %g1                        <== NOT EXECUTED
            {                                                         
              rtems_rfs_group_bitmap_free (fs, false, singly_block);  
4001bf08:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          <== NOT EXECUTED
4001bf0c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001bf10:	7f ff d8 50 	call  40012050 <rtems_rfs_group_bitmap_free>   <== NOT EXECUTED
4001bf14:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
              rtems_rfs_group_bitmap_free (fs, false, block);         
4001bf18:	d4 07 bf f8 	ld  [ %fp + -8 ], %o2                          <== NOT EXECUTED
4001bf1c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001bf20:	7f ff d8 4c 	call  40012050 <rtems_rfs_group_bitmap_free>   <== NOT EXECUTED
4001bf24:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4001bf28:	30 bf ff 20 	b,a   4001bba8 <rtems_rfs_block_map_grow+0x34> <== NOT EXECUTED
      *new_block = block;                                             
    map->last_data_block = block;                                     
    map->dirty = true;                                                
  }                                                                   
                                                                      
  return 0;                                                           
4001bf2c:	ba 10 20 00 	clr  %i5                                       
}                                                                     
4001bf30:	81 c7 e0 08 	ret                                            
4001bf34:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
                                                                      
          rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
                                                singly_block, true);  
          if (rc > 0)                                                 
          {                                                           
            rtems_rfs_group_bitmap_free (fs, false, block);           
4001bf38:	d4 07 bf f8 	ld  [ %fp + -8 ], %o2                          <== NOT EXECUTED
4001bf3c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001bf40:	7f ff d8 44 	call  40012050 <rtems_rfs_group_bitmap_free>   <== NOT EXECUTED
4001bf44:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4001bf48:	30 bf ff 18 	b,a   4001bba8 <rtems_rfs_block_map_grow+0x34> <== NOT EXECUTED
                                                                      

4001b2e4 <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) {
4001b2e4:	9d e3 bf 98 	save  %sp, -104, %sp                           
  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);
4001b2e8:	d2 06 60 1c 	ld  [ %i1 + 0x1c ], %o1                        
4001b2ec:	94 10 20 00 	clr  %o2                                       
4001b2f0:	90 10 00 18 	mov  %i0, %o0                                  
4001b2f4:	7f ff da c8 	call  40011e14 <rtems_rfs_group_bitmap_alloc>  
4001b2f8:	96 07 bf fc 	add  %fp, -4, %o3                              
  if (rc > 0)                                                         
4001b2fc:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001b300:	04 80 00 04 	ble  4001b310 <rtems_rfs_block_map_indirect_alloc+0x2c><== ALWAYS TAKEN
4001b304:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          
  }                                                                   
  rtems_rfs_buffer_mark_dirty (buffer);                               
  *block = new_block;                                                 
  map->last_map_block = new_block;                                    
  return 0;                                                           
}                                                                     
4001b308:	81 c7 e0 08 	ret                                            
4001b30c:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
   * slots which are cleared when upping.                             
   */                                                                 
  rc = rtems_rfs_group_bitmap_alloc (fs, map->last_map_block, false, &new_block);
  if (rc > 0)                                                         
    return rc;                                                        
  rc = rtems_rfs_buffer_handle_request (fs, buffer, new_block, false);
4001b310:	90 10 00 18 	mov  %i0, %o0                                  
4001b314:	92 10 00 1a 	mov  %i2, %o1                                  
4001b318:	40 00 04 c2 	call  4001c620 <rtems_rfs_buffer_handle_request>
4001b31c:	96 10 20 00 	clr  %o3                                       
  if (rc > 0)                                                         
4001b320:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001b324:	04 80 00 08 	ble  4001b344 <rtems_rfs_block_map_indirect_alloc+0x60><== ALWAYS TAKEN
4001b328:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          
  {                                                                   
    rtems_rfs_group_bitmap_free (fs, false, new_block);               
4001b32c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001b330:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4001b334:	7f ff db 47 	call  40012050 <rtems_rfs_group_bitmap_free>   <== NOT EXECUTED
4001b338:	b0 10 00 1d 	mov  %i5, %i0                                  <== NOT EXECUTED
  }                                                                   
  rtems_rfs_buffer_mark_dirty (buffer);                               
  *block = new_block;                                                 
  map->last_map_block = new_block;                                    
  return 0;                                                           
}                                                                     
4001b33c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001b340:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_group_bitmap_free (fs, false, new_block);               
    return rc;                                                        
  }                                                                   
  memset (rtems_rfs_buffer_data (buffer), 0xff, rtems_rfs_fs_block_size (fs));
4001b344:	c2 06 a0 08 	ld  [ %i2 + 8 ], %g1                           
4001b348:	d4 06 20 08 	ld  [ %i0 + 8 ], %o2                           
4001b34c:	d0 00 60 1c 	ld  [ %g1 + 0x1c ], %o0                        
4001b350:	40 00 22 8d 	call  40023d84 <memset>                        
4001b354:	92 10 20 ff 	mov  0xff, %o1                                 
  if (upping)                                                         
4001b358:	80 a7 20 00 	cmp  %i4, 0                                    
4001b35c:	12 80 00 08 	bne  4001b37c <rtems_rfs_block_map_indirect_alloc+0x98><== ALWAYS TAKEN
4001b360:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
              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);                               
4001b364:	84 10 20 01 	mov  1, %g2                                    
4001b368:	c4 2e 80 00 	stb  %g2, [ %i2 ]                              
  *block = new_block;                                                 
4001b36c:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
  map->last_map_block = new_block;                                    
4001b370:	c2 26 60 1c 	st  %g1, [ %i1 + 0x1c ]                        
  return 0;                                                           
4001b374:	10 bf ff e5 	b  4001b308 <rtems_rfs_block_map_indirect_alloc+0x24>
4001b378:	ba 10 20 00 	clr  %i5                                       
  }                                                                   
  memset (rtems_rfs_buffer_data (buffer), 0xff, rtems_rfs_fs_block_size (fs));
  if (upping)                                                         
  {                                                                   
    int b;                                                            
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))             
4001b37c:	90 10 20 00 	clr  %o0                                       
4001b380:	7f ff e2 c9 	call  40013ea4 <rtems_rfs_trace>               
4001b384:	13 00 00 08 	sethi  %hi(0x2000), %o1                        
4001b388:	80 8a 20 ff 	btst  0xff, %o0                                
4001b38c:	32 80 00 24 	bne,a   4001b41c <rtems_rfs_block_map_indirect_alloc+0x138><== NEVER TAKEN
4001b390:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
4001b394:	84 10 00 19 	mov  %i1, %g2                                  
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)  
{                                                                     
4001b398:	82 10 20 00 	clr  %g1                                       
    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]);         
4001b39c:	ba 10 20 01 	mov  1, %i5                                    
4001b3a0:	c6 06 a0 08 	ld  [ %i2 + 8 ], %g3                           
4001b3a4:	c8 08 a0 24 	ldub  [ %g2 + 0x24 ], %g4                      
4001b3a8:	c6 00 e0 1c 	ld  [ %g3 + 0x1c ], %g3                        
4001b3ac:	c8 28 c0 01 	stb  %g4, [ %g3 + %g1 ]                        
4001b3b0:	c6 06 a0 08 	ld  [ %i2 + 8 ], %g3                           
4001b3b4:	c8 10 a0 24 	lduh  [ %g2 + 0x24 ], %g4                      
4001b3b8:	c6 00 e0 1c 	ld  [ %g3 + 0x1c ], %g3                        
4001b3bc:	86 00 c0 01 	add  %g3, %g1, %g3                             
4001b3c0:	c8 28 e0 01 	stb  %g4, [ %g3 + 1 ]                          
4001b3c4:	c6 06 a0 08 	ld  [ %i2 + 8 ], %g3                           
4001b3c8:	c8 00 a0 24 	ld  [ %g2 + 0x24 ], %g4                        
4001b3cc:	c6 00 e0 1c 	ld  [ %g3 + 0x1c ], %g3                        
4001b3d0:	89 31 20 08 	srl  %g4, 8, %g4                               
4001b3d4:	86 00 c0 01 	add  %g3, %g1, %g3                             
4001b3d8:	c8 28 e0 02 	stb  %g4, [ %g3 + 2 ]                          
4001b3dc:	c6 06 a0 08 	ld  [ %i2 + 8 ], %g3                           
4001b3e0:	c8 00 a0 24 	ld  [ %g2 + 0x24 ], %g4                        
4001b3e4:	c6 00 e0 1c 	ld  [ %g3 + 0x1c ], %g3                        
4001b3e8:	84 00 a0 04 	add  %g2, 4, %g2                               
4001b3ec:	86 00 c0 01 	add  %g3, %g1, %g3                             
4001b3f0:	c8 28 e0 03 	stb  %g4, [ %g3 + 3 ]                          
4001b3f4:	82 00 60 04 	add  %g1, 4, %g1                               
  {                                                                   
    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++)                      
4001b3f8:	80 a0 60 14 	cmp  %g1, 0x14                                 
4001b3fc:	12 bf ff e9 	bne  4001b3a0 <rtems_rfs_block_map_indirect_alloc+0xbc>
4001b400:	fa 2e 80 00 	stb  %i5, [ %i2 ]                              
      rtems_rfs_block_set_number (buffer, b, map->blocks[b]);         
    memset (map->blocks, 0, sizeof (map->blocks));                    
4001b404:	90 06 60 24 	add  %i1, 0x24, %o0                            
4001b408:	92 10 20 00 	clr  %o1                                       
4001b40c:	40 00 22 5e 	call  40023d84 <memset>                        
4001b410:	94 10 20 14 	mov  0x14, %o2                                 
  }                                                                   
  rtems_rfs_buffer_mark_dirty (buffer);                               
  *block = new_block;                                                 
4001b414:	10 bf ff d4 	b  4001b364 <rtems_rfs_block_map_indirect_alloc+0x80>
4001b418:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
  memset (rtems_rfs_buffer_data (buffer), 0xff, rtems_rfs_fs_block_size (fs));
  if (upping)                                                         
  {                                                                   
    int b;                                                            
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))             
      printf ("rtems-rfs: block-map-grow: upping: block-count=%" PRId32 "\n",
4001b41c:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
4001b420:	40 00 22 d7 	call  40023f7c <printf>                        <== NOT EXECUTED
4001b424:	90 12 20 00 	mov  %o0, %o0	! 40036c00 <CSWTCH.2+0x10>       <== NOT EXECUTED
4001b428:	10 bf ff dc 	b  4001b398 <rtems_rfs_block_map_indirect_alloc+0xb4><== NOT EXECUTED
4001b42c:	84 10 00 19 	mov  %i1, %g2                                  <== NOT EXECUTED
                                                                      

4001b230 <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) {
4001b230:	9d e3 bf a0 	save  %sp, -96, %sp                            
   * 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) ||                                                 
4001b234:	80 a7 20 00 	cmp  %i4, 0                                    
4001b238:	22 80 00 07 	be,a   4001b254 <rtems_rfs_block_map_indirect_shrink+0x24><== NEVER TAKEN
4001b23c:	b6 06 e0 08 	add  %i3, 8, %i3                               <== NOT EXECUTED
4001b240:	80 a7 20 05 	cmp  %i4, 5                                    
4001b244:	02 80 00 11 	be  4001b288 <rtems_rfs_block_map_indirect_shrink+0x58>
4001b248:	80 a6 e0 00 	cmp  %i3, 0                                    
                                     rtems_rfs_block_map*     map,    
                                     rtems_rfs_buffer_handle* buffer, 
                                     rtems_rfs_block_no       indirect,
                                     rtems_rfs_block_no       index)  
{                                                                     
  int rc = 0;                                                         
4001b24c:	81 c7 e0 08 	ret                                            
4001b250:	91 e8 20 00 	restore  %g0, 0, %o0                           
   * 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];         
4001b254:	b7 2e e0 02 	sll  %i3, 2, %i3                               <== NOT EXECUTED
4001b258:	b6 06 40 1b 	add  %i1, %i3, %i3                             <== NOT EXECUTED
4001b25c:	f4 06 e0 04 	ld  [ %i3 + 4 ], %i2                           <== NOT EXECUTED
    else                                                              
    {                                                                 
      /*                                                              
       * One less singly indirect block in the inode.                 
       */                                                             
      map->blocks[indirect] = 0;                                      
4001b260:	c0 26 e0 04 	clr  [ %i3 + 4 ]                               <== NOT EXECUTED
    }                                                                 
                                                                      
    rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);      
4001b264:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001b268:	92 10 20 00 	clr  %o1                                       
4001b26c:	7f ff db 79 	call  40012050 <rtems_rfs_group_bitmap_free>   
4001b270:	94 10 00 1a 	mov  %i2, %o2                                  
    if (rc > 0)                                                       
4001b274:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001b278:	24 80 00 02 	ble,a   4001b280 <rtems_rfs_block_map_indirect_shrink+0x50><== ALWAYS TAKEN
4001b27c:	f4 26 60 1c 	st  %i2, [ %i1 + 0x1c ]                        
                                                                      
    map->last_map_block = block_to_free;                              
  }                                                                   
                                                                      
  return rc;                                                          
}                                                                     
4001b280:	81 c7 e0 08 	ret                                            
4001b284:	81 e8 00 00 	restore                                        
   * 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) ||                                                 
4001b288:	12 bf ff f1 	bne  4001b24c <rtems_rfs_block_map_indirect_shrink+0x1c><== NEVER TAKEN
4001b28c:	84 10 20 00 	clr  %g2                                       
4001b290:	c2 06 a0 08 	ld  [ %i2 + 8 ], %g1                           
      ((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS)))         
  {                                                                   
    rtems_rfs_block_no block_to_free = map->blocks[indirect];         
4001b294:	f4 06 60 24 	ld  [ %i1 + 0x24 ], %i2                        
4001b298:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        
      /*                                                              
       * 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);      
4001b29c:	c8 08 40 00 	ldub  [ %g1 ], %g4                             
4001b2a0:	f6 08 60 01 	ldub  [ %g1 + 1 ], %i3                         
4001b2a4:	f8 08 60 03 	ldub  [ %g1 + 3 ], %i4                         
4001b2a8:	fa 08 60 02 	ldub  [ %g1 + 2 ], %i5                         
 * @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,     
4001b2ac:	86 06 40 02 	add  %i1, %g2, %g3                             
      /*                                                              
       * 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);      
4001b2b0:	89 29 20 18 	sll  %g4, 0x18, %g4                            
4001b2b4:	b7 2e e0 10 	sll  %i3, 0x10, %i3                            
4001b2b8:	bb 2f 60 08 	sll  %i5, 8, %i5                               
4001b2bc:	88 11 00 1b 	or  %g4, %i3, %g4                              
4001b2c0:	88 11 00 1c 	or  %g4, %i4, %g4                              
4001b2c4:	88 11 00 1d 	or  %g4, %i5, %g4                              
4001b2c8:	c8 20 e0 24 	st  %g4, [ %g3 + 0x24 ]                        
4001b2cc:	84 00 a0 04 	add  %g2, 4, %g2                               
    {                                                                 
      /*                                                              
       * Move to direct inode access.                                 
       */                                                             
      int b;                                                          
      for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)                    
4001b2d0:	80 a0 a0 14 	cmp  %g2, 0x14                                 
4001b2d4:	12 bf ff f2 	bne  4001b29c <rtems_rfs_block_map_indirect_shrink+0x6c>
4001b2d8:	82 00 60 04 	add  %g1, 4, %g1                               
       * One less singly indirect block in the inode.                 
       */                                                             
      map->blocks[indirect] = 0;                                      
    }                                                                 
                                                                      
    rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);      
4001b2dc:	10 bf ff e3 	b  4001b268 <rtems_rfs_block_map_indirect_shrink+0x38>
4001b2e0:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      

4001b610 <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) {
4001b610:	9d e3 bf a0 	save  %sp, -96, %sp                            
   * 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;                                                 
4001b614:	c0 2e 80 00 	clrb  [ %i2 ]                                  
  map->inode = NULL;                                                  
4001b618:	c0 26 a0 04 	clr  [ %i2 + 4 ]                               
 * @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;                                                    
4001b61c:	c0 26 a0 08 	clr  [ %i2 + 8 ]                               
  size->offset = 0;                                                   
4001b620:	c0 26 a0 0c 	clr  [ %i2 + 0xc ]                             
 * @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;                                                      
4001b624:	c0 26 a0 10 	clr  [ %i2 + 0x10 ]                            
  bpos->boff = 0;                                                     
4001b628:	c0 26 a0 14 	clr  [ %i2 + 0x14 ]                            
  bpos->block = 0;                                                    
4001b62c:	c0 26 a0 18 	clr  [ %i2 + 0x18 ]                            
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
4001b630:	c0 2e a0 38 	clrb  [ %i2 + 0x38 ]                           
  handle->bnum  = 0;                                                  
4001b634:	c0 26 a0 3c 	clr  [ %i2 + 0x3c ]                            
  handle->buffer = NULL;                                              
4001b638:	c0 26 a0 40 	clr  [ %i2 + 0x40 ]                            
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
4001b63c:	c0 2e a0 44 	clrb  [ %i2 + 0x44 ]                           
  handle->bnum  = 0;                                                  
4001b640:	c0 26 a0 48 	clr  [ %i2 + 0x48 ]                            
  handle->buffer = NULL;                                              
4001b644:	c0 26 a0 4c 	clr  [ %i2 + 0x4c ]                            
    return rc;                                                        
  rc = rtems_rfs_buffer_handle_open (fs, &map->doubly_buffer);        
  if (rc > 0)                                                         
    return rc;                                                        
                                                                      
  rc = rtems_rfs_inode_load (fs, inode);                              
4001b648:	90 10 00 18 	mov  %i0, %o0                                  
4001b64c:	92 10 00 19 	mov  %i1, %o1                                  
4001b650:	7f ff db 41 	call  40012354 <rtems_rfs_inode_load>          
4001b654:	ba 10 00 1a 	mov  %i2, %i5                                  
  if (rc > 0)                                                         
4001b658:	b8 92 20 00 	orcc  %o0, 0, %i4                              
4001b65c:	14 80 00 3f 	bg  4001b758 <rtems_rfs_block_map_open+0x148>  <== NEVER TAKEN
4001b660:	88 10 00 1a 	mov  %i2, %g4                                  
4001b664:	c6 06 60 0c 	ld  [ %i1 + 0xc ], %g3                         
                                                                      
  /*                                                                  
   * Extract the block and block count data from the inode into the targets
   * byte order.                                                      
   */                                                                 
  map->inode = inode;                                                 
4001b668:	f2 26 a0 04 	st  %i1, [ %i2 + 4 ]                           
  for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)                        
4001b66c:	82 10 20 00 	clr  %g1                                       
 * @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]);      
4001b670:	b8 00 60 06 	add  %g1, 6, %i4                               
4001b674:	b9 2f 20 02 	sll  %i4, 2, %i4                               
4001b678:	b8 00 c0 1c 	add  %g3, %i4, %i4                             
4001b67c:	de 0f 20 04 	ldub  [ %i4 + 4 ], %o7                         
4001b680:	f4 0f 20 05 	ldub  [ %i4 + 5 ], %i2                         
4001b684:	f6 0f 20 07 	ldub  [ %i4 + 7 ], %i3                         
4001b688:	f8 0f 20 06 	ldub  [ %i4 + 6 ], %i4                         
4001b68c:	85 2b e0 18 	sll  %o7, 0x18, %g2                            
4001b690:	b5 2e a0 10 	sll  %i2, 0x10, %i2                            
4001b694:	b9 2f 20 08 	sll  %i4, 8, %i4                               
4001b698:	84 10 80 1a 	or  %g2, %i2, %g2                              
4001b69c:	84 10 80 1b 	or  %g2, %i3, %g2                              
4001b6a0:	84 10 80 1c 	or  %g2, %i4, %g2                              
    map->blocks[b] = rtems_rfs_inode_get_block (inode, b);            
4001b6a4:	c4 21 20 24 	st  %g2, [ %g4 + 0x24 ]                        
  /*                                                                  
   * 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++)                        
4001b6a8:	82 00 60 01 	inc  %g1                                       
4001b6ac:	80 a0 60 05 	cmp  %g1, 5                                    
4001b6b0:	12 bf ff f0 	bne  4001b670 <rtems_rfs_block_map_open+0x60>  
4001b6b4:	88 01 20 04 	add  %g4, 4, %g4                               
 * @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);             
4001b6b8:	c8 08 e0 0f 	ldub  [ %g3 + 0xf ], %g4                       
4001b6bc:	c2 08 e0 0c 	ldub  [ %g3 + 0xc ], %g1                       
4001b6c0:	f8 08 e0 0d 	ldub  [ %g3 + 0xd ], %i4                       
4001b6c4:	c4 08 e0 0e 	ldub  [ %g3 + 0xe ], %g2                       
4001b6c8:	b9 2f 20 10 	sll  %i4, 0x10, %i4                            
4001b6cc:	85 28 a0 08 	sll  %g2, 8, %g2                               
4001b6d0:	83 28 60 18 	sll  %g1, 0x18, %g1                            
4001b6d4:	82 10 40 1c 	or  %g1, %i4, %g1                              
4001b6d8:	82 10 40 04 	or  %g1, %g4, %g1                              
4001b6dc:	82 10 40 02 	or  %g1, %g2, %g1                              
    map->blocks[b] = rtems_rfs_inode_get_block (inode, b);            
  map->size.count = rtems_rfs_inode_get_block_count (inode);          
4001b6e0:	c2 27 60 08 	st  %g1, [ %i5 + 8 ]                           
  map->size.offset = rtems_rfs_inode_get_block_offset (inode);        
4001b6e4:	c4 08 e0 0b 	ldub  [ %g3 + 0xb ], %g2                       
 * @return uint32_t The block offset.                                 
 */                                                                   
static inline uint16_t                                                
rtems_rfs_inode_get_block_offset (rtems_rfs_inode_handle* handle)     
{                                                                     
  return rtems_rfs_read_u16 (&handle->node->block_offset);            
4001b6e8:	c2 08 e0 0a 	ldub  [ %g3 + 0xa ], %g1                       
4001b6ec:	83 28 60 08 	sll  %g1, 8, %g1                               
4001b6f0:	82 10 80 01 	or  %g2, %g1, %g1                              
4001b6f4:	c2 27 60 0c 	st  %g1, [ %i5 + 0xc ]                         
 * @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);          
4001b6f8:	c8 08 e0 33 	ldub  [ %g3 + 0x33 ], %g4                      
4001b6fc:	c2 08 e0 30 	ldub  [ %g3 + 0x30 ], %g1                      
4001b700:	f8 08 e0 31 	ldub  [ %g3 + 0x31 ], %i4                      
4001b704:	c4 08 e0 32 	ldub  [ %g3 + 0x32 ], %g2                      
4001b708:	b9 2f 20 10 	sll  %i4, 0x10, %i4                            
4001b70c:	85 28 a0 08 	sll  %g2, 8, %g2                               
4001b710:	83 28 60 18 	sll  %g1, 0x18, %g1                            
4001b714:	82 10 40 1c 	or  %g1, %i4, %g1                              
4001b718:	82 10 40 04 	or  %g1, %g4, %g1                              
4001b71c:	82 10 40 02 	or  %g1, %g2, %g1                              
  map->last_map_block = rtems_rfs_inode_get_last_map_block (inode);   
4001b720:	c2 27 60 1c 	st  %g1, [ %i5 + 0x1c ]                        
 * @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);         
4001b724:	c2 08 e0 34 	ldub  [ %g3 + 0x34 ], %g1                      
4001b728:	c8 08 e0 37 	ldub  [ %g3 + 0x37 ], %g4                      
4001b72c:	c4 08 e0 36 	ldub  [ %g3 + 0x36 ], %g2                      
4001b730:	f8 08 e0 35 	ldub  [ %g3 + 0x35 ], %i4                      
4001b734:	83 28 60 18 	sll  %g1, 0x18, %g1                            
4001b738:	87 2f 20 10 	sll  %i4, 0x10, %g3                            
4001b73c:	85 28 a0 08 	sll  %g2, 8, %g2                               
4001b740:	82 10 40 03 	or  %g1, %g3, %g1                              
4001b744:	82 10 40 04 	or  %g1, %g4, %g1                              
4001b748:	82 10 40 02 	or  %g1, %g2, %g1                              
  map->last_data_block = rtems_rfs_inode_get_last_data_block (inode); 
4001b74c:	c2 27 60 20 	st  %g1, [ %i5 + 0x20 ]                        
                                                                      
  rc = rtems_rfs_inode_unload (fs, inode, false);                     
4001b750:	7f ff db 65 	call  400124e4 <rtems_rfs_inode_unload>        
4001b754:	95 e8 20 00 	restore  %g0, 0, %o2                           
 */                                                                   
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);                       
4001b758:	92 06 a0 38 	add  %i2, 0x38, %o1                            <== NOT EXECUTED
4001b75c:	40 00 03 37 	call  4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001b760:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001b764:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
4001b768:	c0 2e a0 38 	clrb  [ %i2 + 0x38 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
4001b76c:	c0 26 a0 3c 	clr  [ %i2 + 0x3c ]                            <== NOT EXECUTED
  handle->buffer = NULL;                                              
4001b770:	c0 26 a0 40 	clr  [ %i2 + 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);                       
4001b774:	92 06 a0 44 	add  %i2, 0x44, %o1                            <== NOT EXECUTED
4001b778:	40 00 03 30 	call  4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001b77c:	b0 10 00 1c 	mov  %i4, %i0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
4001b780:	c0 2e a0 44 	clrb  [ %i2 + 0x44 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
4001b784:	c0 26 a0 48 	clr  [ %i2 + 0x48 ]                            <== NOT EXECUTED
  handle->buffer = NULL;                                              
4001b788:	c0 26 a0 4c 	clr  [ %i2 + 0x4c ]                            <== NOT EXECUTED
                                                                      
  return rc;                                                          
}                                                                     
4001b78c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001b790:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4001bf4c <rtems_rfs_block_map_shrink>: int rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs, rtems_rfs_block_map* map, size_t blocks) {
4001bf4c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))             
4001bf50:	90 10 20 00 	clr  %o0                                       
4001bf54:	13 00 00 10 	sethi  %hi(0x4000), %o1                        
4001bf58:	7f ff df d3 	call  40013ea4 <rtems_rfs_trace>               
4001bf5c:	b6 10 00 18 	mov  %i0, %i3                                  
4001bf60:	80 8a 20 ff 	btst  0xff, %o0                                
4001bf64:	32 80 00 b0 	bne,a   4001c224 <rtems_rfs_block_map_shrink+0x2d8><== NEVER TAKEN
4001bf68:	d4 06 60 08 	ld  [ %i1 + 8 ], %o2                           <== NOT EXECUTED
    printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
            blocks, map->size.count);                                 
                                                                      
  if (map->size.count == 0)                                           
4001bf6c:	f8 06 60 08 	ld  [ %i1 + 8 ], %i4                           
4001bf70:	80 a7 20 00 	cmp  %i4, 0                                    
4001bf74:	02 80 00 a9 	be  4001c218 <rtems_rfs_block_map_shrink+0x2cc>
4001bf78:	80 a6 80 1c 	cmp  %i2, %i4                                  
4001bf7c:	38 80 00 02 	bgu,a   4001bf84 <rtems_rfs_block_map_shrink+0x38><== NEVER TAKEN
4001bf80:	b4 10 00 1c 	mov  %i4, %i2                                  <== NOT EXECUTED
    return 0;                                                         
                                                                      
  if (blocks > map->size.count)                                       
    blocks = map->size.count;                                         
                                                                      
  while (blocks)                                                      
4001bf84:	80 a6 a0 00 	cmp  %i2, 0                                    
4001bf88:	02 80 00 98 	be  4001c1e8 <rtems_rfs_block_map_shrink+0x29c><== NEVER TAKEN
4001bf8c:	a6 06 60 44 	add  %i1, 0x44, %l3                            
                                             doubly_singly);          
                                                                      
        /*                                                            
         * Read the singly indirect table and get the block number.   
         */                                                           
        rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001bf90:	a4 06 60 38 	add  %i1, 0x38, %l2                            
    if (rc > 0)                                                       
      return rc;                                                      
    map->size.count--;                                                
    map->size.offset = 0;                                             
    map->last_data_block = block_to_free;                             
    map->dirty = true;                                                
4001bf94:	10 80 00 14 	b  4001bfe4 <rtems_rfs_block_map_shrink+0x98>  
4001bf98:	a2 10 20 01 	mov  1, %l1                                    
    {                                                                 
      /*                                                              
       * We have less than RTEMS_RFS_INODE_BLOCKS so they are held in the
       * inode.                                                       
       */                                                             
      block_to_free = map->blocks[block];                             
4001bf9c:	b9 2f 20 02 	sll  %i4, 2, %i4                               
4001bfa0:	b8 06 40 1c 	add  %i1, %i4, %i4                             
4001bfa4:	fa 07 20 04 	ld  [ %i4 + 4 ], %i5                           
      map->blocks[block] = 0;                                         
4001bfa8:	c0 27 20 04 	clr  [ %i4 + 4 ]                               
      {                                                               
        rc = EIO;                                                     
        break;                                                        
      }                                                               
    }                                                                 
    rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);      
4001bfac:	90 10 00 1b 	mov  %i3, %o0                                  
4001bfb0:	92 10 20 00 	clr  %o1                                       
4001bfb4:	7f ff d8 27 	call  40012050 <rtems_rfs_group_bitmap_free>   
4001bfb8:	94 10 00 1d 	mov  %i5, %o2                                  
    if (rc > 0)                                                       
4001bfbc:	80 a2 20 00 	cmp  %o0, 0                                    
4001bfc0:	14 80 00 63 	bg  4001c14c <rtems_rfs_block_map_shrink+0x200><== NEVER TAKEN
4001bfc4:	b4 86 bf ff 	addcc  %i2, -1, %i2                            
      return rc;                                                      
    map->size.count--;                                                
4001bfc8:	f8 06 60 08 	ld  [ %i1 + 8 ], %i4                           
    map->size.offset = 0;                                             
4001bfcc:	c0 26 60 0c 	clr  [ %i1 + 0xc ]                             
      }                                                               
    }                                                                 
    rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);      
    if (rc > 0)                                                       
      return rc;                                                      
    map->size.count--;                                                
4001bfd0:	b8 07 3f ff 	add  %i4, -1, %i4                              
    map->size.offset = 0;                                             
    map->last_data_block = block_to_free;                             
4001bfd4:	fa 26 60 20 	st  %i5, [ %i1 + 0x20 ]                        
      }                                                               
    }                                                                 
    rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);      
    if (rc > 0)                                                       
      return rc;                                                      
    map->size.count--;                                                
4001bfd8:	f8 26 60 08 	st  %i4, [ %i1 + 8 ]                           
    return 0;                                                         
                                                                      
  if (blocks > map->size.count)                                       
    blocks = map->size.count;                                         
                                                                      
  while (blocks)                                                      
4001bfdc:	02 80 00 80 	be  4001c1dc <rtems_rfs_block_map_shrink+0x290>
4001bfe0:	e2 2e 40 00 	stb  %l1, [ %i1 ]                              
  {                                                                   
    rtems_rfs_block_no block;                                         
    rtems_rfs_block_no block_to_free;                                 
    int                rc;                                            
                                                                      
    block = map->size.count - 1;                                      
4001bfe4:	ba 07 3f ff 	add  %i4, -1, %i5                              
                                                                      
    if (block < RTEMS_RFS_INODE_BLOCKS)                               
4001bfe8:	80 a7 60 04 	cmp  %i5, 4                                    
4001bfec:	28 bf ff ec 	bleu,a   4001bf9c <rtems_rfs_block_map_shrink+0x50>
4001bff0:	b8 07 20 07 	add  %i4, 7, %i4                               
       * table of block numbers.                                      
       */                                                             
      rtems_rfs_block_no direct;                                      
      rtems_rfs_block_no singly;                                      
                                                                      
      direct = block % fs->blocks_per_block;                          
4001bff4:	f0 06 e0 34 	ld  [ %i3 + 0x34 ], %i0                        
4001bff8:	90 10 00 1d 	mov  %i5, %o0                                  
4001bffc:	40 00 51 76 	call  400305d4 <.urem>                         
4001c000:	92 10 00 18 	mov  %i0, %o1                                  
      singly = block / fs->blocks_per_block;                          
4001c004:	92 10 00 18 	mov  %i0, %o1                                  
       * table of block numbers.                                      
       */                                                             
      rtems_rfs_block_no direct;                                      
      rtems_rfs_block_no singly;                                      
                                                                      
      direct = block % fs->blocks_per_block;                          
4001c008:	a0 10 00 08 	mov  %o0, %l0                                  
      singly = block / fs->blocks_per_block;                          
4001c00c:	7f ff 99 a5 	call  400026a0 <.udiv>                         
4001c010:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
      if (block < fs->block_map_singly_blocks)                        
4001c014:	c2 06 e0 38 	ld  [ %i3 + 0x38 ], %g1                        
4001c018:	80 a7 40 01 	cmp  %i5, %g1                                  
4001c01c:	0a 80 00 4e 	bcs  4001c154 <rtems_rfs_block_map_shrink+0x208><== ALWAYS TAKEN
4001c020:	a8 10 00 08 	mov  %o0, %l4                                  
        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)                   
4001c024:	c2 06 e0 3c 	ld  [ %i3 + 0x3c ], %g1                        <== NOT EXECUTED
4001c028:	80 a7 40 01 	cmp  %i5, %g1                                  <== NOT EXECUTED
4001c02c:	1a 80 00 6d 	bcc  4001c1e0 <rtems_rfs_block_map_shrink+0x294><== NOT EXECUTED
4001c030:	80 a7 20 00 	cmp  %i4, 0                                    <== 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;                
4001c034:	7f ff 99 9b 	call  400026a0 <.udiv>                         <== NOT EXECUTED
4001c038:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
        doubly_singly = singly % fs->blocks_per_block;                
4001c03c:	92 10 00 18 	mov  %i0, %o1                                  <== 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;                
4001c040:	b8 10 00 08 	mov  %o0, %i4                                  <== NOT EXECUTED
        doubly_singly = singly % fs->blocks_per_block;                
4001c044:	40 00 51 64 	call  400305d4 <.urem>                         <== NOT EXECUTED
4001c048:	90 10 00 14 	mov  %l4, %o0                                  <== NOT EXECUTED
                                                                      
        rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
4001c04c:	82 07 20 08 	add  %i4, 8, %g1                               <== NOT EXECUTED
4001c050:	83 28 60 02 	sll  %g1, 2, %g1                               <== NOT EXECUTED
4001c054:	82 06 40 01 	add  %i1, %g1, %g1                             <== NOT EXECUTED
4001c058:	d4 00 60 04 	ld  [ %g1 + 4 ], %o2                           <== 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;                
4001c05c:	a8 10 00 08 	mov  %o0, %l4                                  <== NOT EXECUTED
                                                                      
        rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
4001c060:	92 10 00 13 	mov  %l3, %o1                                  <== NOT EXECUTED
4001c064:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
4001c068:	40 00 01 6e 	call  4001c620 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
4001c06c:	96 10 20 01 	mov  1, %o3                                    <== NOT EXECUTED
                                              map->blocks[doubly], true);
        if (rc > 0)                                                   
4001c070:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4001c074:	14 80 00 36 	bg  4001c14c <rtems_rfs_block_map_shrink+0x200><== NOT EXECUTED
4001c078:	85 2d 20 02 	sll  %l4, 2, %g2                               <== NOT EXECUTED
          return rc;                                                  
                                                                      
        singly = rtems_rfs_block_get_number (&map->doubly_buffer,     
4001c07c:	c2 06 60 4c 	ld  [ %i1 + 0x4c ], %g1                        <== NOT EXECUTED
4001c080:	c6 00 60 1c 	ld  [ %g1 + 0x1c ], %g3                        <== NOT EXECUTED
                                             doubly_singly);          
                                                                      
        /*                                                            
         * Read the singly indirect table and get the block number.   
         */                                                           
        rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001c084:	90 10 00 1b 	mov  %i3, %o0                                  <== 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,     
4001c088:	82 00 c0 02 	add  %g3, %g2, %g1                             <== NOT EXECUTED
4001c08c:	c6 08 c0 02 	ldub  [ %g3 + %g2 ], %g3                       <== NOT EXECUTED
4001c090:	ea 08 60 03 	ldub  [ %g1 + 3 ], %l5                         <== NOT EXECUTED
4001c094:	c4 08 60 01 	ldub  [ %g1 + 1 ], %g2                         <== NOT EXECUTED
4001c098:	c2 08 60 02 	ldub  [ %g1 + 2 ], %g1                         <== NOT EXECUTED
4001c09c:	87 28 e0 18 	sll  %g3, 0x18, %g3                            <== NOT EXECUTED
4001c0a0:	85 28 a0 10 	sll  %g2, 0x10, %g2                            <== NOT EXECUTED
4001c0a4:	83 28 60 08 	sll  %g1, 8, %g1                               <== NOT EXECUTED
4001c0a8:	aa 15 40 03 	or  %l5, %g3, %l5                              <== NOT EXECUTED
                                             doubly_singly);          
                                                                      
        /*                                                            
         * Read the singly indirect table and get the block number.   
         */                                                           
        rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001c0ac:	92 10 00 12 	mov  %l2, %o1                                  <== 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,     
4001c0b0:	aa 15 40 02 	or  %l5, %g2, %l5                              <== NOT EXECUTED
                                             doubly_singly);          
                                                                      
        /*                                                            
         * Read the singly indirect table and get the block number.   
         */                                                           
        rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001c0b4:	96 10 20 01 	mov  1, %o3                                    <== 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,     
4001c0b8:	aa 15 40 01 	or  %l5, %g1, %l5                              <== NOT EXECUTED
                                             doubly_singly);          
                                                                      
        /*                                                            
         * Read the singly indirect table and get the block number.   
         */                                                           
        rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001c0bc:	40 00 01 59 	call  4001c620 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
4001c0c0:	94 10 00 15 	mov  %l5, %o2                                  <== NOT EXECUTED
                                              singly, true);          
        if (rc > 0)                                                   
4001c0c4:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4001c0c8:	14 80 00 21 	bg  4001c14c <rtems_rfs_block_map_shrink+0x200><== NOT EXECUTED
4001c0cc:	85 2c 20 02 	sll  %l0, 2, %g2                               <== NOT EXECUTED
          return rc;                                                  
                                                                      
        block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
4001c0d0:	c2 06 60 40 	ld  [ %i1 + 0x40 ], %g1                        <== NOT EXECUTED
4001c0d4:	c6 00 60 1c 	ld  [ %g1 + 0x1c ], %g3                        <== NOT EXECUTED
                                                    direct);          
                                                                      
        if (direct == 0)                                              
4001c0d8:	80 a4 20 00 	cmp  %l0, 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,
4001c0dc:	82 00 c0 02 	add  %g3, %g2, %g1                             <== NOT EXECUTED
4001c0e0:	c6 08 c0 02 	ldub  [ %g3 + %g2 ], %g3                       <== NOT EXECUTED
4001c0e4:	fa 08 60 03 	ldub  [ %g1 + 3 ], %i5                         <== NOT EXECUTED
4001c0e8:	c4 08 60 01 	ldub  [ %g1 + 1 ], %g2                         <== NOT EXECUTED
4001c0ec:	c2 08 60 02 	ldub  [ %g1 + 2 ], %g1                         <== NOT EXECUTED
4001c0f0:	87 28 e0 18 	sll  %g3, 0x18, %g3                            <== NOT EXECUTED
4001c0f4:	85 28 a0 10 	sll  %g2, 0x10, %g2                            <== NOT EXECUTED
4001c0f8:	ba 17 40 03 	or  %i5, %g3, %i5                              <== NOT EXECUTED
4001c0fc:	83 28 60 08 	sll  %g1, 8, %g1                               <== NOT EXECUTED
4001c100:	ba 17 40 02 	or  %i5, %g2, %i5                              <== NOT EXECUTED
                                                    direct);          
                                                                      
        if (direct == 0)                                              
4001c104:	12 bf ff aa 	bne  4001bfac <rtems_rfs_block_map_shrink+0x60><== NOT EXECUTED
4001c108:	ba 17 40 01 	or  %i5, %g1, %i5                              <== NOT EXECUTED
        {                                                             
          rc = rtems_rfs_group_bitmap_free (fs, false, singly);       
4001c10c:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
4001c110:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4001c114:	7f ff d7 cf 	call  40012050 <rtems_rfs_group_bitmap_free>   <== NOT EXECUTED
4001c118:	94 10 00 15 	mov  %l5, %o2                                  <== NOT EXECUTED
          if (rc > 0)                                                 
4001c11c:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4001c120:	14 80 00 0b 	bg  4001c14c <rtems_rfs_block_map_shrink+0x200><== NOT EXECUTED
4001c124:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
            return rc;                                                
                                                                      
          map->last_map_block = singly;                               
4001c128:	ea 26 60 1c 	st  %l5, [ %i1 + 0x1c ]                        <== NOT EXECUTED
                                                                      
          rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->doubly_buffer,
4001c12c:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
4001c130:	94 10 00 13 	mov  %l3, %o2                                  <== NOT EXECUTED
4001c134:	96 10 00 1c 	mov  %i4, %o3                                  <== NOT EXECUTED
4001c138:	7f ff fc 3e 	call  4001b230 <rtems_rfs_block_map_indirect_shrink><== NOT EXECUTED
4001c13c:	98 10 00 14 	mov  %l4, %o4                                  <== NOT EXECUTED
                                                    doubly, doubly_singly);
          if (rc)                                                     
4001c140:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4001c144:	22 bf ff 9b 	be,a   4001bfb0 <rtems_rfs_block_map_shrink+0x64><== NOT EXECUTED
4001c148:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
   */                                                                 
  if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))          
    rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);           
                                                                      
  return 0;                                                           
}                                                                     
4001c14c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001c150:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== 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,
4001c154:	82 02 20 08 	add  %o0, 8, %g1                               
4001c158:	83 28 60 02 	sll  %g1, 2, %g1                               
4001c15c:	82 06 40 01 	add  %i1, %g1, %g1                             
4001c160:	d4 00 60 04 	ld  [ %g1 + 4 ], %o2                           
4001c164:	90 10 00 1b 	mov  %i3, %o0                                  
4001c168:	92 10 00 12 	mov  %l2, %o1                                  
4001c16c:	40 00 01 2d 	call  4001c620 <rtems_rfs_buffer_handle_request>
4001c170:	96 10 20 01 	mov  1, %o3                                    
                                              map->blocks[singly], true);
        if (rc > 0)                                                   
4001c174:	80 a2 20 00 	cmp  %o0, 0                                    
4001c178:	14 bf ff f5 	bg  4001c14c <rtems_rfs_block_map_shrink+0x200><== NEVER TAKEN
4001c17c:	85 2c 20 02 	sll  %l0, 2, %g2                               
          return rc;                                                  
                                                                      
        block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
4001c180:	c2 06 60 40 	ld  [ %i1 + 0x40 ], %g1                        
4001c184:	c6 00 60 1c 	ld  [ %g1 + 0x1c ], %g3                        
                                                    direct);          
                                                                      
        rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
4001c188:	90 10 00 1b 	mov  %i3, %o0                                  
        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,
4001c18c:	82 00 c0 02 	add  %g3, %g2, %g1                             
4001c190:	c6 08 c0 02 	ldub  [ %g3 + %g2 ], %g3                       
4001c194:	fa 08 60 03 	ldub  [ %g1 + 3 ], %i5                         
4001c198:	c4 08 60 01 	ldub  [ %g1 + 1 ], %g2                         
4001c19c:	c2 08 60 02 	ldub  [ %g1 + 2 ], %g1                         
4001c1a0:	87 28 e0 18 	sll  %g3, 0x18, %g3                            
4001c1a4:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
4001c1a8:	83 28 60 08 	sll  %g1, 8, %g1                               
4001c1ac:	ba 17 40 03 	or  %i5, %g3, %i5                              
                                                    direct);          
                                                                      
        rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
4001c1b0:	92 10 00 19 	mov  %i1, %o1                                  
        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,
4001c1b4:	ba 17 40 02 	or  %i5, %g2, %i5                              
                                                    direct);          
                                                                      
        rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
4001c1b8:	94 10 00 12 	mov  %l2, %o2                                  
        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,
4001c1bc:	ba 17 40 01 	or  %i5, %g1, %i5                              
                                                    direct);          
                                                                      
        rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
4001c1c0:	96 10 00 14 	mov  %l4, %o3                                  
4001c1c4:	7f ff fc 1b 	call  4001b230 <rtems_rfs_block_map_indirect_shrink>
4001c1c8:	98 10 00 10 	mov  %l0, %o4                                  
                                                  singly, direct);    
        if (rc)                                                       
4001c1cc:	80 a2 20 00 	cmp  %o0, 0                                    
4001c1d0:	22 bf ff 78 	be,a   4001bfb0 <rtems_rfs_block_map_shrink+0x64><== ALWAYS TAKEN
4001c1d4:	90 10 00 1b 	mov  %i3, %o0                                  
4001c1d8:	30 bf ff dd 	b,a   4001c14c <rtems_rfs_block_map_shrink+0x200><== NOT EXECUTED
    map->last_data_block = block_to_free;                             
    map->dirty = true;                                                
    blocks--;                                                         
  }                                                                   
                                                                      
  if (map->size.count == 0)                                           
4001c1dc:	80 a7 20 00 	cmp  %i4, 0                                    
4001c1e0:	22 80 00 17 	be,a   4001c23c <rtems_rfs_block_map_shrink+0x2f0>
4001c1e4:	c0 26 60 1c 	clr  [ %i1 + 0x1c ]                            
  }                                                                   
                                                                      
  /*                                                                  
   * Keep the position inside the map.                                
   */                                                                 
  if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))          
4001c1e8:	c4 06 60 10 	ld  [ %i1 + 0x10 ], %g2                        
4001c1ec:	80 a0 80 1c 	cmp  %g2, %i4                                  
4001c1f0:	1a 80 00 14 	bcc  4001c240 <rtems_rfs_block_map_shrink+0x2f4><== NEVER TAKEN
4001c1f4:	82 07 3f ff 	add  %i4, -1, %g1                              
4001c1f8:	80 a0 40 02 	cmp  %g1, %g2                                  
4001c1fc:	12 80 00 08 	bne  4001c21c <rtems_rfs_block_map_shrink+0x2d0><== NEVER TAKEN
4001c200:	90 10 20 00 	clr  %o0                                       
4001c204:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
4001c208:	c4 06 60 14 	ld  [ %i1 + 0x14 ], %g2                        
4001c20c:	80 a0 80 01 	cmp  %g2, %g1                                  
4001c210:	38 80 00 0e 	bgu,a   4001c248 <rtems_rfs_block_map_shrink+0x2fc><== ALWAYS TAKEN
4001c214:	f8 26 60 10 	st  %i4, [ %i1 + 0x10 ]                        
  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)                                           
    return 0;                                                         
4001c218:	90 10 20 00 	clr  %o0                                       
   */                                                                 
  if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))          
    rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);           
                                                                      
  return 0;                                                           
}                                                                     
4001c21c:	81 c7 e0 08 	ret                                            
4001c220:	91 e8 00 08 	restore  %g0, %o0, %o0                         
rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,                
                            rtems_rfs_block_map*   map,               
                            size_t                 blocks)            
{                                                                     
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))             
    printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
4001c224:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
4001c228:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
4001c22c:	40 00 1f 54 	call  40023f7c <printf>                        <== NOT EXECUTED
4001c230:	90 12 20 c0 	or  %o0, 0xc0, %o0	! 40036cc0 <CSWTCH.2+0xd0>  <== NOT EXECUTED
            blocks, map->size.count);                                 
                                                                      
  if (map->size.count == 0)                                           
4001c234:	10 bf ff 4f 	b  4001bf70 <rtems_rfs_block_map_shrink+0x24>  <== NOT EXECUTED
4001c238:	f8 06 60 08 	ld  [ %i1 + 8 ], %i4                           <== NOT EXECUTED
  }                                                                   
                                                                      
  if (map->size.count == 0)                                           
  {                                                                   
    map->last_map_block = 0;                                          
    map->last_data_block = 0;                                         
4001c23c:	c0 26 60 20 	clr  [ %i1 + 0x20 ]                            
4001c240:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
                                                                      
  /*                                                                  
   * Keep the position inside the map.                                
   */                                                                 
  if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))          
    rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);           
4001c244:	f8 26 60 10 	st  %i4, [ %i1 + 0x10 ]                        
4001c248:	c2 26 60 14 	st  %g1, [ %i1 + 0x14 ]                        
4001c24c:	80 a0 60 00 	cmp  %g1, 0                                    
4001c250:	02 bf ff f2 	be  4001c218 <rtems_rfs_block_map_shrink+0x2cc><== ALWAYS TAKEN
4001c254:	c0 26 60 18 	clr  [ %i1 + 0x18 ]                            
4001c258:	b8 07 3f ff 	add  %i4, -1, %i4                              <== NOT EXECUTED
                                                                      
  return 0;                                                           
4001c25c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Keep the position inside the map.                                
   */                                                                 
  if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))          
    rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);           
4001c260:	f8 26 60 10 	st  %i4, [ %i1 + 0x10 ]                        <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
4001c264:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001c268:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
                                                                      

400224b8 <rtems_rfs_buffer_bdbuf_release>: int rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer, bool modified) {
400224b8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc;                                               
  int               rc = 0;                                           
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))               
400224bc:	90 10 20 00 	clr  %o0                                       
400224c0:	7f ff c6 79 	call  40013ea4 <rtems_rfs_trace>               
400224c4:	92 10 20 40 	mov  0x40, %o1                                 
400224c8:	80 8a 20 ff 	btst  0xff, %o0                                
400224cc:	02 80 00 0b 	be  400224f8 <rtems_rfs_buffer_bdbuf_release+0x40><== ALWAYS TAKEN
400224d0:	80 a6 60 00 	cmp  %i1, 0                                    
    printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n",
400224d4:	d2 06 20 34 	ld  [ %i0 + 0x34 ], %o1                        <== NOT EXECUTED
400224d8:	12 80 00 18 	bne  40022538 <rtems_rfs_buffer_bdbuf_release+0x80><== NOT EXECUTED
400224dc:	d4 06 20 18 	ld  [ %i0 + 0x18 ], %o2                        <== NOT EXECUTED
400224e0:	17 10 00 d0 	sethi  %hi(0x40034000), %o3                    <== NOT EXECUTED
400224e4:	96 12 e2 10 	or  %o3, 0x210, %o3	! 40034210 <__FUNCTION__.6193+0x148><== NOT EXECUTED
400224e8:	11 10 00 e0 	sethi  %hi(0x40038000), %o0                    <== NOT EXECUTED
400224ec:	40 00 06 a4 	call  40023f7c <printf>                        <== NOT EXECUTED
400224f0:	90 12 23 30 	or  %o0, 0x330, %o0	! 40038330 <rtems_rfs_rtems_file_handlers+0x3c><== NOT EXECUTED
            ((intptr_t) buffer->user),                                
            buffer->block, modified ? "(modified)" : "");             
                                                                      
  if (modified)                                                       
400224f4:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
400224f8:	02 80 00 09 	be  4002251c <rtems_rfs_buffer_bdbuf_release+0x64>
400224fc:	90 10 00 18 	mov  %i0, %o0                                  
    sc = rtems_bdbuf_release_modified (buffer);                       
40022500:	7f ff d0 29 	call  400165a4 <rtems_bdbuf_release_modified>  
40022504:	01 00 00 00 	nop                                            
int                                                                   
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,             
                                bool              modified)           
{                                                                     
  rtems_status_code sc;                                               
  int               rc = 0;                                           
40022508:	80 a0 00 08 	cmp  %g0, %o0                                  
4002250c:	b0 60 20 00 	subx  %g0, 0, %i0                              
#endif                                                                
    rc = EIO;                                                         
  }                                                                   
                                                                      
  return rc;                                                          
}                                                                     
40022510:	b0 0e 20 05 	and  %i0, 5, %i0                               
40022514:	81 c7 e0 08 	ret                                            
40022518:	81 e8 00 00 	restore                                        
            buffer->block, modified ? "(modified)" : "");             
                                                                      
  if (modified)                                                       
    sc = rtems_bdbuf_release_modified (buffer);                       
  else                                                                
    sc = rtems_bdbuf_release (buffer);                                
4002251c:	7f ff cf ea 	call  400164c4 <rtems_bdbuf_release>           
40022520:	01 00 00 00 	nop                                            
int                                                                   
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,             
                                bool              modified)           
{                                                                     
  rtems_status_code sc;                                               
  int               rc = 0;                                           
40022524:	80 a0 00 08 	cmp  %g0, %o0                                  
40022528:	b0 60 20 00 	subx  %g0, 0, %i0                              
#endif                                                                
    rc = EIO;                                                         
  }                                                                   
                                                                      
  return rc;                                                          
}                                                                     
4002252c:	b0 0e 20 05 	and  %i0, 5, %i0                               
40022530:	81 c7 e0 08 	ret                                            
40022534:	81 e8 00 00 	restore                                        
{                                                                     
  rtems_status_code sc;                                               
  int               rc = 0;                                           
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))               
    printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n",
40022538:	17 10 00 e0 	sethi  %hi(0x40038000), %o3                    <== NOT EXECUTED
4002253c:	10 bf ff eb 	b  400224e8 <rtems_rfs_buffer_bdbuf_release+0x30><== NOT EXECUTED
40022540:	96 12 e3 20 	or  %o3, 0x320, %o3	! 40038320 <rtems_rfs_rtems_file_handlers+0x2c><== NOT EXECUTED
40022544:	40 02 27 e8 	call  400ac4e4 <__end+0x61b94>                 <== NOT EXECUTED
40022548:	40 02 27 54 	call  400ac298 <__end+0x61948>                 <== NOT EXECUTED
4002254c:	40 02 27 48 	call  400ac26c <__end+0x6191c>                 <== NOT EXECUTED
40022550:	40 02 27 3c 	call  400ac240 <__end+0x618f0>                 <== NOT EXECUTED
40022554:	40 02 27 30 	call  400ac214 <__end+0x618c4>                 <== NOT EXECUTED
40022558:	40 02 27 28 	call  400ac1f8 <__end+0x618a8>                 <== NOT EXECUTED
4002255c:	40 02 27 1c 	call  400ac1cc <__end+0x6187c>                 <== NOT EXECUTED
40022560:	40 02 27 10 	call  400ac1a0 <__end+0x61850>                 <== NOT EXECUTED
40022564:	40 02 27 04 	call  400ac174 <__end+0x61824>                 <== NOT EXECUTED
40022568:	40 02 26 fc 	call  400ac158 <__end+0x61808>                 <== NOT EXECUTED
4002256c:	40 02 26 f0 	call  400ac12c <__end+0x617dc>                 <== NOT EXECUTED
40022570:	40 02 26 e4 	call  400ac100 <__end+0x617b0>                 <== NOT EXECUTED
40022574:	40 02 26 d8 	call  400ac0d4 <__end+0x61784>                 <== NOT EXECUTED
                                                                      

4001ccf0 <rtems_rfs_buffer_close>: return 0; } int rtems_rfs_buffer_close (rtems_rfs_file_system* fs) {
4001ccf0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rc = 0;                                                         
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))                 
4001ccf4:	90 10 20 00 	clr  %o0                                       
4001ccf8:	92 10 20 10 	mov  0x10, %o1                                 
4001ccfc:	7f ff dc 6a 	call  40013ea4 <rtems_rfs_trace>               
4001cd00:	ba 10 00 18 	mov  %i0, %i5                                  
4001cd04:	80 8a 20 ff 	btst  0xff, %o0                                
4001cd08:	12 80 00 15 	bne  4001cd5c <rtems_rfs_buffer_close+0x6c>    <== NEVER TAKEN
4001cd0c:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    
                                                                      
  /*                                                                  
   * 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));
4001cd10:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
4001cd14:	90 10 00 1d 	mov  %i5, %o0                                  
4001cd18:	7f ff ff ad 	call  4001cbcc <rtems_rfs_buffer_setblksize>   
4001cd1c:	d2 00 60 20 	ld  [ %g1 + 0x20 ], %o1                        
                                                                      
  if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))     
4001cd20:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001cd24:	04 80 00 07 	ble  4001cd40 <rtems_rfs_buffer_close+0x50>    <== ALWAYS TAKEN
4001cd28:	90 10 20 00 	clr  %o0                                       
4001cd2c:	7f ff dc 5e 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001cd30:	92 10 20 10 	mov  0x10, %o1                                 <== NOT EXECUTED
4001cd34:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001cd38:	12 80 00 1f 	bne  4001cdb4 <rtems_rfs_buffer_close+0xc4>    <== NOT EXECUTED
4001cd3c:	01 00 00 00 	nop                                            <== NOT EXECUTED
    printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n",
            rc, strerror (rc));                                       
                                                                      
  if (close (fs->device) < 0)                                         
4001cd40:	7f ff ac 60 	call  40007ec0 <close>                         
4001cd44:	d0 07 60 0c 	ld  [ %i5 + 0xc ], %o0                         
4001cd48:	80 a2 20 00 	cmp  %o0, 0                                    
4001cd4c:	06 80 00 08 	bl  4001cd6c <rtems_rfs_buffer_close+0x7c>     <== NEVER TAKEN
4001cd50:	01 00 00 00 	nop                                            
      printf ("rtems-rfs: buffer-close: file close failed: %d: %s\n", 
              rc, strerror (rc));                                     
  }                                                                   
                                                                      
  return rc;                                                          
}                                                                     
4001cd54:	81 c7 e0 08 	ret                                            
4001cd58:	81 e8 00 00 	restore                                        
rtems_rfs_buffer_close (rtems_rfs_file_system* fs)                    
{                                                                     
  int rc = 0;                                                         
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))                 
    printf ("rtems-rfs: buffer-close: closing\n");                    
4001cd5c:	40 00 1d 20 	call  400241dc <puts>                          <== NOT EXECUTED
4001cd60:	90 12 21 98 	or  %o0, 0x198, %o0                            <== 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));
4001cd64:	10 bf ff ec 	b  4001cd14 <rtems_rfs_buffer_close+0x24>      <== NOT EXECUTED
4001cd68:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        <== NOT EXECUTED
    printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n",
            rc, strerror (rc));                                       
                                                                      
  if (close (fs->device) < 0)                                         
  {                                                                   
    rc = errno;                                                       
4001cd6c:	40 00 16 f3 	call  40022938 <__errno>                       <== NOT EXECUTED
4001cd70:	01 00 00 00 	nop                                            <== NOT EXECUTED
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))               
4001cd74:	92 10 20 10 	mov  0x10, %o1	! 10 <PROM_START+0x10>          <== NOT EXECUTED
    printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n",
            rc, strerror (rc));                                       
                                                                      
  if (close (fs->device) < 0)                                         
  {                                                                   
    rc = errno;                                                       
4001cd78:	f0 02 00 00 	ld  [ %o0 ], %i0                               <== NOT EXECUTED
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))               
4001cd7c:	7f ff dc 4a 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001cd80:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001cd84:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001cd88:	02 80 00 09 	be  4001cdac <rtems_rfs_buffer_close+0xbc>     <== NOT EXECUTED
4001cd8c:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: buffer-close: file close failed: %d: %s\n", 
4001cd90:	40 00 20 c5 	call  400250a4 <strerror>                      <== NOT EXECUTED
4001cd94:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001cd98:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
4001cd9c:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
4001cda0:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
4001cda4:	40 00 1c 76 	call  40023f7c <printf>                        <== NOT EXECUTED
4001cda8:	90 12 22 00 	or  %o0, 0x200, %o0	! 40037200 <CSWTCH.2+0x610><== NOT EXECUTED
              rc, strerror (rc));                                     
  }                                                                   
                                                                      
  return rc;                                                          
}                                                                     
4001cdac:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001cdb0:	81 e8 00 00 	restore                                        <== NOT EXECUTED
   * all buffers.                                                     
   */                                                                 
  rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_media_block_size (fs));
                                                                      
  if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))     
    printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n",
4001cdb4:	40 00 20 bc 	call  400250a4 <strerror>                      <== NOT EXECUTED
4001cdb8:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001cdbc:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
4001cdc0:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
4001cdc4:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
4001cdc8:	40 00 1c 6d 	call  40023f7c <printf>                        <== NOT EXECUTED
4001cdcc:	90 12 21 c0 	or  %o0, 0x1c0, %o0	! 400371c0 <CSWTCH.2+0x5d0><== NOT EXECUTED
            rc, strerror (rc));                                       
                                                                      
  if (close (fs->device) < 0)                                         
4001cdd0:	7f ff ac 3c 	call  40007ec0 <close>                         <== NOT EXECUTED
4001cdd4:	d0 07 60 0c 	ld  [ %i5 + 0xc ], %o0                         <== NOT EXECUTED
4001cdd8:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4001cddc:	16 bf ff f4 	bge  4001cdac <rtems_rfs_buffer_close+0xbc>    <== NOT EXECUTED
4001cde0:	01 00 00 00 	nop                                            <== NOT EXECUTED
4001cde4:	30 bf ff e2 	b,a   4001cd6c <rtems_rfs_buffer_close+0x7c>   <== NOT EXECUTED
                                                                      

4001c438 <rtems_rfs_buffer_handle_release>: } int rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs, rtems_rfs_buffer_handle* handle) {
4001c438:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rc = 0;                                                         
                                                                      
  if (rtems_rfs_buffer_handle_has_block (handle))                     
4001c43c:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
4001c440:	80 a0 60 00 	cmp  %g1, 0                                    
4001c444:	02 80 00 13 	be  4001c490 <rtems_rfs_buffer_handle_release+0x58>
4001c448:	b8 10 20 00 	clr  %i4                                       
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))      
4001c44c:	90 10 20 00 	clr  %o0                                       
4001c450:	7f ff de 95 	call  40013ea4 <rtems_rfs_trace>               
4001c454:	92 10 22 00 	mov  0x200, %o1                                
4001c458:	80 8a 20 ff 	btst  0xff, %o0                                
4001c45c:	32 80 00 0f 	bne,a   4001c498 <rtems_rfs_buffer_handle_release+0x60><== NEVER TAKEN
4001c460:	c2 0e 40 00 	ldub  [ %i1 ], %g1                             <== 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)                           
4001c464:	d0 06 60 08 	ld  [ %i1 + 8 ], %o0                           
4001c468:	fa 02 20 30 	ld  [ %o0 + 0x30 ], %i5                        
4001c46c:	80 a7 60 00 	cmp  %i5, 0                                    
4001c470:	04 80 00 05 	ble  4001c484 <rtems_rfs_buffer_handle_release+0x4c><== NEVER TAKEN
4001c474:	01 00 00 00 	nop                                            
      rtems_rfs_buffer_refs_down (handle);                            
4001c478:	ba 07 7f ff 	add  %i5, -1, %i5                              
4001c47c:	fa 22 20 30 	st  %i5, [ %o0 + 0x30 ]                        
                                                                      
    if (rtems_rfs_buffer_refs (handle) == 0)                          
4001c480:	80 a7 60 00 	cmp  %i5, 0                                    
4001c484:	02 80 00 15 	be  4001c4d8 <rtems_rfs_buffer_handle_release+0xa0>
4001c488:	b8 10 20 00 	clr  %i4                                       
          rtems_chain_append (&fs->release, rtems_rfs_buffer_link (handle));
          fs->release_count++;                                        
        }                                                             
      }                                                               
    }                                                                 
    handle->buffer = NULL;                                            
4001c48c:	c0 26 60 08 	clr  [ %i1 + 8 ]                               
  }                                                                   
                                                                      
  return rc;                                                          
}                                                                     
4001c490:	81 c7 e0 08 	ret                                            
4001c494:	91 e8 00 1c 	restore  %g0, %i4, %o0                         
  int rc = 0;                                                         
                                                                      
  if (rtems_rfs_buffer_handle_has_block (handle))                     
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))      
      printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n",
4001c498:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4001c49c:	12 80 00 28 	bne  4001c53c <rtems_rfs_buffer_handle_release+0x104><== NOT EXECUTED
4001c4a0:	d2 06 60 04 	ld  [ %i1 + 4 ], %o1                           <== 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" : "");
4001c4a4:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           <== NOT EXECUTED
  int rc = 0;                                                         
                                                                      
  if (rtems_rfs_buffer_handle_has_block (handle))                     
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))      
      printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n",
4001c4a8:	15 10 00 d0 	sethi  %hi(0x40034000), %o2                    <== 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" : "");
4001c4ac:	d6 00 60 30 	ld  [ %g1 + 0x30 ], %o3                        <== NOT EXECUTED
  int rc = 0;                                                         
                                                                      
  if (rtems_rfs_buffer_handle_has_block (handle))                     
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))      
      printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n",
4001c4b0:	80 a2 e0 00 	cmp  %o3, 0                                    <== NOT EXECUTED
4001c4b4:	12 80 00 28 	bne  4001c554 <rtems_rfs_buffer_handle_release+0x11c><== NOT EXECUTED
4001c4b8:	94 12 a2 10 	or  %o2, 0x210, %o2                            <== NOT EXECUTED
4001c4bc:	19 10 00 db 	sethi  %hi(0x40036c00), %o4                    <== NOT EXECUTED
4001c4c0:	98 13 21 90 	or  %o4, 0x190, %o4	! 40036d90 <CSWTCH.2+0x1a0><== NOT EXECUTED
4001c4c4:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
4001c4c8:	40 00 1e ad 	call  40023f7c <printf>                        <== NOT EXECUTED
4001c4cc:	90 12 21 a0 	or  %o0, 0x1a0, %o0	! 40036da0 <CSWTCH.2+0x1b0><== 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)                           
4001c4d0:	10 bf ff e6 	b  4001c468 <rtems_rfs_buffer_handle_release+0x30><== NOT EXECUTED
4001c4d4:	d0 06 60 08 	ld  [ %i1 + 8 ], %o0                           <== NOT EXECUTED
4001c4d8:	7f ff f3 61 	call  4001925c <_Chain_Extract>                
4001c4dc:	01 00 00 00 	nop                                            
      rtems_rfs_buffer_refs_down (handle);                            
                                                                      
    if (rtems_rfs_buffer_refs (handle) == 0)                          
    {                                                                 
      rtems_chain_extract (rtems_rfs_buffer_link (handle));           
      fs->buffers_count--;                                            
4001c4e0:	c4 06 20 50 	ld  [ %i0 + 0x50 ], %g2                        
                                                                      
      if (rtems_rfs_fs_no_local_cache (fs))                           
4001c4e4:	c2 06 00 00 	ld  [ %i0 ], %g1                               
      rtems_rfs_buffer_refs_down (handle);                            
                                                                      
    if (rtems_rfs_buffer_refs (handle) == 0)                          
    {                                                                 
      rtems_chain_extract (rtems_rfs_buffer_link (handle));           
      fs->buffers_count--;                                            
4001c4e8:	84 00 bf ff 	add  %g2, -1, %g2                              
                                                                      
      if (rtems_rfs_fs_no_local_cache (fs))                           
4001c4ec:	80 88 60 02 	btst  2, %g1                                   
4001c4f0:	12 80 00 1c 	bne  4001c560 <rtems_rfs_buffer_handle_release+0x128>
4001c4f4:	c4 26 20 50 	st  %g2, [ %i0 + 0x50 ]                        
         * 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 +                                      
4001c4f8:	c6 06 20 70 	ld  [ %i0 + 0x70 ], %g3                        
4001c4fc:	c4 06 20 60 	ld  [ %i0 + 0x60 ], %g2                        
4001c500:	c2 06 20 40 	ld  [ %i0 + 0x40 ], %g1                        
4001c504:	84 00 c0 02 	add  %g3, %g2, %g2                             
4001c508:	80 a0 80 01 	cmp  %g2, %g1                                  
4001c50c:	1a 80 00 21 	bcc  4001c590 <rtems_rfs_buffer_handle_release+0x158>
4001c510:	b8 10 00 1d 	mov  %i5, %i4                                  
          }                                                           
          buffer->user = (void*) 0;                                   
          rc = rtems_rfs_buffer_io_release (buffer, modified);        
        }                                                             
                                                                      
        if (rtems_rfs_buffer_dirty (handle))                          
4001c514:	c2 0e 40 00 	ldub  [ %i1 ], %g1                             
4001c518:	80 a0 60 00 	cmp  %g1, 0                                    
4001c51c:	02 80 00 17 	be  4001c578 <rtems_rfs_buffer_handle_release+0x140>
4001c520:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           
RTEMS_INLINE_ROUTINE void rtems_chain_append(                         
  rtems_chain_control *the_chain,                                     
  rtems_chain_node    *the_node                                       
)                                                                     
{                                                                     
  _Chain_Append( the_chain, the_node );                               
4001c524:	7f ff c4 c2 	call  4000d82c <_Chain_Append>                 
4001c528:	90 06 20 64 	add  %i0, 0x64, %o0                            
        {                                                             
          rtems_chain_append (&fs->release_modified,                  
                              rtems_rfs_buffer_link (handle));        
          fs->release_modified_count++;                               
4001c52c:	c2 06 20 70 	ld  [ %i0 + 0x70 ], %g1                        
4001c530:	82 00 60 01 	inc  %g1                                       
4001c534:	10 bf ff d6 	b  4001c48c <rtems_rfs_buffer_handle_release+0x54>
4001c538:	c2 26 20 70 	st  %g1, [ %i0 + 0x70 ]                        
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))      
      printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n",
              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" : "");
4001c53c:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           <== NOT EXECUTED
  int rc = 0;                                                         
                                                                      
  if (rtems_rfs_buffer_handle_has_block (handle))                     
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))      
      printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n",
4001c540:	15 10 00 db 	sethi  %hi(0x40036c00), %o2                    <== 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" : "");
4001c544:	d6 00 60 30 	ld  [ %g1 + 0x30 ], %o3                        <== NOT EXECUTED
  int rc = 0;                                                         
                                                                      
  if (rtems_rfs_buffer_handle_has_block (handle))                     
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))      
      printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n",
4001c548:	80 a2 e0 00 	cmp  %o3, 0                                    <== NOT EXECUTED
4001c54c:	02 bf ff dc 	be  4001c4bc <rtems_rfs_buffer_handle_release+0x84><== NOT EXECUTED
4001c550:	94 12 a1 88 	or  %o2, 0x188, %o2                            <== NOT EXECUTED
4001c554:	19 10 00 d0 	sethi  %hi(0x40034000), %o4                    <== NOT EXECUTED
4001c558:	10 bf ff db 	b  4001c4c4 <rtems_rfs_buffer_handle_release+0x8c><== NOT EXECUTED
4001c55c:	98 13 22 10 	or  %o4, 0x210, %o4	! 40034210 <__FUNCTION__.6193+0x148><== 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;                             
4001c560:	d0 06 60 08 	ld  [ %i1 + 8 ], %o0                           
        rc = rtems_rfs_buffer_io_release (handle->buffer,             
4001c564:	d2 0e 40 00 	ldub  [ %i1 ], %o1                             
4001c568:	40 00 17 d4 	call  400224b8 <rtems_rfs_buffer_bdbuf_release>
4001c56c:	c0 22 20 34 	clr  [ %o0 + 0x34 ]                            
4001c570:	10 bf ff c7 	b  4001c48c <rtems_rfs_buffer_handle_release+0x54>
4001c574:	b8 10 00 08 	mov  %o0, %i4                                  
4001c578:	7f ff c4 ad 	call  4000d82c <_Chain_Append>                 
4001c57c:	90 06 20 54 	add  %i0, 0x54, %o0                            
          fs->release_modified_count++;                               
        }                                                             
        else                                                          
        {                                                             
          rtems_chain_append (&fs->release, rtems_rfs_buffer_link (handle));
          fs->release_count++;                                        
4001c580:	c2 06 20 60 	ld  [ %i0 + 0x60 ], %g1                        
4001c584:	82 00 60 01 	inc  %g1                                       
4001c588:	10 bf ff c1 	b  4001c48c <rtems_rfs_buffer_handle_release+0x54>
4001c58c:	c2 26 20 60 	st  %g1, [ %i0 + 0x60 ]                        
             fs->release_modified_count) >= fs->max_held_buffers)     
        {                                                             
          rtems_rfs_buffer* buffer;                                   
          bool              modified;                                 
                                                                      
          if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
4001c590:	90 10 20 00 	clr  %o0                                       
4001c594:	7f ff de 44 	call  40013ea4 <rtems_rfs_trace>               
4001c598:	92 10 22 00 	mov  0x200, %o1                                
4001c59c:	80 8a 20 ff 	btst  0xff, %o0                                
4001c5a0:	32 80 00 19 	bne,a   4001c604 <rtems_rfs_buffer_handle_release+0x1cc><== NEVER TAKEN
4001c5a4:	d2 06 20 70 	ld  [ %i0 + 0x70 ], %o1                        <== NOT EXECUTED
            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)         
4001c5a8:	c4 06 20 60 	ld  [ %i0 + 0x60 ], %g2                        
4001c5ac:	c2 06 20 70 	ld  [ %i0 + 0x70 ], %g1                        
4001c5b0:	80 a0 80 01 	cmp  %g2, %g1                                  
4001c5b4:	08 80 00 0d 	bleu  4001c5e8 <rtems_rfs_buffer_handle_release+0x1b0>
4001c5b8:	01 00 00 00 	nop                                            
 */                                                                   
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(               
  rtems_chain_control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Get( the_chain );                                     
4001c5bc:	7f ff c4 a7 	call  4000d858 <_Chain_Get>                    
4001c5c0:	90 06 20 54 	add  %i0, 0x54, %o0                            
          {                                                           
            buffer = (rtems_rfs_buffer*) rtems_chain_get (&fs->release);
            fs->release_count--;                                      
4001c5c4:	c2 06 20 60 	ld  [ %i0 + 0x60 ], %g1                        
            modified = false;                                         
4001c5c8:	92 10 20 00 	clr  %o1                                       
                    " %" PRIu32 "\n", fs->release_count + fs->release_modified_count);
                                                                      
          if (fs->release_count > fs->release_modified_count)         
          {                                                           
            buffer = (rtems_rfs_buffer*) rtems_chain_get (&fs->release);
            fs->release_count--;                                      
4001c5cc:	82 00 7f ff 	add  %g1, -1, %g1                              
4001c5d0:	c2 26 20 60 	st  %g1, [ %i0 + 0x60 ]                        
            buffer =                                                  
              (rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
            fs->release_modified_count--;                             
            modified = true;                                          
          }                                                           
          buffer->user = (void*) 0;                                   
4001c5d4:	c0 22 20 34 	clr  [ %o0 + 0x34 ]                            
          rc = rtems_rfs_buffer_io_release (buffer, modified);        
4001c5d8:	40 00 17 b8 	call  400224b8 <rtems_rfs_buffer_bdbuf_release>
4001c5dc:	92 0a 60 01 	and  %o1, 1, %o1                               
4001c5e0:	10 bf ff cd 	b  4001c514 <rtems_rfs_buffer_handle_release+0xdc>
4001c5e4:	b8 10 00 08 	mov  %o0, %i4                                  
4001c5e8:	7f ff c4 9c 	call  4000d858 <_Chain_Get>                    
4001c5ec:	90 06 20 64 	add  %i0, 0x64, %o0                            
          }                                                           
          else                                                        
          {                                                           
            buffer =                                                  
              (rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
            fs->release_modified_count--;                             
4001c5f0:	c2 06 20 70 	ld  [ %i0 + 0x70 ], %g1                        
            modified = true;                                          
4001c5f4:	92 10 20 01 	mov  1, %o1                                    
          }                                                           
          else                                                        
          {                                                           
            buffer =                                                  
              (rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
            fs->release_modified_count--;                             
4001c5f8:	82 00 7f ff 	add  %g1, -1, %g1                              
4001c5fc:	10 bf ff f6 	b  4001c5d4 <rtems_rfs_buffer_handle_release+0x19c>
4001c600:	c2 26 20 70 	st  %g1, [ %i0 + 0x70 ]                        
        {                                                             
          rtems_rfs_buffer* buffer;                                   
          bool              modified;                                 
                                                                      
          if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
            printf ("rtems-rfs: buffer-release: local cache overflow:"
4001c604:	c2 06 20 60 	ld  [ %i0 + 0x60 ], %g1                        <== NOT EXECUTED
4001c608:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
4001c60c:	92 02 40 01 	add  %o1, %g1, %o1                             <== NOT EXECUTED
4001c610:	40 00 1e 5b 	call  40023f7c <printf>                        <== NOT EXECUTED
4001c614:	90 12 21 d8 	or  %o0, 0x1d8, %o0                            <== NOT EXECUTED
                    " %" PRIu32 "\n", fs->release_count + fs->release_modified_count);
                                                                      
          if (fs->release_count > fs->release_modified_count)         
4001c618:	10 bf ff e5 	b  4001c5ac <rtems_rfs_buffer_handle_release+0x174><== NOT EXECUTED
4001c61c:	c4 06 20 60 	ld  [ %i0 + 0x60 ], %g2                        <== NOT EXECUTED
                                                                      

4001c620 <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) {
4001c620:	9d e3 bf a0 	save  %sp, -96, %sp                            
                                                                      
  /*                                                                  
   * 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))                     
4001c624:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
4001c628:	80 a0 60 00 	cmp  %g1, 0                                    
4001c62c:	02 80 00 17 	be  4001c688 <rtems_rfs_buffer_handle_request+0x68>
4001c630:	ba 10 00 18 	mov  %i0, %i5                                  
  {                                                                   
    /*                                                                
     * Treat block 0 as special to handle the loading of the super block.
     */                                                               
    if (block && (rtems_rfs_buffer_bnum (handle) == block))           
4001c634:	80 a6 a0 00 	cmp  %i2, 0                                    
4001c638:	02 80 00 06 	be  4001c650 <rtems_rfs_buffer_handle_request+0x30><== NEVER TAKEN
4001c63c:	90 10 20 00 	clr  %o0                                       
4001c640:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
4001c644:	80 a0 40 1a 	cmp  %g1, %i2                                  
4001c648:	02 80 00 40 	be  4001c748 <rtems_rfs_buffer_handle_request+0x128>
4001c64c:	01 00 00 00 	nop                                            
      return 0;                                                       
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))      
4001c650:	7f ff de 15 	call  40013ea4 <rtems_rfs_trace>               
4001c654:	92 10 21 00 	mov  0x100, %o1	! 100 <PROM_START+0x100>       
4001c658:	80 8a 20 ff 	btst  0xff, %o0                                
4001c65c:	32 80 00 3d 	bne,a   4001c750 <rtems_rfs_buffer_handle_request+0x130><== NEVER TAKEN
4001c660:	d2 06 60 04 	ld  [ %i1 + 4 ], %o1                           <== NOT EXECUTED
      printf ("rtems-rfs: buffer-request: handle has buffer: %" PRIu32 "\n",
              rtems_rfs_buffer_bnum (handle));                        
                                                                      
    rc = rtems_rfs_buffer_handle_release (fs, handle);                
4001c664:	90 10 00 1d 	mov  %i5, %o0                                  
4001c668:	7f ff ff 74 	call  4001c438 <rtems_rfs_buffer_handle_release>
4001c66c:	92 10 00 19 	mov  %i1, %o1                                  
    if (rc > 0)                                                       
4001c670:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001c674:	24 80 00 04 	ble,a   4001c684 <rtems_rfs_buffer_handle_request+0x64><== ALWAYS TAKEN
4001c678:	c0 2e 40 00 	clrb  [ %i1 ]                                  
    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;                                                           
}                                                                     
4001c67c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001c680:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
    rc = rtems_rfs_buffer_handle_release (fs, handle);                
    if (rc > 0)                                                       
      return rc;                                                      
    handle->dirty = false;                                            
    handle->bnum = 0;                                                 
4001c684:	c0 26 60 04 	clr  [ %i1 + 4 ]                               
  }                                                                   
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))        
4001c688:	90 10 20 00 	clr  %o0                                       
4001c68c:	7f ff de 06 	call  40013ea4 <rtems_rfs_trace>               
4001c690:	92 10 21 00 	mov  0x100, %o1                                
4001c694:	80 8a 20 ff 	btst  0xff, %o0                                
4001c698:	32 80 00 5b 	bne,a   4001c804 <rtems_rfs_buffer_handle_request+0x1e4><== NEVER TAKEN
4001c69c:	92 10 00 1a 	mov  %i2, %o1                                  <== 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)                                              
4001c6a0:	c2 07 60 50 	ld  [ %i5 + 0x50 ], %g1                        
4001c6a4:	80 a0 60 00 	cmp  %g1, 0                                    
4001c6a8:	12 80 00 44 	bne  4001c7b8 <rtems_rfs_buffer_handle_request+0x198>
4001c6ac:	90 07 60 44 	add  %i5, 0x44, %o0                            
4001c6b0:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
  /*                                                                  
   * 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) &&                            
4001c6b4:	c4 07 40 00 	ld  [ %i5 ], %g2                               
4001c6b8:	80 88 a0 02 	btst  2, %g2                                   
4001c6bc:	02 80 00 2a 	be  4001c764 <rtems_rfs_buffer_handle_request+0x144>
4001c6c0:	80 a0 60 00 	cmp  %g1, 0                                    
  }                                                                   
                                                                      
  /*                                                                  
   * If not located we request the buffer from the I/O layer.         
   */                                                                 
  if (!rtems_rfs_buffer_handle_has_block (handle))                    
4001c6c4:	02 80 00 65 	be  4001c858 <rtems_rfs_buffer_handle_request+0x238><== ALWAYS TAKEN
4001c6c8:	90 10 00 1d 	mov  %i5, %o0                                  
  }                                                                   
                                                                      
  /*                                                                  
   * Increase the reference count of the buffer.                      
   */                                                                 
  rtems_rfs_buffer_refs_up (handle);                                  
4001c6cc:	c4 00 60 30 	ld  [ %g1 + 0x30 ], %g2                        
RTEMS_INLINE_ROUTINE void rtems_chain_append(                         
  rtems_chain_control *the_chain,                                     
  rtems_chain_node    *the_node                                       
)                                                                     
{                                                                     
  _Chain_Append( the_chain, the_node );                               
4001c6d0:	92 10 00 01 	mov  %g1, %o1                                  
4001c6d4:	84 00 a0 01 	inc  %g2                                       
4001c6d8:	90 07 60 44 	add  %i5, 0x44, %o0                            
4001c6dc:	7f ff c4 54 	call  4000d82c <_Chain_Append>                 
4001c6e0:	c4 20 60 30 	st  %g2, [ %g1 + 0x30 ]                        
  rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle));  
  fs->buffers_count++;                                                
4001c6e4:	c4 07 60 50 	ld  [ %i5 + 0x50 ], %g2                        
                                                                      
  handle->buffer->user = (void*) ((intptr_t) block);                  
4001c6e8:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
  /*                                                                  
   * 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++;                                                
4001c6ec:	84 00 a0 01 	inc  %g2                                       
4001c6f0:	c4 27 60 50 	st  %g2, [ %i5 + 0x50 ]                        
                                                                      
  handle->buffer->user = (void*) ((intptr_t) block);                  
4001c6f4:	f4 20 60 34 	st  %i2, [ %g1 + 0x34 ]                        
  handle->bnum = block;                                               
4001c6f8:	f4 26 60 04 	st  %i2, [ %i1 + 4 ]                           
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))        
4001c6fc:	90 10 20 00 	clr  %o0                                       
4001c700:	7f ff dd e9 	call  40013ea4 <rtems_rfs_trace>               
4001c704:	92 10 21 00 	mov  0x100, %o1                                
4001c708:	80 8a 20 ff 	btst  0xff, %o0                                
4001c70c:	02 80 00 0f 	be  4001c748 <rtems_rfs_buffer_handle_request+0x128><== ALWAYS TAKEN
4001c710:	80 a6 e0 00 	cmp  %i3, 0                                    
    printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
4001c714:	02 80 00 41 	be  4001c818 <rtems_rfs_buffer_handle_request+0x1f8><== NOT EXECUTED
4001c718:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           <== NOT EXECUTED
            block, read ? "read" : "get", handle->buffer->block,      
            handle->buffer->references);                              
                                                                      
  return 0;                                                           
4001c71c:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
                                                                      
  handle->buffer->user = (void*) ((intptr_t) block);                  
  handle->bnum = block;                                               
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))        
    printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
4001c720:	d6 00 60 18 	ld  [ %g1 + 0x18 ], %o3                        <== NOT EXECUTED
4001c724:	d8 00 60 30 	ld  [ %g1 + 0x30 ], %o4                        <== NOT EXECUTED
4001c728:	15 10 00 d8 	sethi  %hi(0x40036000), %o2                    <== NOT EXECUTED
4001c72c:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
4001c730:	94 12 a2 d0 	or  %o2, 0x2d0, %o2                            <== NOT EXECUTED
4001c734:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
4001c738:	40 00 1e 11 	call  40023f7c <printf>                        <== NOT EXECUTED
4001c73c:	90 12 22 e8 	or  %o0, 0x2e8, %o0                            <== NOT EXECUTED
4001c740:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001c744:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  {                                                                   
    /*                                                                
     * Treat block 0 as special to handle the loading of the super block.
     */                                                               
    if (block && (rtems_rfs_buffer_bnum (handle) == block))           
      return 0;                                                       
4001c748:	81 c7 e0 08 	ret                                            
4001c74c:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))      
      printf ("rtems-rfs: buffer-request: handle has buffer: %" PRIu32 "\n",
4001c750:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
4001c754:	40 00 1e 0a 	call  40023f7c <printf>                        <== NOT EXECUTED
4001c758:	90 12 22 18 	or  %o0, 0x218, %o0	! 40036e18 <CSWTCH.2+0x228><== NOT EXECUTED
              rtems_rfs_buffer_bnum (handle));                        
                                                                      
    rc = rtems_rfs_buffer_handle_release (fs, handle);                
4001c75c:	10 bf ff c3 	b  4001c668 <rtems_rfs_buffer_handle_request+0x48><== NOT EXECUTED
4001c760:	90 10 00 1d 	mov  %i5, %o0                                  <== 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) &&                            
4001c764:	32 bf ff db 	bne,a   4001c6d0 <rtems_rfs_buffer_handle_request+0xb0>
4001c768:	c4 00 60 30 	ld  [ %g1 + 0x30 ], %g2                        
      !rtems_rfs_buffer_handle_has_block (handle))                    
  {                                                                   
    /*                                                                
     * Check the local cache of released buffers.                     
     */                                                               
    if (fs->release_count)                                            
4001c76c:	c2 07 60 60 	ld  [ %i5 + 0x60 ], %g1                        
4001c770:	80 a0 60 00 	cmp  %g1, 0                                    
4001c774:	12 80 00 5a 	bne  4001c8dc <rtems_rfs_buffer_handle_request+0x2bc>
4001c778:	90 07 60 54 	add  %i5, 0x54, %o0                            
      handle->buffer = rtems_rfs_scan_chain (&fs->release,            
                                             &fs->release_count,      
                                             block);                  
                                                                      
    if (!rtems_rfs_buffer_handle_has_block (handle) &&                
4001c77c:	c2 07 60 70 	ld  [ %i5 + 0x70 ], %g1                        
4001c780:	80 a0 60 00 	cmp  %g1, 0                                    
4001c784:	02 80 00 35 	be  4001c858 <rtems_rfs_buffer_handle_request+0x238>
4001c788:	90 10 00 1d 	mov  %i5, %o0                                  
        fs->release_modified_count)                                   
    {                                                                 
      handle->buffer = rtems_rfs_scan_chain (&fs->release_modified,   
4001c78c:	90 07 60 64 	add  %i5, 0x64, %o0                            
4001c790:	92 07 60 70 	add  %i5, 0x70, %o1                            
4001c794:	7f ff fe e1 	call  4001c318 <rtems_rfs_scan_chain>          
4001c798:	94 10 00 1a 	mov  %i2, %o2                                  
4001c79c:	d0 26 60 08 	st  %o0, [ %i1 + 8 ]                           
                                             &fs->release_modified_count,
                                             block);                  
      /*                                                              
       * If we found a buffer retain the dirty buffer state.          
       */                                                             
      if (rtems_rfs_buffer_handle_has_block (handle))                 
4001c7a0:	80 a2 20 00 	cmp  %o0, 0                                    
4001c7a4:	02 80 00 2c 	be  4001c854 <rtems_rfs_buffer_handle_request+0x234>
4001c7a8:	82 10 00 08 	mov  %o0, %g1                                  
        rtems_rfs_buffer_mark_dirty (handle);                         
4001c7ac:	84 10 20 01 	mov  1, %g2                                    
4001c7b0:	10 bf ff c7 	b  4001c6cc <rtems_rfs_buffer_handle_request+0xac>
4001c7b4:	c4 2e 40 00 	stb  %g2, [ %i1 ]                              
  if (fs->buffers_count)                                              
  {                                                                   
    /*                                                                
     * Check the active buffer list for shared buffers.               
     */                                                               
    handle->buffer = rtems_rfs_scan_chain (&fs->buffers,              
4001c7b8:	92 07 60 50 	add  %i5, 0x50, %o1                            
4001c7bc:	7f ff fe d7 	call  4001c318 <rtems_rfs_scan_chain>          
4001c7c0:	94 10 00 1a 	mov  %i2, %o2                                  
                                           &fs->buffers_count,        
                                           block);                    
    if (rtems_rfs_buffer_handle_has_block (handle) &&                 
4001c7c4:	80 a2 20 00 	cmp  %o0, 0                                    
4001c7c8:	02 80 00 1f 	be  4001c844 <rtems_rfs_buffer_handle_request+0x224>
4001c7cc:	d0 26 60 08 	st  %o0, [ %i1 + 8 ]                           
        rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))      
4001c7d0:	90 10 20 00 	clr  %o0                                       
4001c7d4:	7f ff dd b4 	call  40013ea4 <rtems_rfs_trace>               
4001c7d8:	92 10 21 00 	mov  0x100, %o1                                
     * Check the active buffer list for shared buffers.               
     */                                                               
    handle->buffer = rtems_rfs_scan_chain (&fs->buffers,              
                                           &fs->buffers_count,        
                                           block);                    
    if (rtems_rfs_buffer_handle_has_block (handle) &&                 
4001c7dc:	80 8a 20 ff 	btst  0xff, %o0                                
4001c7e0:	02 bf ff b5 	be  4001c6b4 <rtems_rfs_buffer_handle_request+0x94><== ALWAYS TAKEN
4001c7e4:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
        rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))      
      printf ("rtems-rfs: buffer-request: buffer shared: refs: %d\n", 
4001c7e8:	d2 00 60 30 	ld  [ %g1 + 0x30 ], %o1                        <== NOT EXECUTED
4001c7ec:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
4001c7f0:	92 02 60 01 	inc  %o1                                       <== NOT EXECUTED
4001c7f4:	40 00 1d e2 	call  40023f7c <printf>                        <== NOT EXECUTED
4001c7f8:	90 12 22 78 	or  %o0, 0x278, %o0                            <== NOT EXECUTED
4001c7fc:	10 bf ff ae 	b  4001c6b4 <rtems_rfs_buffer_handle_request+0x94><== NOT EXECUTED
4001c800:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           <== NOT EXECUTED
    handle->dirty = false;                                            
    handle->bnum = 0;                                                 
  }                                                                   
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))        
    printf ("rtems-rfs: buffer-request: block=%" PRIu32 "\n", block); 
4001c804:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
4001c808:	40 00 1d dd 	call  40023f7c <printf>                        <== NOT EXECUTED
4001c80c:	90 12 22 50 	or  %o0, 0x250, %o0	! 40036e50 <CSWTCH.2+0x260><== 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)                                              
4001c810:	10 bf ff a5 	b  4001c6a4 <rtems_rfs_buffer_handle_request+0x84><== NOT EXECUTED
4001c814:	c2 07 60 50 	ld  [ %i5 + 0x50 ], %g1                        <== NOT EXECUTED
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))        
    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;                                                           
4001c818:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
                                                                      
  handle->buffer->user = (void*) ((intptr_t) block);                  
  handle->bnum = block;                                               
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))        
    printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
4001c81c:	d6 00 60 18 	ld  [ %g1 + 0x18 ], %o3                        <== NOT EXECUTED
4001c820:	d8 00 60 30 	ld  [ %g1 + 0x30 ], %o4                        <== NOT EXECUTED
4001c824:	15 10 00 db 	sethi  %hi(0x40036c00), %o2                    <== NOT EXECUTED
4001c828:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
4001c82c:	94 12 a2 10 	or  %o2, 0x210, %o2                            <== NOT EXECUTED
4001c830:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
4001c834:	40 00 1d d2 	call  40023f7c <printf>                        <== NOT EXECUTED
4001c838:	90 12 22 e8 	or  %o0, 0x2e8, %o0                            <== NOT EXECUTED
4001c83c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001c840:	81 e8 00 00 	restore                                        <== 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) &&                            
4001c844:	c2 07 40 00 	ld  [ %i5 ], %g1                               
4001c848:	80 88 60 02 	btst  2, %g1                                   
4001c84c:	22 bf ff c9 	be,a   4001c770 <rtems_rfs_buffer_handle_request+0x150>
4001c850:	c2 07 60 60 	ld  [ %i5 + 0x60 ], %g1                        
  /*                                                                  
   * If not located we request the buffer from the I/O layer.         
   */                                                                 
  if (!rtems_rfs_buffer_handle_has_block (handle))                    
  {                                                                   
    rc = rtems_rfs_buffer_io_request (fs, block, read, &handle->buffer);
4001c854:	90 10 00 1d 	mov  %i5, %o0                                  
4001c858:	92 10 00 1a 	mov  %i2, %o1                                  
4001c85c:	94 10 00 1b 	mov  %i3, %o2                                  
4001c860:	40 00 17 02 	call  40022468 <rtems_rfs_buffer_bdbuf_request>
4001c864:	96 06 60 08 	add  %i1, 8, %o3                               
                                                                      
    if (rc > 0)                                                       
4001c868:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001c86c:	04 80 00 16 	ble  4001c8c4 <rtems_rfs_buffer_handle_request+0x2a4><== ALWAYS TAKEN
4001c870:	90 10 20 00 	clr  %o0                                       
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))    
4001c874:	7f ff dd 8c 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001c878:	92 10 21 00 	mov  0x100, %o1                                <== NOT EXECUTED
4001c87c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001c880:	02 bf ff 7f 	be  4001c67c <rtems_rfs_buffer_handle_request+0x5c><== NOT EXECUTED
4001c884:	80 a6 e0 00 	cmp  %i3, 0                                    <== NOT EXECUTED
        printf ("rtems-rfs: buffer-request: block=%" PRIu32 ": bdbuf-%s: %d: %s\n",
4001c888:	02 80 00 13 	be  4001c8d4 <rtems_rfs_buffer_handle_request+0x2b4><== NOT EXECUTED
4001c88c:	3b 10 00 db 	sethi  %hi(0x40036c00), %i5                    <== NOT EXECUTED
4001c890:	3b 10 00 d8 	sethi  %hi(0x40036000), %i5                    <== NOT EXECUTED
4001c894:	ba 17 62 d0 	or  %i5, 0x2d0, %i5	! 400362d0 <rtems_rfs_rtems_eval_config+0x2d0><== NOT EXECUTED
4001c898:	40 00 22 03 	call  400250a4 <strerror>                      <== NOT EXECUTED
4001c89c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001c8a0:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
4001c8a4:	98 10 00 08 	mov  %o0, %o4                                  <== NOT EXECUTED
4001c8a8:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
4001c8ac:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
4001c8b0:	96 10 00 18 	mov  %i0, %o3                                  <== NOT EXECUTED
4001c8b4:	40 00 1d b2 	call  40023f7c <printf>                        <== NOT EXECUTED
4001c8b8:	90 12 22 b0 	or  %o0, 0x2b0, %o0                            <== NOT EXECUTED
4001c8bc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001c8c0:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                block, read ? "read" : "get", rc, strerror (rc));     
      return rc;                                                      
    }                                                                 
                                                                      
    rtems_chain_set_off_chain (rtems_rfs_buffer_link(handle));        
4001c8c4:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
4001c8c8:	c0 20 60 04 	clr  [ %g1 + 4 ]                               
4001c8cc:	10 bf ff 80 	b  4001c6cc <rtems_rfs_buffer_handle_request+0xac>
4001c8d0:	c0 20 40 00 	clr  [ %g1 ]                                   
    rc = rtems_rfs_buffer_io_request (fs, block, read, &handle->buffer);
                                                                      
    if (rc > 0)                                                       
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))    
        printf ("rtems-rfs: buffer-request: block=%" PRIu32 ": bdbuf-%s: %d: %s\n",
4001c8d4:	10 bf ff f1 	b  4001c898 <rtems_rfs_buffer_handle_request+0x278><== NOT EXECUTED
4001c8d8:	ba 17 62 10 	or  %i5, 0x210, %i5                            <== NOT EXECUTED
  {                                                                   
    /*                                                                
     * Check the local cache of released buffers.                     
     */                                                               
    if (fs->release_count)                                            
      handle->buffer = rtems_rfs_scan_chain (&fs->release,            
4001c8dc:	92 07 60 60 	add  %i5, 0x60, %o1                            
4001c8e0:	7f ff fe 8e 	call  4001c318 <rtems_rfs_scan_chain>          
4001c8e4:	94 10 00 1a 	mov  %i2, %o2                                  
4001c8e8:	d0 26 60 08 	st  %o0, [ %i1 + 8 ]                           
                                             &fs->release_count,      
                                             block);                  
                                                                      
    if (!rtems_rfs_buffer_handle_has_block (handle) &&                
4001c8ec:	80 a2 20 00 	cmp  %o0, 0                                    
4001c8f0:	12 bf ff 77 	bne  4001c6cc <rtems_rfs_buffer_handle_request+0xac>
4001c8f4:	82 10 00 08 	mov  %o0, %g1                                  
4001c8f8:	10 bf ff a2 	b  4001c780 <rtems_rfs_buffer_handle_request+0x160>
4001c8fc:	c2 07 60 70 	ld  [ %i5 + 0x70 ], %g1                        
                                                                      

4001c900 <rtems_rfs_buffer_open>: return rc; } int rtems_rfs_buffer_open (const char* name, rtems_rfs_file_system* fs) {
4001c900:	9d e3 bf 58 	save  %sp, -168, %sp                           
  struct stat st;                                                     
#if RTEMS_RFS_USE_LIBBLOCK                                            
  int rv;                                                             
#endif                                                                
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))                  
4001c904:	90 10 20 00 	clr  %o0                                       
4001c908:	92 10 20 20 	mov  0x20, %o1                                 
4001c90c:	7f ff dd 66 	call  40013ea4 <rtems_rfs_trace>               
4001c910:	ba 10 00 18 	mov  %i0, %i5                                  
4001c914:	80 8a 20 ff 	btst  0xff, %o0                                
4001c918:	12 80 00 1b 	bne  4001c984 <rtems_rfs_buffer_open+0x84>     <== NEVER TAKEN
4001c91c:	92 10 00 18 	mov  %i0, %o1                                  
    printf ("rtems-rfs: buffer-open: opening: %s\n", name);           
                                                                      
  fs->device = open (name, O_RDWR);                                   
4001c920:	90 10 00 1d 	mov  %i5, %o0                                  
4001c924:	7f ff b1 4e 	call  40008e5c <open>                          
4001c928:	92 10 20 02 	mov  2, %o1                                    
  if (fs->device < 0)                                                 
4001c92c:	80 a2 20 00 	cmp  %o0, 0                                    
4001c930:	06 80 00 1e 	bl  4001c9a8 <rtems_rfs_buffer_open+0xa8>      <== NEVER TAKEN
4001c934:	d0 26 60 0c 	st  %o0, [ %i1 + 0xc ]                         
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))                
      printf ("rtems-rfs: buffer-open: cannot open file\n");          
    return ENXIO;                                                     
  }                                                                   
                                                                      
  if (fstat (fs->device, &st) < 0)                                    
4001c938:	7f ff ad ae 	call  40007ff0 <fstat>                         
4001c93c:	92 07 bf b8 	add  %fp, -72, %o1                             
4001c940:	80 a2 20 00 	cmp  %o0, 0                                    
4001c944:	06 80 00 3b 	bl  4001ca30 <rtems_rfs_buffer_open+0x130>     <== NEVER TAKEN
4001c948:	c4 07 bf c4 	ld  [ %fp + -60 ], %g2                         
                                                                      
#if RTEMS_RFS_USE_LIBBLOCK                                            
  /*                                                                  
   * Is the device a block device ?                                   
   */                                                                 
  if (!S_ISBLK (st.st_mode))                                          
4001c94c:	03 00 00 3c 	sethi  %hi(0xf000), %g1                        
4001c950:	84 08 80 01 	and  %g2, %g1, %g2                             
4001c954:	03 00 00 18 	sethi  %hi(0x6000), %g1                        
4001c958:	80 a0 80 01 	cmp  %g2, %g1                                  
4001c95c:	22 80 00 1e 	be,a   4001c9d4 <rtems_rfs_buffer_open+0xd4>   <== ALWAYS TAKEN
4001c960:	d0 06 60 0c 	ld  [ %i1 + 0xc ], %o0                         
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))                
4001c964:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001c968:	7f ff dd 4f 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001c96c:	92 10 20 08 	mov  8, %o1                                    <== NOT EXECUTED
4001c970:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001c974:	32 80 00 29 	bne,a   4001ca18 <rtems_rfs_buffer_open+0x118> <== NOT EXECUTED
4001c978:	b0 10 20 06 	mov  6, %i0                                    <== NOT EXECUTED
  fs->device = open (name, O_RDWR);                                   
  if (fs->device < 0)                                                 
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))                
      printf ("rtems-rfs: buffer-open: cannot open file\n");          
    return ENXIO;                                                     
4001c97c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001c980:	91 e8 20 06 	restore  %g0, 6, %o0                           <== NOT EXECUTED
#if RTEMS_RFS_USE_LIBBLOCK                                            
  int rv;                                                             
#endif                                                                
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))                  
    printf ("rtems-rfs: buffer-open: opening: %s\n", name);           
4001c984:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
4001c988:	40 00 1d 7d 	call  40023f7c <printf>                        <== NOT EXECUTED
4001c98c:	90 12 23 28 	or  %o0, 0x328, %o0	! 40036f28 <CSWTCH.2+0x338><== NOT EXECUTED
                                                                      
  fs->device = open (name, O_RDWR);                                   
4001c990:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001c994:	7f ff b1 32 	call  40008e5c <open>                          <== NOT EXECUTED
4001c998:	92 10 20 02 	mov  2, %o1                                    <== NOT EXECUTED
  if (fs->device < 0)                                                 
4001c99c:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4001c9a0:	16 bf ff e6 	bge  4001c938 <rtems_rfs_buffer_open+0x38>     <== NOT EXECUTED
4001c9a4:	d0 26 60 0c 	st  %o0, [ %i1 + 0xc ]                         <== NOT EXECUTED
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))                
4001c9a8:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001c9ac:	7f ff dd 3e 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001c9b0:	92 10 20 08 	mov  8, %o1                                    <== NOT EXECUTED
4001c9b4:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001c9b8:	02 bf ff f1 	be  4001c97c <rtems_rfs_buffer_open+0x7c>      <== NOT EXECUTED
4001c9bc:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
      printf ("rtems-rfs: buffer-open: cannot open file\n");          
    return ENXIO;                                                     
4001c9c0:	b0 10 20 06 	mov  6, %i0                                    <== NOT EXECUTED
                                                                      
  fs->device = open (name, O_RDWR);                                   
  if (fs->device < 0)                                                 
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))                
      printf ("rtems-rfs: buffer-open: cannot open file\n");          
4001c9c4:	40 00 1e 06 	call  400241dc <puts>                          <== NOT EXECUTED
4001c9c8:	90 12 23 50 	or  %o0, 0x350, %o0                            <== NOT EXECUTED
4001c9cc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001c9d0:	81 e8 00 00 	restore                                        <== NOT EXECUTED
static inline int rtems_disk_fd_get_disk_device(                      
  int fd,                                                             
  rtems_disk_device **dd_ptr                                          
)                                                                     
{                                                                     
  return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);                   
4001c9d4:	94 06 60 10 	add  %i1, 0x10, %o2                            
4001c9d8:	13 10 01 10 	sethi  %hi(0x40044000), %o1                    
4001c9dc:	7f ff ad db 	call  40008148 <ioctl>                         
4001c9e0:	92 12 62 09 	or  %o1, 0x209, %o1	! 40044209 <flashdisk_data+0xa961>
                                                                      
  /*                                                                  
   * Check that device is registred as a block device and lock it.    
   */                                                                 
  rv = rtems_disk_fd_get_disk_device (fs->device, &fs->disk);         
  if (rv != 0)                                                        
4001c9e4:	80 a2 20 00 	cmp  %o0, 0                                    
4001c9e8:	02 80 00 23 	be  4001ca74 <rtems_rfs_buffer_open+0x174>     <== ALWAYS TAKEN
4001c9ec:	90 10 20 00 	clr  %o0                                       
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))                
4001c9f0:	7f ff dd 2d 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001c9f4:	92 10 20 08 	mov  8, %o1                                    <== NOT EXECUTED
4001c9f8:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001c9fc:	02 bf ff e0 	be  4001c97c <rtems_rfs_buffer_open+0x7c>      <== NOT EXECUTED
4001ca00:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
      printf ("rtems-rfs: buffer-open: cannot obtain the disk\n");    
    return ENXIO;                                                     
4001ca04:	b0 10 20 06 	mov  6, %i0                                    <== NOT EXECUTED
   */                                                                 
  rv = rtems_disk_fd_get_disk_device (fs->device, &fs->disk);         
  if (rv != 0)                                                        
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))                
      printf ("rtems-rfs: buffer-open: cannot obtain the disk\n");    
4001ca08:	40 00 1d f5 	call  400241dc <puts>                          <== NOT EXECUTED
4001ca0c:	90 12 23 e8 	or  %o0, 0x3e8, %o0                            <== NOT EXECUTED
4001ca10:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001ca14:	81 e8 00 00 	restore                                        <== NOT EXECUTED
   * Is the device a block device ?                                   
   */                                                                 
  if (!S_ISBLK (st.st_mode))                                          
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))                
      printf ("rtems-rfs: buffer-open: '%s' is not a block device\n", name);
4001ca18:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
4001ca1c:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
4001ca20:	40 00 1d 57 	call  40023f7c <printf>                        <== NOT EXECUTED
4001ca24:	90 12 23 b0 	or  %o0, 0x3b0, %o0	! 40036fb0 <CSWTCH.2+0x3c0><== NOT EXECUTED
4001ca28:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001ca2c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    return ENXIO;                                                     
  }                                                                   
                                                                      
  if (fstat (fs->device, &st) < 0)                                    
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))                
4001ca30:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001ca34:	7f ff dd 1c 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001ca38:	92 10 20 08 	mov  8, %o1                                    <== NOT EXECUTED
4001ca3c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001ca40:	02 bf ff cf 	be  4001c97c <rtems_rfs_buffer_open+0x7c>      <== NOT EXECUTED
4001ca44:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",       
              name, strerror (errno));                                
4001ca48:	40 00 17 bc 	call  40022938 <__errno>                       <== NOT EXECUTED
4001ca4c:	b0 10 20 06 	mov  6, %i0	! 6 <PROM_START+0x6>               <== NOT EXECUTED
  }                                                                   
                                                                      
  if (fstat (fs->device, &st) < 0)                                    
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))                
      printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",       
4001ca50:	40 00 21 95 	call  400250a4 <strerror>                      <== NOT EXECUTED
4001ca54:	d0 02 00 00 	ld  [ %o0 ], %o0                               <== NOT EXECUTED
4001ca58:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
4001ca5c:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
4001ca60:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
4001ca64:	40 00 1d 46 	call  40023f7c <printf>                        <== NOT EXECUTED
4001ca68:	90 12 23 80 	or  %o0, 0x380, %o0	! 40036f80 <CSWTCH.2+0x390><== NOT EXECUTED
4001ca6c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001ca70:	81 e8 00 00 	restore                                        <== NOT EXECUTED
#else                                                                 
  fs->media_size = st.st_size;                                        
  strcat (fs->name, name);                                            
#endif                                                                
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))                  
4001ca74:	92 10 20 20 	mov  0x20, %o1                                 
4001ca78:	7f ff dd 0b 	call  40013ea4 <rtems_rfs_trace>               
4001ca7c:	b0 10 20 00 	clr  %i0                                       
4001ca80:	80 8a 20 ff 	btst  0xff, %o0                                
4001ca84:	32 80 00 04 	bne,a   4001ca94 <rtems_rfs_buffer_open+0x194> <== NEVER TAKEN
4001ca88:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1                        <== 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;                                                           
}                                                                     
4001ca8c:	81 c7 e0 08 	ret                                            
4001ca90:	81 e8 00 00 	restore                                        
  fs->media_size = st.st_size;                                        
  strcat (fs->name, name);                                            
#endif                                                                
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))                  
    printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n",
4001ca94:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
4001ca98:	d2 00 60 1c 	ld  [ %g1 + 0x1c ], %o1                        <== NOT EXECUTED
4001ca9c:	d4 00 60 20 	ld  [ %g1 + 0x20 ], %o2                        <== NOT EXECUTED
4001caa0:	40 00 1d 37 	call  40023f7c <printf>                        <== NOT EXECUTED
4001caa4:	90 12 20 18 	or  %o0, 0x18, %o0                             <== NOT EXECUTED
            rtems_rfs_fs_media_blocks (fs),                           
            rtems_rfs_fs_media_block_size (fs));                      
                                                                      
  return 0;                                                           
}                                                                     
4001caa8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001caac:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4001cbcc <rtems_rfs_buffer_setblksize>: return result; } int rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size) {
4001cbcc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rc;                                                             
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))            
4001cbd0:	90 10 20 00 	clr  %o0                                       
  return result;                                                      
}                                                                     
                                                                      
int                                                                   
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)  
{                                                                     
4001cbd4:	f2 27 a0 48 	st  %i1, [ %fp + 0x48 ]                        
  int rc;                                                             
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))            
4001cbd8:	7f ff dc b3 	call  40013ea4 <rtems_rfs_trace>               
4001cbdc:	92 10 24 00 	mov  0x400, %o1                                
4001cbe0:	80 8a 20 ff 	btst  0xff, %o0                                
4001cbe4:	12 80 00 21 	bne  4001cc68 <rtems_rfs_buffer_setblksize+0x9c><== NEVER TAKEN
4001cbe8:	d2 07 a0 48 	ld  [ %fp + 0x48 ], %o1                        
    printf ("rtems-rfs: buffer-setblksize: block size: %zu\n", size); 
                                                                      
  rc = rtems_rfs_buffers_release (fs);                                
4001cbec:	7f ff ff d7 	call  4001cb48 <rtems_rfs_buffers_release>     
4001cbf0:	90 10 00 18 	mov  %i0, %o0                                  
  if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
4001cbf4:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001cbf8:	04 80 00 07 	ble  4001cc14 <rtems_rfs_buffer_setblksize+0x48><== ALWAYS TAKEN
4001cbfc:	90 10 20 00 	clr  %o0                                       
4001cc00:	7f ff dc a9 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001cc04:	92 10 24 00 	mov  0x400, %o1                                <== NOT EXECUTED
4001cc08:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001cc0c:	12 80 00 20 	bne  4001cc8c <rtems_rfs_buffer_setblksize+0xc0><== NOT EXECUTED
4001cc10:	01 00 00 00 	nop                                            <== NOT EXECUTED
    printf ("rtems-rfs: buffer-setblksize: buffer release failed: %d: %s\n",
            rc, strerror (rc));                                       
                                                                      
  rc = rtems_rfs_buffer_sync (fs);                                    
4001cc14:	7f ff ff a7 	call  4001cab0 <rtems_rfs_buffer_sync>         
4001cc18:	90 10 00 18 	mov  %i0, %o0                                  
  if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
4001cc1c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001cc20:	04 80 00 07 	ble  4001cc3c <rtems_rfs_buffer_setblksize+0x70><== ALWAYS TAKEN
4001cc24:	90 10 20 00 	clr  %o0                                       
4001cc28:	7f ff dc 9f 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001cc2c:	92 10 24 00 	mov  0x400, %o1                                <== NOT EXECUTED
4001cc30:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001cc34:	12 80 00 1e 	bne  4001ccac <rtems_rfs_buffer_setblksize+0xe0><== NOT EXECUTED
4001cc38:	01 00 00 00 	nop                                            <== NOT EXECUTED
    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);     
4001cc3c:	d0 06 20 10 	ld  [ %i0 + 0x10 ], %o0                        
4001cc40:	13 20 01 10 	sethi  %hi(0x80044000), %o1                    
4001cc44:	c2 02 20 38 	ld  [ %o0 + 0x38 ], %g1                        
4001cc48:	92 12 62 04 	or  %o1, 0x204, %o1                            
4001cc4c:	9f c0 40 00 	call  %g1                                      
4001cc50:	94 07 a0 48 	add  %fp, 0x48, %o2                            
  if (rc < 0)                                                         
4001cc54:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001cc58:	06 80 00 08 	bl  4001cc78 <rtems_rfs_buffer_setblksize+0xac><== NEVER TAKEN
4001cc5c:	01 00 00 00 	nop                                            
    rc = errno;                                                       
#endif                                                                
  return rc;                                                          
}                                                                     
4001cc60:	81 c7 e0 08 	ret                                            
4001cc64:	81 e8 00 00 	restore                                        
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)  
{                                                                     
  int rc;                                                             
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))            
    printf ("rtems-rfs: buffer-setblksize: block size: %zu\n", size); 
4001cc68:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
4001cc6c:	40 00 1c c4 	call  40023f7c <printf>                        <== NOT EXECUTED
4001cc70:	90 12 20 e8 	or  %o0, 0xe8, %o0	! 400370e8 <CSWTCH.2+0x4f8> <== NOT EXECUTED
4001cc74:	30 bf ff de 	b,a   4001cbec <rtems_rfs_buffer_setblksize+0x20><== NOT EXECUTED
            rc, strerror (rc));                                       
                                                                      
#if RTEMS_RFS_USE_LIBBLOCK                                            
  rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);     
  if (rc < 0)                                                         
    rc = errno;                                                       
4001cc78:	40 00 17 30 	call  40022938 <__errno>                       <== NOT EXECUTED
4001cc7c:	01 00 00 00 	nop                                            <== NOT EXECUTED
4001cc80:	f0 02 00 00 	ld  [ %o0 ], %i0                               <== NOT EXECUTED
#endif                                                                
  return rc;                                                          
}                                                                     
4001cc84:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001cc88:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  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);                                
  if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
    printf ("rtems-rfs: buffer-setblksize: buffer release failed: %d: %s\n",
4001cc8c:	40 00 21 06 	call  400250a4 <strerror>                      <== NOT EXECUTED
4001cc90:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001cc94:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
4001cc98:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
4001cc9c:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
4001cca0:	40 00 1c b7 	call  40023f7c <printf>                        <== NOT EXECUTED
4001cca4:	90 12 21 18 	or  %o0, 0x118, %o0	! 40037118 <CSWTCH.2+0x528><== NOT EXECUTED
4001cca8:	30 bf ff db 	b,a   4001cc14 <rtems_rfs_buffer_setblksize+0x48><== NOT EXECUTED
            rc, strerror (rc));                                       
                                                                      
  rc = rtems_rfs_buffer_sync (fs);                                    
  if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
    printf ("rtems-rfs: buffer-setblksize: device sync failed: %d: %s\n",
4001ccac:	40 00 20 fe 	call  400250a4 <strerror>                      <== NOT EXECUTED
4001ccb0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001ccb4:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
4001ccb8:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
4001ccbc:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
4001ccc0:	40 00 1c af 	call  40023f7c <printf>                        <== NOT EXECUTED
4001ccc4:	90 12 21 58 	or  %o0, 0x158, %o0	! 40037158 <CSWTCH.2+0x568><== NOT EXECUTED
            rc, strerror (rc));                                       
                                                                      
#if RTEMS_RFS_USE_LIBBLOCK                                            
  rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);     
4001ccc8:	d0 06 20 10 	ld  [ %i0 + 0x10 ], %o0                        <== NOT EXECUTED
4001cccc:	13 20 01 10 	sethi  %hi(0x80044000), %o1                    <== NOT EXECUTED
4001ccd0:	c2 02 20 38 	ld  [ %o0 + 0x38 ], %g1                        <== NOT EXECUTED
4001ccd4:	92 12 62 04 	or  %o1, 0x204, %o1                            <== NOT EXECUTED
4001ccd8:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
4001ccdc:	94 07 a0 48 	add  %fp, 0x48, %o2                            <== NOT EXECUTED
  if (rc < 0)                                                         
4001cce0:	b0 92 20 00 	orcc  %o0, 0, %i0                              <== NOT EXECUTED
4001cce4:	16 bf ff e8 	bge  4001cc84 <rtems_rfs_buffer_setblksize+0xb8><== NOT EXECUTED
4001cce8:	01 00 00 00 	nop                                            <== NOT EXECUTED
4001ccec:	30 bf ff e3 	b,a   4001cc78 <rtems_rfs_buffer_setblksize+0xac><== NOT EXECUTED
                                                                      

4001cab0 <rtems_rfs_buffer_sync>: return rc; } int rtems_rfs_buffer_sync (rtems_rfs_file_system* fs) {
4001cab0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int result = 0;                                                     
#if RTEMS_RFS_USE_LIBBLOCK                                            
  rtems_status_code sc;                                               
#endif                                                                
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))                  
4001cab4:	90 10 20 00 	clr  %o0                                       
4001cab8:	92 10 20 20 	mov  0x20, %o1                                 
4001cabc:	7f ff dc fa 	call  40013ea4 <rtems_rfs_trace>               
4001cac0:	ba 10 00 18 	mov  %i0, %i5                                  
4001cac4:	80 8a 20 ff 	btst  0xff, %o0                                
4001cac8:	12 80 00 1c 	bne  4001cb38 <rtems_rfs_buffer_sync+0x88>     <== NEVER TAKEN
4001cacc:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    
                                                                      
  /*                                                                  
   * @todo Split in the separate files for each type.                 
   */                                                                 
#if RTEMS_RFS_USE_LIBBLOCK                                            
  sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));                
4001cad0:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        
4001cad4:	7f ff e7 26 	call  4001676c <rtems_bdbuf_syncdev>           
4001cad8:	b0 10 20 00 	clr  %i0                                       
  if (sc != RTEMS_SUCCESSFUL)                                         
4001cadc:	b8 92 20 00 	orcc  %o0, 0, %i4                              
4001cae0:	12 80 00 06 	bne  4001caf8 <rtems_rfs_buffer_sync+0x48>     <== NEVER TAKEN
4001cae4:	90 10 20 00 	clr  %o0                                       
    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);                                      
4001cae8:	7f ff 9e 14 	call  40004338 <rtems_disk_release>            
4001caec:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        
      printf ("rtems-rfs: buffer-sync: file sync failed: %d: %s\n",   
              result, strerror (result));                             
  }                                                                   
#endif                                                                
  return result;                                                      
}                                                                     
4001caf0:	81 c7 e0 08 	ret                                            
4001caf4:	81 e8 00 00 	restore                                        
   */                                                                 
#if RTEMS_RFS_USE_LIBBLOCK                                            
  sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));                
  if (sc != RTEMS_SUCCESSFUL)                                         
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))                
4001caf8:	92 10 20 20 	mov  0x20, %o1                                 <== NOT EXECUTED
4001cafc:	7f ff dc ea 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001cb00:	b0 10 20 05 	mov  5, %i0                                    <== NOT EXECUTED
4001cb04:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001cb08:	02 bf ff f8 	be  4001cae8 <rtems_rfs_buffer_sync+0x38>      <== NOT EXECUTED
4001cb0c:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: buffer-sync: device sync failed: %s\n",     
4001cb10:	7f ff eb 40 	call  40017810 <rtems_status_text>             <== NOT EXECUTED
4001cb14:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
4001cb18:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
4001cb1c:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
4001cb20:	40 00 1d 17 	call  40023f7c <printf>                        <== NOT EXECUTED
4001cb24:	90 12 20 68 	or  %o0, 0x68, %o0	! 40037068 <CSWTCH.2+0x478> <== NOT EXECUTED
              rtems_status_text (sc));                                
    result = EIO;                                                     
  }                                                                   
  rtems_disk_release (fs->disk);                                      
4001cb28:	7f ff 9e 04 	call  40004338 <rtems_disk_release>            <== NOT EXECUTED
4001cb2c:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        <== NOT EXECUTED
      printf ("rtems-rfs: buffer-sync: file sync failed: %d: %s\n",   
              result, strerror (result));                             
  }                                                                   
#endif                                                                
  return result;                                                      
}                                                                     
4001cb30:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001cb34:	81 e8 00 00 	restore                                        <== NOT EXECUTED
#if RTEMS_RFS_USE_LIBBLOCK                                            
  rtems_status_code sc;                                               
#endif                                                                
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))                  
    printf ("rtems-rfs: buffer-sync: syncing\n");                     
4001cb38:	40 00 1d a9 	call  400241dc <puts>                          <== NOT EXECUTED
4001cb3c:	90 12 20 48 	or  %o0, 0x48, %o0                             <== 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));                
4001cb40:	10 bf ff e5 	b  4001cad4 <rtems_rfs_buffer_sync+0x24>       <== NOT EXECUTED
4001cb44:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        <== NOT EXECUTED
                                                                      

4001cb48 <rtems_rfs_buffers_release>: return rrc; } int rtems_rfs_buffers_release (rtems_rfs_file_system* fs) {
4001cb48:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rrc = 0;                                                        
  int rc;                                                             
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))               
4001cb4c:	90 10 20 00 	clr  %o0                                       
4001cb50:	7f ff dc d5 	call  40013ea4 <rtems_rfs_trace>               
4001cb54:	92 10 20 40 	mov  0x40, %o1                                 
4001cb58:	80 8a 20 ff 	btst  0xff, %o0                                
4001cb5c:	32 80 00 15 	bne,a   4001cbb0 <rtems_rfs_buffers_release+0x68><== NEVER TAKEN
4001cb60:	d2 06 20 50 	ld  [ %i0 + 0x50 ], %o1                        <== NOT EXECUTED
    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,                         
4001cb64:	92 06 20 60 	add  %i0, 0x60, %o1                            
4001cb68:	94 10 20 00 	clr  %o2                                       
4001cb6c:	7f ff fd c4 	call  4001c27c <rtems_rfs_release_chain>       
4001cb70:	90 06 20 54 	add  %i0, 0x54, %o0                            
4001cb74:	82 38 00 08 	xnor  %g0, %o0, %g1                            
4001cb78:	83 38 60 1f 	sra  %g1, 0x1f, %g1                            
4001cb7c:	ba 10 00 08 	mov  %o0, %i5                                  
                                &fs->release_count,                   
                                false);                               
  if ((rc > 0) && (rrc == 0))                                         
    rrc = rc;                                                         
  rc = rtems_rfs_release_chain (&fs->release_modified,                
4001cb80:	92 06 20 70 	add  %i0, 0x70, %o1                            
4001cb84:	ba 0f 40 01 	and  %i5, %g1, %i5                             
4001cb88:	90 06 20 64 	add  %i0, 0x64, %o0                            
4001cb8c:	7f ff fd bc 	call  4001c27c <rtems_rfs_release_chain>       
4001cb90:	94 10 20 01 	mov  1, %o2                                    
                                &fs->release_modified_count,          
                                true);                                
  if ((rc > 0) && (rrc == 0))                                         
4001cb94:	80 a7 60 00 	cmp  %i5, 0                                    
4001cb98:	12 80 00 04 	bne  4001cba8 <rtems_rfs_buffers_release+0x60> <== NEVER TAKEN
4001cb9c:	80 a2 20 00 	cmp  %o0, 0                                    
4001cba0:	34 80 00 02 	bg,a   4001cba8 <rtems_rfs_buffers_release+0x60><== NEVER TAKEN
4001cba4:	ba 10 00 08 	mov  %o0, %i5                                  <== NOT EXECUTED
    rrc = rc;                                                         
                                                                      
  return rrc;                                                         
}                                                                     
4001cba8:	81 c7 e0 08 	ret                                            
4001cbac:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
{                                                                     
  int rrc = 0;                                                        
  int rc;                                                             
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))               
    printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "         
4001cbb0:	d4 06 20 60 	ld  [ %i0 + 0x60 ], %o2                        <== NOT EXECUTED
4001cbb4:	d6 06 20 70 	ld  [ %i0 + 0x70 ], %o3                        <== NOT EXECUTED
4001cbb8:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
4001cbbc:	40 00 1c f0 	call  40023f7c <printf>                        <== NOT EXECUTED
4001cbc0:	90 12 20 98 	or  %o0, 0x98, %o0	! 40037098 <CSWTCH.2+0x4a8> <== NOT EXECUTED
            "release:%" PRIu32 " release-modified:%" PRIu32 "\n",     
            fs->buffers_count, fs->release_count, fs->release_modified_count);
                                                                      
  rc = rtems_rfs_release_chain (&fs->release,                         
4001cbc4:	10 bf ff e9 	b  4001cb68 <rtems_rfs_buffers_release+0x20>   <== NOT EXECUTED
4001cbc8:	92 06 20 60 	add  %i0, 0x60, %o1                            <== NOT EXECUTED
                                                                      

4001d324 <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) {
4001d324:	9d e3 bf 30 	save  %sp, -208, %sp                           
  rtems_rfs_block_map     map;                                        
  rtems_rfs_block_pos     bpos;                                       
  rtems_rfs_buffer_handle buffer;                                     
  int                     rc;                                         
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))                
4001d328:	90 10 20 00 	clr  %o0                                       
4001d32c:	7f ff da de 	call  40013ea4 <rtems_rfs_trace>               
4001d330:	13 08 00 00 	sethi  %hi(0x20000000), %o1                    
4001d334:	80 8a 20 ff 	btst  0xff, %o0                                
4001d338:	32 80 00 7c 	bne,a   4001d528 <rtems_rfs_dir_add_entry+0x204><== NEVER TAKEN
4001d33c:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== 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);                      
4001d340:	90 10 00 18 	mov  %i0, %o0                                  
4001d344:	92 10 00 19 	mov  %i1, %o1                                  
4001d348:	7f ff f8 b2 	call  4001b610 <rtems_rfs_block_map_open>      
4001d34c:	94 07 bf b0 	add  %fp, -80, %o2                             
  if (rc > 0)                                                         
4001d350:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001d354:	04 80 00 04 	ble  4001d364 <rtems_rfs_dir_add_entry+0x40>   <== ALWAYS TAKEN
4001d358:	29 00 00 3f 	sethi  %hi(0xfc00), %l4                        
  }                                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &buffer);                        
  rtems_rfs_block_map_close (fs, &map);                               
  return rc;                                                          
}                                                                     
4001d35c:	81 c7 e0 08 	ret                                            
4001d360:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
4001d364:	c0 2f bf a4 	clrb  [ %fp + -92 ]                            
  handle->bnum  = 0;                                                  
4001d368:	c0 27 bf a8 	clr  [ %fp + -88 ]                             
  handle->buffer = NULL;                                              
4001d36c:	c0 27 bf ac 	clr  [ %fp + -84 ]                             
 * @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;                                                      
4001d370:	c0 27 bf 98 	clr  [ %fp + -104 ]                            
  bpos->boff = 0;                                                     
4001d374:	c0 27 bf 9c 	clr  [ %fp + -100 ]                            
  bpos->block = 0;                                                    
4001d378:	c0 27 bf a0 	clr  [ %fp + -96 ]                             
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
      eino    = rtems_rfs_dir_entry_ino (entry);                      
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
4001d37c:	a8 15 23 ff 	or  %l4, 0x3ff, %l4                            
      {                                                               
        if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <                     
4001d380:	a6 06 e0 0a 	add  %i3, 0xa, %l3                             
    /*                                                                
     * 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);          
4001d384:	90 10 00 18 	mov  %i0, %o0                                  
4001d388:	92 07 bf b0 	add  %fp, -80, %o1                             
4001d38c:	94 07 bf 98 	add  %fp, -104, %o2                            
4001d390:	7f ff f9 75 	call  4001b964 <rtems_rfs_block_map_find>      
4001d394:	96 07 bf 94 	add  %fp, -108, %o3                            
    if (rc > 0)                                                       
4001d398:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001d39c:	04 80 00 ae 	ble  4001d654 <rtems_rfs_dir_add_entry+0x330>  
4001d3a0:	80 a7 60 06 	cmp  %i5, 6                                    
    {                                                                 
      if (rc != ENXIO)                                                
4001d3a4:	12 80 00 c7 	bne  4001d6c0 <rtems_rfs_dir_add_entry+0x39c>  <== NEVER TAKEN
4001d3a8:	90 10 00 18 	mov  %i0, %o0                                  
      }                                                               
                                                                      
      /*                                                              
       * We have reached the end of the directory so add a block.     
       */                                                             
      rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);            
4001d3ac:	92 07 bf b0 	add  %fp, -80, %o1                             
4001d3b0:	94 10 20 01 	mov  1, %o2                                    
4001d3b4:	7f ff f9 f0 	call  4001bb74 <rtems_rfs_block_map_grow>      
4001d3b8:	96 07 bf 94 	add  %fp, -108, %o3                            
      if (rc > 0)                                                     
4001d3bc:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001d3c0:	14 80 00 d1 	bg  4001d704 <rtems_rfs_dir_add_entry+0x3e0>   <== NEVER TAKEN
4001d3c4:	a0 10 20 00 	clr  %l0                                       
      }                                                               
                                                                      
      read = false;                                                   
    }                                                                 
                                                                      
    bpos.bno++;                                                       
4001d3c8:	c2 07 bf 98 	ld  [ %fp + -104 ], %g1                        
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);  
4001d3cc:	d4 07 bf 94 	ld  [ %fp + -108 ], %o2                        
      }                                                               
                                                                      
      read = false;                                                   
    }                                                                 
                                                                      
    bpos.bno++;                                                       
4001d3d0:	82 00 60 01 	inc  %g1                                       
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);  
4001d3d4:	a0 0c 20 ff 	and  %l0, 0xff, %l0                            
      }                                                               
                                                                      
      read = false;                                                   
    }                                                                 
                                                                      
    bpos.bno++;                                                       
4001d3d8:	c2 27 bf 98 	st  %g1, [ %fp + -104 ]                        
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);  
4001d3dc:	90 10 00 18 	mov  %i0, %o0                                  
4001d3e0:	92 07 bf a4 	add  %fp, -92, %o1                             
4001d3e4:	7f ff fc 8f 	call  4001c620 <rtems_rfs_buffer_handle_request>
4001d3e8:	96 10 00 10 	mov  %l0, %o3                                  
    if (rc > 0)                                                       
4001d3ec:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001d3f0:	14 80 00 9b 	bg  4001d65c <rtems_rfs_dir_add_entry+0x338>   <== NEVER TAKEN
4001d3f4:	c2 07 bf ac 	ld  [ %fp + -84 ], %g1                         
      break;                                                          
    }                                                                 
                                                                      
    entry  = rtems_rfs_buffer_data (&buffer);                         
                                                                      
    if (!read)                                                        
4001d3f8:	80 a4 20 00 	cmp  %l0, 0                                    
4001d3fc:	02 80 00 5e 	be  4001d574 <rtems_rfs_dir_add_entry+0x250>   
4001d400:	fa 00 60 1c 	ld  [ %g1 + 0x1c ], %i5                        
      memset (entry, 0xff, rtems_rfs_fs_block_size (fs));             
                                                                      
    offset = 0;                                                       
                                                                      
    while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001d404:	da 06 20 08 	ld  [ %i0 + 8 ], %o5                           
4001d408:	9e 83 7f f6 	addcc  %o5, -10, %o7                           
4001d40c:	02 bf ff df 	be  4001d388 <rtems_rfs_dir_add_entry+0x64>    <== NEVER TAKEN
4001d410:	90 10 00 18 	mov  %i0, %o0                                  
    {                                                                 
      rtems_rfs_ino eino;                                             
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
4001d414:	e0 0f 60 08 	ldub  [ %i5 + 8 ], %l0                         
4001d418:	c8 0f 60 09 	ldub  [ %i5 + 9 ], %g4                         
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001d41c:	e4 0f 40 00 	ldub  [ %i5 ], %l2                             
4001d420:	c6 0f 60 02 	ldub  [ %i5 + 2 ], %g3                         
4001d424:	c4 0f 60 03 	ldub  [ %i5 + 3 ], %g2                         
4001d428:	c2 0f 60 01 	ldub  [ %i5 + 1 ], %g1                         
    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);                   
4001d42c:	a1 2c 20 08 	sll  %l0, 8, %l0                               
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001d430:	a5 2c a0 18 	sll  %l2, 0x18, %l2                            
    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);                   
4001d434:	a0 14 00 04 	or  %l0, %g4, %l0                              
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001d438:	87 28 e0 08 	sll  %g3, 8, %g3                               
4001d43c:	83 28 60 10 	sll  %g1, 0x10, %g1                            
4001d440:	a4 14 80 03 	or  %l2, %g3, %l2                              
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
4001d444:	80 a4 00 14 	cmp  %l0, %l4                                  
    {                                                                 
      rtems_rfs_ino eino;                                             
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001d448:	a4 14 80 02 	or  %l2, %g2, %l2                              
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
4001d44c:	02 80 00 58 	be  4001d5ac <rtems_rfs_dir_add_entry+0x288>   
4001d450:	a4 14 80 01 	or  %l2, %g1, %l2                              
4001d454:	10 80 00 20 	b  4001d4d4 <rtems_rfs_dir_add_entry+0x1b0>    
4001d458:	a2 10 20 00 	clr  %l1                                       
        }                                                             
                                                                      
        break;                                                        
      }                                                               
                                                                      
      if (rtems_rfs_dir_entry_valid (fs, elength, eino))              
4001d45c:	80 a4 00 01 	cmp  %l0, %g1                                  
4001d460:	1a 80 00 20 	bcc  4001d4e0 <rtems_rfs_dir_add_entry+0x1bc>  <== NEVER TAKEN
4001d464:	ba 07 40 10 	add  %i5, %l0, %i5                             
4001d468:	80 a4 a0 00 	cmp  %l2, 0                                    
4001d46c:	02 80 00 1e 	be  4001d4e4 <rtems_rfs_dir_add_entry+0x1c0>   <== NEVER TAKEN
4001d470:	90 10 20 00 	clr  %o0                                       
4001d474:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
4001d478:	80 a0 40 12 	cmp  %g1, %l2                                  
4001d47c:	0a 80 00 1a 	bcs  4001d4e4 <rtems_rfs_dir_add_entry+0x1c0>  <== NEVER TAKEN
4001d480:	01 00 00 00 	nop                                            
        rtems_rfs_block_map_close (fs, &map);                         
        return EIO;                                                   
      }                                                               
                                                                      
      entry  += elength;                                              
      offset += elength;                                              
4001d484:	a2 04 40 10 	add  %l1, %l0, %l1                             
    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))
4001d488:	80 a4 40 0f 	cmp  %l1, %o7                                  
4001d48c:	1a bf ff be 	bcc  4001d384 <rtems_rfs_dir_add_entry+0x60>   <== NEVER TAKEN
4001d490:	98 10 00 11 	mov  %l1, %o4                                  
    {                                                                 
      rtems_rfs_ino eino;                                             
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
4001d494:	e0 0f 60 08 	ldub  [ %i5 + 8 ], %l0                         
4001d498:	c8 0f 60 09 	ldub  [ %i5 + 9 ], %g4                         
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001d49c:	e4 0f 40 00 	ldub  [ %i5 ], %l2                             
4001d4a0:	c6 0f 60 01 	ldub  [ %i5 + 1 ], %g3                         
4001d4a4:	c4 0f 60 03 	ldub  [ %i5 + 3 ], %g2                         
4001d4a8:	c2 0f 60 02 	ldub  [ %i5 + 2 ], %g1                         
    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);                   
4001d4ac:	a1 2c 20 08 	sll  %l0, 8, %l0                               
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001d4b0:	a5 2c a0 18 	sll  %l2, 0x18, %l2                            
    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);                   
4001d4b4:	a0 14 00 04 	or  %l0, %g4, %l0                              
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001d4b8:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
4001d4bc:	83 28 60 08 	sll  %g1, 8, %g1                               
4001d4c0:	a4 14 80 03 	or  %l2, %g3, %l2                              
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
4001d4c4:	80 a4 00 14 	cmp  %l0, %l4                                  
    {                                                                 
      rtems_rfs_ino eino;                                             
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001d4c8:	a4 14 80 02 	or  %l2, %g2, %l2                              
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
4001d4cc:	02 80 00 39 	be  4001d5b0 <rtems_rfs_dir_add_entry+0x28c>   
4001d4d0:	a4 14 80 01 	or  %l2, %g1, %l2                              
        }                                                             
                                                                      
        break;                                                        
      }                                                               
                                                                      
      if (rtems_rfs_dir_entry_valid (fs, elength, eino))              
4001d4d4:	80 a4 20 0a 	cmp  %l0, 0xa                                  
4001d4d8:	34 bf ff e1 	bg,a   4001d45c <rtems_rfs_dir_add_entry+0x138><== ALWAYS TAKEN
4001d4dc:	c2 06 20 1c 	ld  [ %i0 + 0x1c ], %g1                        
      {                                                               
        if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))          
4001d4e0:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001d4e4:	7f ff da 70 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001d4e8:	13 08 00 00 	sethi  %hi(0x20000000), %o1                    <== NOT EXECUTED
4001d4ec:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001d4f0:	32 80 00 27 	bne,a   4001d58c <rtems_rfs_dir_add_entry+0x268><== NOT EXECUTED
4001d4f4:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== 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);                       
4001d4f8:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
4001d4fc:	7f ff fb cf 	call  4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001d500:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
          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);                  
        rtems_rfs_block_map_close (fs, &map);                         
4001d504:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
4001d508:	c0 2f bf a4 	clrb  [ %fp + -92 ]                            <== NOT EXECUTED
  handle->bnum  = 0;                                                  
4001d50c:	c0 27 bf a8 	clr  [ %fp + -88 ]                             <== NOT EXECUTED
  handle->buffer = NULL;                                              
4001d510:	c0 27 bf ac 	clr  [ %fp + -84 ]                             <== NOT EXECUTED
4001d514:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
4001d518:	7f ff f8 9f 	call  4001b794 <rtems_rfs_block_map_close>     <== NOT EXECUTED
4001d51c:	ba 10 20 05 	mov  5, %i5                                    <== NOT EXECUTED
  }                                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &buffer);                        
  rtems_rfs_block_map_close (fs, &map);                               
  return rc;                                                          
}                                                                     
4001d520:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001d524:	91 e8 00 1d 	restore  %g0, %i5, %o0                         <== NOT EXECUTED
  int                     rc;                                         
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))                
  {                                                                   
    int c;                                                            
    printf ("rtems-rfs: dir-add-entry: dir=%" PRId32 ", name=",       
4001d528:	11 10 00 dd 	sethi  %hi(0x40037400), %o0                    <== NOT EXECUTED
4001d52c:	40 00 1a 94 	call  40023f7c <printf>                        <== NOT EXECUTED
4001d530:	90 12 21 08 	or  %o0, 0x108, %o0	! 40037508 <CSWTCH.2+0x918><== NOT EXECUTED
            rtems_rfs_inode_ino (dir));                               
    for (c = 0; c < length; c++)                                      
4001d534:	ba 10 20 00 	clr  %i5                                       <== NOT EXECUTED
4001d538:	80 a6 e0 00 	cmp  %i3, 0                                    <== NOT EXECUTED
4001d53c:	02 80 00 08 	be  4001d55c <rtems_rfs_dir_add_entry+0x238>   <== NOT EXECUTED
4001d540:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
      printf ("%c", name[c]);                                         
4001d544:	d0 4e 80 01 	ldsb  [ %i2 + %g1 ], %o0                       <== NOT EXECUTED
4001d548:	40 00 1a f7 	call  40024124 <putchar>                       <== NOT EXECUTED
4001d54c:	ba 07 60 01 	inc  %i5                                       <== NOT EXECUTED
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))                
  {                                                                   
    int c;                                                            
    printf ("rtems-rfs: dir-add-entry: dir=%" PRId32 ", name=",       
            rtems_rfs_inode_ino (dir));                               
    for (c = 0; c < length; c++)                                      
4001d550:	80 a7 40 1b 	cmp  %i5, %i3                                  <== NOT EXECUTED
4001d554:	12 bf ff fc 	bne  4001d544 <rtems_rfs_dir_add_entry+0x220>  <== NOT EXECUTED
4001d558:	82 10 00 1d 	mov  %i5, %g1                                  <== NOT EXECUTED
      printf ("%c", name[c]);                                         
    printf (", len=%zd\n", length);                                   
4001d55c:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
4001d560:	11 10 00 dd 	sethi  %hi(0x40037400), %o0                    <== NOT EXECUTED
4001d564:	40 00 1a 86 	call  40023f7c <printf>                        <== NOT EXECUTED
4001d568:	90 12 21 38 	or  %o0, 0x138, %o0	! 40037538 <CSWTCH.2+0x948><== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_block_map_open (fs, dir, &map);                      
4001d56c:	10 bf ff 76 	b  4001d344 <rtems_rfs_dir_add_entry+0x20>     <== NOT EXECUTED
4001d570:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
    }                                                                 
                                                                      
    entry  = rtems_rfs_buffer_data (&buffer);                         
                                                                      
    if (!read)                                                        
      memset (entry, 0xff, rtems_rfs_fs_block_size (fs));             
4001d574:	d4 06 20 08 	ld  [ %i0 + 8 ], %o2                           
4001d578:	90 10 00 1d 	mov  %i5, %o0                                  
4001d57c:	40 00 1a 02 	call  40023d84 <memset>                        
4001d580:	92 10 20 ff 	mov  0xff, %o1                                 
                                                                      
    offset = 0;                                                       
                                                                      
    while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001d584:	10 bf ff a1 	b  4001d408 <rtems_rfs_dir_add_entry+0xe4>     
4001d588:	da 06 20 08 	ld  [ %i0 + 8 ], %o5                           
      }                                                               
                                                                      
      if (rtems_rfs_dir_entry_valid (fs, elength, eino))              
      {                                                               
        if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))          
          printf ("rtems-rfs: dir-add-entry: "                        
4001d58c:	94 10 00 10 	mov  %l0, %o2                                  <== NOT EXECUTED
4001d590:	11 10 00 dd 	sethi  %hi(0x40037400), %o0                    <== NOT EXECUTED
4001d594:	96 10 00 12 	mov  %l2, %o3                                  <== NOT EXECUTED
4001d598:	98 10 00 11 	mov  %l1, %o4                                  <== NOT EXECUTED
4001d59c:	40 00 1a 78 	call  40023f7c <printf>                        <== NOT EXECUTED
4001d5a0:	90 12 22 20 	or  %o0, 0x220, %o0                            <== 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);                       
4001d5a4:	10 bf ff d6 	b  4001d4fc <rtems_rfs_dir_add_entry+0x1d8>    <== NOT EXECUTED
4001d5a8:	92 07 bf a4 	add  %fp, -92, %o1                             <== 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))
4001d5ac:	98 10 20 00 	clr  %o4                                       
      eino    = rtems_rfs_dir_entry_ino (entry);                      
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
      {                                                               
        if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <                     
            (rtems_rfs_fs_block_size (fs) - offset))                  
4001d5b0:	9a 23 40 0c 	sub  %o5, %o4, %o5                             
      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) <                     
4001d5b4:	80 a4 c0 0d 	cmp  %l3, %o5                                  
4001d5b8:	3a bf ff 74 	bcc,a   4001d388 <rtems_rfs_dir_add_entry+0x64><== NEVER TAKEN
4001d5bc:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
            (rtems_rfs_fs_block_size (fs) - offset))                  
        {                                                             
          uint32_t hash;                                              
          hash = rtems_rfs_dir_hash (name, length);                   
4001d5c0:	92 10 00 1b 	mov  %i3, %o1                                  
4001d5c4:	40 00 13 ed 	call  40022578 <rtems_rfs_dir_hash>            
4001d5c8:	90 10 00 1a 	mov  %i2, %o0                                  
          rtems_rfs_dir_set_entry_hash (entry, hash);                 
4001d5cc:	83 32 20 08 	srl  %o0, 8, %g1                               
4001d5d0:	c2 2f 60 06 	stb  %g1, [ %i5 + 6 ]                          
          rtems_rfs_dir_set_entry_ino (entry, ino);                   
4001d5d4:	83 37 20 10 	srl  %i4, 0x10, %g1                            
        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);                 
4001d5d8:	85 32 20 10 	srl  %o0, 0x10, %g2                            
          rtems_rfs_dir_set_entry_ino (entry, ino);                   
4001d5dc:	c2 2f 60 01 	stb  %g1, [ %i5 + 1 ]                          
4001d5e0:	83 37 20 08 	srl  %i4, 8, %g1                               
        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);                 
4001d5e4:	87 32 20 18 	srl  %o0, 0x18, %g3                            
4001d5e8:	c4 2f 60 05 	stb  %g2, [ %i5 + 5 ]                          
          rtems_rfs_dir_set_entry_ino (entry, ino);                   
4001d5ec:	c2 2f 60 02 	stb  %g1, [ %i5 + 2 ]                          
4001d5f0:	85 37 20 18 	srl  %i4, 0x18, %g2                            
          rtems_rfs_dir_set_entry_length (entry,                      
4001d5f4:	83 34 e0 08 	srl  %l3, 8, %g1                               
        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);                 
4001d5f8:	c6 2f 60 04 	stb  %g3, [ %i5 + 4 ]                          
          rtems_rfs_dir_set_entry_ino (entry, ino);                   
4001d5fc:	c4 2f 40 00 	stb  %g2, [ %i5 ]                              
          rtems_rfs_dir_set_entry_length (entry,                      
                                          RTEMS_RFS_DIR_ENTRY_SIZE + length);
          memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);    
4001d600:	94 10 00 1b 	mov  %i3, %o2                                  
4001d604:	92 10 00 1a 	mov  %i2, %o1                                  
        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);                 
4001d608:	d0 2f 60 07 	stb  %o0, [ %i5 + 7 ]                          
          rtems_rfs_dir_set_entry_ino (entry, ino);                   
4001d60c:	f8 2f 60 03 	stb  %i4, [ %i5 + 3 ]                          
          rtems_rfs_dir_set_entry_length (entry,                      
4001d610:	e6 2f 60 09 	stb  %l3, [ %i5 + 9 ]                          
4001d614:	c2 2f 60 08 	stb  %g1, [ %i5 + 8 ]                          
                                          RTEMS_RFS_DIR_ENTRY_SIZE + length);
          memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);    
4001d618:	40 00 19 4c 	call  40023b48 <memcpy>                        
4001d61c:	90 07 60 0a 	add  %i5, 0xa, %o0                             
          rtems_rfs_buffer_mark_dirty (&buffer);                      
4001d620:	82 10 20 01 	mov  1, %g1                                    
4001d624:	92 07 bf a4 	add  %fp, -92, %o1                             
4001d628:	90 10 00 18 	mov  %i0, %o0                                  
4001d62c:	7f ff fb 83 	call  4001c438 <rtems_rfs_buffer_handle_release>
4001d630:	c2 2f bf a4 	stb  %g1, [ %fp + -92 ]                        
          rtems_rfs_buffer_handle_close (fs, &buffer);                
          rtems_rfs_block_map_close (fs, &map);                       
4001d634:	90 10 00 18 	mov  %i0, %o0                                  
  handle->dirty = false;                                              
4001d638:	c0 2f bf a4 	clrb  [ %fp + -92 ]                            
  handle->bnum  = 0;                                                  
4001d63c:	c0 27 bf a8 	clr  [ %fp + -88 ]                             
  handle->buffer = NULL;                                              
4001d640:	c0 27 bf ac 	clr  [ %fp + -84 ]                             
4001d644:	92 07 bf b0 	add  %fp, -80, %o1                             
4001d648:	7f ff f8 53 	call  4001b794 <rtems_rfs_block_map_close>     
4001d64c:	ba 10 20 00 	clr  %i5                                       
4001d650:	30 bf ff 43 	b,a   4001d35c <rtems_rfs_dir_add_entry+0x38>  
  while (true)                                                        
  {                                                                   
    rtems_rfs_block_no block;                                         
    uint8_t*           entry;                                         
    int                offset;                                        
    bool               read = true;                                   
4001d654:	10 bf ff 5d 	b  4001d3c8 <rtems_rfs_dir_add_entry+0xa4>     
4001d658:	a0 10 20 01 	mov  1, %l0                                    
    bpos.bno++;                                                       
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);  
    if (rc > 0)                                                       
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))            
4001d65c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001d660:	7f ff da 11 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001d664:	13 08 00 00 	sethi  %hi(0x20000000), %o1                    <== NOT EXECUTED
4001d668:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001d66c:	22 80 00 0c 	be,a   4001d69c <rtems_rfs_dir_add_entry+0x378><== NOT EXECUTED
4001d670:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
        printf ("rtems-rfs: dir-add-entry: "                          
4001d674:	f8 06 60 08 	ld  [ %i1 + 8 ], %i4                           <== NOT EXECUTED
4001d678:	40 00 1e 8b 	call  400250a4 <strerror>                      <== NOT EXECUTED
4001d67c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001d680:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
4001d684:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
4001d688:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
4001d68c:	11 10 00 dd 	sethi  %hi(0x40037400), %o0                    <== NOT EXECUTED
4001d690:	40 00 1a 3b 	call  40023f7c <printf>                        <== NOT EXECUTED
4001d694:	90 12 21 d8 	or  %o0, 0x1d8, %o0	! 400375d8 <CSWTCH.2+0x9e8><== 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);                       
4001d698:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
4001d69c:	7f ff fb 67 	call  4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001d6a0:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
      offset += elength;                                              
    }                                                                 
  }                                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &buffer);                        
  rtems_rfs_block_map_close (fs, &map);                               
4001d6a4:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
4001d6a8:	c0 2f bf a4 	clrb  [ %fp + -92 ]                            <== NOT EXECUTED
  handle->bnum  = 0;                                                  
4001d6ac:	c0 27 bf a8 	clr  [ %fp + -88 ]                             <== NOT EXECUTED
  handle->buffer = NULL;                                              
4001d6b0:	c0 27 bf ac 	clr  [ %fp + -84 ]                             <== NOT EXECUTED
4001d6b4:	7f ff f8 38 	call  4001b794 <rtems_rfs_block_map_close>     <== NOT EXECUTED
4001d6b8:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
4001d6bc:	30 bf ff 28 	b,a   4001d35c <rtems_rfs_dir_add_entry+0x38>  <== NOT EXECUTED
    rc = rtems_rfs_block_map_find (fs, &map, &bpos, &block);          
    if (rc > 0)                                                       
    {                                                                 
      if (rc != ENXIO)                                                
      {                                                               
        if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))          
4001d6c0:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001d6c4:	7f ff d9 f8 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001d6c8:	13 08 00 00 	sethi  %hi(0x20000000), %o1                    <== NOT EXECUTED
4001d6cc:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001d6d0:	22 bf ff f3 	be,a   4001d69c <rtems_rfs_dir_add_entry+0x378><== NOT EXECUTED
4001d6d4:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
          printf ("rtems-rfs: dir-add-entry: "                        
4001d6d8:	f8 06 60 08 	ld  [ %i1 + 8 ], %i4                           <== NOT EXECUTED
4001d6dc:	40 00 1e 72 	call  400250a4 <strerror>                      <== NOT EXECUTED
4001d6e0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001d6e4:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
4001d6e8:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
4001d6ec:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
4001d6f0:	11 10 00 dd 	sethi  %hi(0x40037400), %o0                    <== NOT EXECUTED
4001d6f4:	40 00 1a 22 	call  40023f7c <printf>                        <== NOT EXECUTED
4001d6f8:	90 12 21 48 	or  %o0, 0x148, %o0	! 40037548 <CSWTCH.2+0x958><== 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);                       
4001d6fc:	10 bf ff e8 	b  4001d69c <rtems_rfs_dir_add_entry+0x378>    <== NOT EXECUTED
4001d700:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
       * We have reached the end of the directory so add a block.     
       */                                                             
      rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);            
      if (rc > 0)                                                     
      {                                                               
        if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))          
4001d704:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001d708:	7f ff d9 e7 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001d70c:	13 08 00 00 	sethi  %hi(0x20000000), %o1                    <== NOT EXECUTED
4001d710:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001d714:	22 bf ff e2 	be,a   4001d69c <rtems_rfs_dir_add_entry+0x378><== NOT EXECUTED
4001d718:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
          printf ("rtems-rfs: dir-add-entry: "                        
4001d71c:	f8 06 60 08 	ld  [ %i1 + 8 ], %i4                           <== NOT EXECUTED
4001d720:	40 00 1e 61 	call  400250a4 <strerror>                      <== NOT EXECUTED
4001d724:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001d728:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
4001d72c:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
4001d730:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
4001d734:	11 10 00 dd 	sethi  %hi(0x40037400), %o0                    <== NOT EXECUTED
4001d738:	40 00 1a 11 	call  40023f7c <printf>                        <== NOT EXECUTED
4001d73c:	90 12 21 90 	or  %o0, 0x190, %o0	! 40037590 <CSWTCH.2+0x9a0><== NOT EXECUTED
4001d740:	10 bf ff d7 	b  4001d69c <rtems_rfs_dir_add_entry+0x378>    <== NOT EXECUTED
4001d744:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
                                                                      

4001d748 <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) {
4001d748:	9d e3 bf 40 	save  %sp, -192, %sp                           
  rtems_rfs_block_no      block;                                      
  rtems_rfs_buffer_handle buffer;                                     
  bool                    search;                                     
  int                     rc;                                         
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))                
4001d74c:	90 10 20 00 	clr  %o0                                       
4001d750:	13 10 00 00 	sethi  %hi(0x40000000), %o1                    
4001d754:	7f ff d9 d4 	call  40013ea4 <rtems_rfs_trace>               
4001d758:	a2 10 00 18 	mov  %i0, %l1                                  
4001d75c:	80 8a 20 ff 	btst  0xff, %o0                                
4001d760:	12 80 00 0a 	bne  4001d788 <rtems_rfs_dir_del_entry+0x40>   <== NEVER TAKEN
4001d764:	92 10 00 19 	mov  %i1, %o1                                  
    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);                      
4001d768:	90 10 00 11 	mov  %l1, %o0                                  
4001d76c:	7f ff f7 a9 	call  4001b610 <rtems_rfs_block_map_open>      
4001d770:	94 07 bf b0 	add  %fp, -80, %o2                             
  if (rc > 0)                                                         
4001d774:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001d778:	04 80 00 11 	ble  4001d7bc <rtems_rfs_dir_del_entry+0x74>   <== ALWAYS TAKEN
4001d77c:	90 10 00 11 	mov  %l1, %o0                                  
  }                                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &buffer);                        
  rtems_rfs_block_map_close (fs, &map);                               
  return rc;                                                          
}                                                                     
4001d780:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001d784:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  rtems_rfs_buffer_handle buffer;                                     
  bool                    search;                                     
  int                     rc;                                         
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))                
    printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n",
4001d788:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
4001d78c:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
4001d790:	96 10 00 1b 	mov  %i3, %o3                                  <== NOT EXECUTED
4001d794:	11 10 00 dd 	sethi  %hi(0x40037400), %o0                    <== NOT EXECUTED
4001d798:	40 00 19 f9 	call  40023f7c <printf>                        <== NOT EXECUTED
4001d79c:	90 12 22 68 	or  %o0, 0x268, %o0	! 40037668 <CSWTCH.2+0xa78><== NOT EXECUTED
            rtems_rfs_inode_ino (dir), ino, offset);                  
                                                                      
  rc = rtems_rfs_block_map_open (fs, dir, &map);                      
4001d7a0:	90 10 00 11 	mov  %l1, %o0                                  <== NOT EXECUTED
4001d7a4:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
4001d7a8:	7f ff f7 9a 	call  4001b610 <rtems_rfs_block_map_open>      <== NOT EXECUTED
4001d7ac:	94 07 bf b0 	add  %fp, -80, %o2                             <== NOT EXECUTED
  if (rc > 0)                                                         
4001d7b0:	b0 92 20 00 	orcc  %o0, 0, %i0                              <== NOT EXECUTED
4001d7b4:	14 bf ff f3 	bg  4001d780 <rtems_rfs_dir_del_entry+0x38>    <== NOT EXECUTED
4001d7b8:	90 10 00 11 	mov  %l1, %o0                                  <== NOT EXECUTED
    return rc;                                                        
                                                                      
  rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);           
4001d7bc:	92 07 bf b0 	add  %fp, -80, %o1                             
4001d7c0:	94 10 20 00 	clr  %o2                                       
4001d7c4:	96 10 00 1b 	mov  %i3, %o3                                  
4001d7c8:	7f ff f8 c1 	call  4001bacc <rtems_rfs_block_map_seek>      
4001d7cc:	98 07 bf a0 	add  %fp, -96, %o4                             
  if (rc > 0)                                                         
4001d7d0:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001d7d4:	04 80 00 09 	ble  4001d7f8 <rtems_rfs_dir_del_entry+0xb0>   <== ALWAYS TAKEN
4001d7d8:	80 a6 20 06 	cmp  %i0, 6                                    
  {                                                                   
    if (rc == ENXIO)                                                  
4001d7dc:	22 80 00 02 	be,a   4001d7e4 <rtems_rfs_dir_del_entry+0x9c> <== NOT EXECUTED
4001d7e0:	b0 10 20 02 	mov  2, %i0                                    <== NOT EXECUTED
      rc = ENOENT;                                                    
    rtems_rfs_block_map_close (fs, &map);                             
4001d7e4:	90 10 00 11 	mov  %l1, %o0                                  <== NOT EXECUTED
4001d7e8:	7f ff f7 eb 	call  4001b794 <rtems_rfs_block_map_close>     <== NOT EXECUTED
4001d7ec:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
4001d7f0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001d7f4:	81 e8 00 00 	restore                                        <== 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)                                                       
4001d7f8:	80 a0 00 1b 	cmp  %g0, %i3                                  
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
      eino    = rtems_rfs_dir_entry_ino (entry);                      
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
4001d7fc:	29 00 00 3f 	sethi  %hi(0xfc00), %l4                        
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
4001d800:	c0 2f bf a4 	clrb  [ %fp + -92 ]                            
  handle->bnum  = 0;                                                  
4001d804:	c0 27 bf a8 	clr  [ %fp + -88 ]                             
  handle->buffer = NULL;                                              
4001d808:	c0 27 bf ac 	clr  [ %fp + -84 ]                             
                                                                      
    /*                                                                
     * If we are searching start at the beginning of the block. If not searching
     * skip to the offset in the block.                               
     */                                                               
    if (search)                                                       
4001d80c:	a6 60 3f ff 	subx  %g0, -1, %l3                             
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
      eino    = rtems_rfs_dir_entry_ino (entry);                      
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
4001d810:	a8 15 23 ff 	or  %l4, 0x3ff, %l4                            
  while (rc == 0)                                                     
  {                                                                   
    uint8_t* entry;                                                   
    int      eoffset;                                                 
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);  
4001d814:	d4 07 bf a0 	ld  [ %fp + -96 ], %o2                         
4001d818:	90 10 00 11 	mov  %l1, %o0                                  
4001d81c:	92 07 bf a4 	add  %fp, -92, %o1                             
4001d820:	7f ff fb 80 	call  4001c620 <rtems_rfs_buffer_handle_request>
4001d824:	96 10 20 01 	mov  1, %o3                                    
    if (rc > 0)                                                       
4001d828:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001d82c:	14 80 00 cc 	bg  4001db5c <rtems_rfs_dir_del_entry+0x414>   <== NEVER TAKEN
4001d830:	80 a4 e0 00 	cmp  %l3, 0                                    
                                                                      
    /*                                                                
     * If we are searching start at the beginning of the block. If not searching
     * skip to the offset in the block.                               
     */                                                               
    if (search)                                                       
4001d834:	02 80 00 63 	be  4001d9c0 <rtems_rfs_dir_del_entry+0x278>   <== ALWAYS TAKEN
4001d838:	ea 04 60 08 	ld  [ %l1 + 8 ], %l5                           
4001d83c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
      eoffset = 0;                                                    
4001d840:	a4 10 20 00 	clr  %l2                                       <== NOT EXECUTED
    else                                                              
      eoffset = offset % rtems_rfs_fs_block_size (fs);                
                                                                      
    entry = rtems_rfs_buffer_data (&buffer) + eoffset;                
4001d844:	c2 07 bf ac 	ld  [ %fp + -84 ], %g1                         
                                                                      
    while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001d848:	9e 05 7f f6 	add  %l5, -10, %o7                             
    if (search)                                                       
      eoffset = 0;                                                    
    else                                                              
      eoffset = offset % rtems_rfs_fs_block_size (fs);                
                                                                      
    entry = rtems_rfs_buffer_data (&buffer) + eoffset;                
4001d84c:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        
                                                                      
    while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001d850:	80 a3 c0 08 	cmp  %o7, %o0                                  
4001d854:	08 80 00 33 	bleu  4001d920 <rtems_rfs_dir_del_entry+0x1d8> <== NEVER TAKEN
4001d858:	ba 00 40 08 	add  %g1, %o0, %i5                             
    {                                                                 
      rtems_rfs_ino eino;                                             
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
4001d85c:	f8 0f 60 08 	ldub  [ %i5 + 8 ], %i4                         
4001d860:	c8 0f 60 09 	ldub  [ %i5 + 9 ], %g4                         
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001d864:	e0 0f 60 01 	ldub  [ %i5 + 1 ], %l0                         
4001d868:	c6 0f 60 02 	ldub  [ %i5 + 2 ], %g3                         
4001d86c:	c2 08 40 08 	ldub  [ %g1 + %o0 ], %g1                       
    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);                   
4001d870:	b9 2f 20 08 	sll  %i4, 8, %i4                               
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001d874:	c4 0f 60 03 	ldub  [ %i5 + 3 ], %g2                         
4001d878:	a1 2c 20 10 	sll  %l0, 0x10, %l0                            
    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);                   
4001d87c:	b8 17 00 04 	or  %i4, %g4, %i4                              
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001d880:	87 28 e0 08 	sll  %g3, 8, %g3                               
4001d884:	10 80 00 22 	b  4001d90c <rtems_rfs_dir_del_entry+0x1c4>    
4001d888:	83 28 60 18 	sll  %g1, 0x18, %g1                            
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
        break;                                                        
                                                                      
      if (rtems_rfs_dir_entry_valid (fs, elength, eino))              
4001d88c:	80 a7 20 0a 	cmp  %i4, 0xa                                  
4001d890:	04 80 00 33 	ble  4001d95c <rtems_rfs_dir_del_entry+0x214>  <== NEVER TAKEN
4001d894:	90 10 20 00 	clr  %o0                                       
4001d898:	c2 04 60 1c 	ld  [ %l1 + 0x1c ], %g1                        
4001d89c:	80 a7 00 01 	cmp  %i4, %g1                                  
4001d8a0:	1a 80 00 2f 	bcc  4001d95c <rtems_rfs_dir_del_entry+0x214>  <== NEVER TAKEN
4001d8a4:	80 a4 20 00 	cmp  %l0, 0                                    
4001d8a8:	02 80 00 2d 	be  4001d95c <rtems_rfs_dir_del_entry+0x214>   <== NEVER TAKEN
4001d8ac:	01 00 00 00 	nop                                            
4001d8b0:	c2 04 60 14 	ld  [ %l1 + 0x14 ], %g1                        
4001d8b4:	80 a0 40 10 	cmp  %g1, %l0                                  
4001d8b8:	0a 80 00 29 	bcs  4001d95c <rtems_rfs_dir_del_entry+0x214>  <== NEVER TAKEN
4001d8bc:	80 a6 80 10 	cmp  %i2, %l0                                  
                  rtems_rfs_inode_ino (dir), elength, eino, block, eoffset);
        rc = EIO;                                                     
        break;                                                        
      }                                                               
                                                                      
      if (ino == rtems_rfs_dir_entry_ino (entry))                     
4001d8c0:	02 80 00 45 	be  4001d9d4 <rtems_rfs_dir_del_entry+0x28c>   <== ALWAYS TAKEN
4001d8c4:	80 a4 e0 00 	cmp  %l3, 0                                    
        rtems_rfs_buffer_handle_close (fs, &buffer);                  
        rtems_rfs_block_map_close (fs, &map);                         
        return 0;                                                     
      }                                                               
                                                                      
      if (!search)                                                    
4001d8c8:	22 80 00 33 	be,a   4001d994 <rtems_rfs_dir_del_entry+0x24c><== NOT EXECUTED
4001d8cc:	b0 10 20 05 	mov  5, %i0                                    <== NOT EXECUTED
        rc = EIO;                                                     
        break;                                                        
      }                                                               
                                                                      
      entry   += elength;                                             
      eoffset += elength;                                             
4001d8d0:	a4 04 80 1c 	add  %l2, %i4, %l2                             <== 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))
4001d8d4:	80 a4 80 0f 	cmp  %l2, %o7                                  <== NOT EXECUTED
4001d8d8:	1a 80 00 12 	bcc  4001d920 <rtems_rfs_dir_del_entry+0x1d8>  <== NOT EXECUTED
4001d8dc:	ba 07 40 1c 	add  %i5, %i4, %i5                             <== NOT EXECUTED
    {                                                                 
      rtems_rfs_ino eino;                                             
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
4001d8e0:	f8 0f 60 08 	ldub  [ %i5 + 8 ], %i4                         <== NOT EXECUTED
4001d8e4:	c8 0f 60 09 	ldub  [ %i5 + 9 ], %g4                         <== NOT EXECUTED
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001d8e8:	e0 0f 40 00 	ldub  [ %i5 ], %l0                             <== NOT EXECUTED
4001d8ec:	c6 0f 60 01 	ldub  [ %i5 + 1 ], %g3                         <== NOT EXECUTED
4001d8f0:	c2 0f 60 02 	ldub  [ %i5 + 2 ], %g1                         <== NOT EXECUTED
4001d8f4:	c4 0f 60 03 	ldub  [ %i5 + 3 ], %g2                         <== 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);                   
4001d8f8:	b9 2f 20 08 	sll  %i4, 8, %i4                               <== NOT EXECUTED
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001d8fc:	a1 2c 20 18 	sll  %l0, 0x18, %l0                            <== 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);                   
4001d900:	b8 17 00 04 	or  %i4, %g4, %i4                              <== NOT EXECUTED
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001d904:	87 28 e0 10 	sll  %g3, 0x10, %g3                            <== NOT EXECUTED
4001d908:	83 28 60 08 	sll  %g1, 8, %g1                               <== NOT EXECUTED
4001d90c:	a0 14 00 03 	or  %l0, %g3, %l0                              
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
4001d910:	80 a7 00 14 	cmp  %i4, %l4                                  
    {                                                                 
      rtems_rfs_ino eino;                                             
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001d914:	a0 14 00 02 	or  %l0, %g2, %l0                              
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
4001d918:	12 bf ff dd 	bne  4001d88c <rtems_rfs_dir_del_entry+0x144>  <== ALWAYS TAKEN
4001d91c:	a0 14 00 01 	or  %l0, %g1, %l0                              
                                                                      
      entry   += elength;                                             
      eoffset += elength;                                             
    }                                                                 
                                                                      
    if (rc == 0)                                                      
4001d920:	80 a6 20 00 	cmp  %i0, 0                                    <== NOT EXECUTED
4001d924:	12 80 00 1d 	bne  4001d998 <rtems_rfs_dir_del_entry+0x250>  <== NOT EXECUTED
4001d928:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
    {                                                                 
      rc = rtems_rfs_block_map_next_block (fs, &map, &block);         
4001d92c:	90 10 00 11 	mov  %l1, %o0                                  <== NOT EXECUTED
4001d930:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
4001d934:	7f ff f8 83 	call  4001bb40 <rtems_rfs_block_map_next_block><== NOT EXECUTED
4001d938:	94 07 bf a0 	add  %fp, -96, %o2                             <== NOT EXECUTED
      if (rc == ENXIO)                                                
4001d93c:	80 a2 20 06 	cmp  %o0, 6                                    <== NOT EXECUTED
4001d940:	02 80 00 85 	be  4001db54 <rtems_rfs_dir_del_entry+0x40c>   <== NOT EXECUTED
4001d944:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
  /*                                                                  
   * Only search if the offset is 0 else we are at that position.     
   */                                                                 
  search = offset ? false : true;                                     
                                                                      
  while (rc == 0)                                                     
4001d948:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4001d94c:	02 bf ff b3 	be  4001d818 <rtems_rfs_dir_del_entry+0xd0>    <== NOT EXECUTED
4001d950:	d4 07 bf a0 	ld  [ %fp + -96 ], %o2                         <== 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);                       
4001d954:	10 80 00 11 	b  4001d998 <rtems_rfs_dir_del_entry+0x250>    <== NOT EXECUTED
4001d958:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
        break;                                                        
                                                                      
      if (rtems_rfs_dir_entry_valid (fs, elength, eino))              
      {                                                               
        if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))          
4001d95c:	7f ff d9 52 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001d960:	13 10 00 00 	sethi  %hi(0x40000000), %o1                    <== NOT EXECUTED
4001d964:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001d968:	22 80 00 0b 	be,a   4001d994 <rtems_rfs_dir_del_entry+0x24c><== NOT EXECUTED
4001d96c:	b0 10 20 05 	mov  5, %i0                                    <== NOT EXECUTED
          printf ("rtems-rfs: dir-del-entry: "                        
4001d970:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
4001d974:	d8 07 bf a0 	ld  [ %fp + -96 ], %o4                         <== NOT EXECUTED
4001d978:	11 10 00 dd 	sethi  %hi(0x40037400), %o0                    <== NOT EXECUTED
4001d97c:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
4001d980:	90 12 22 f0 	or  %o0, 0x2f0, %o0                            <== NOT EXECUTED
4001d984:	96 10 00 10 	mov  %l0, %o3                                  <== NOT EXECUTED
4001d988:	40 00 19 7d 	call  40023f7c <printf>                        <== NOT EXECUTED
4001d98c:	9a 10 00 12 	mov  %l2, %o5                                  <== NOT EXECUTED
        }                                                             
                                                                      
        rtems_rfs_buffer_mark_dirty (&buffer);                        
        rtems_rfs_buffer_handle_close (fs, &buffer);                  
        rtems_rfs_block_map_close (fs, &map);                         
        return 0;                                                     
4001d990:	b0 10 20 05 	mov  5, %i0                                    <== NOT EXECUTED
4001d994:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
4001d998:	7f ff fa a8 	call  4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001d99c:	90 10 00 11 	mov  %l1, %o0                                  <== NOT EXECUTED
        rc = ENOENT;                                                  
    }                                                                 
  }                                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &buffer);                        
  rtems_rfs_block_map_close (fs, &map);                               
4001d9a0:	90 10 00 11 	mov  %l1, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
4001d9a4:	c0 2f bf a4 	clrb  [ %fp + -92 ]                            <== NOT EXECUTED
  handle->bnum  = 0;                                                  
4001d9a8:	c0 27 bf a8 	clr  [ %fp + -88 ]                             <== NOT EXECUTED
  handle->buffer = NULL;                                              
4001d9ac:	c0 27 bf ac 	clr  [ %fp + -84 ]                             <== NOT EXECUTED
4001d9b0:	7f ff f7 79 	call  4001b794 <rtems_rfs_block_map_close>     <== NOT EXECUTED
4001d9b4:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
4001d9b8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001d9bc:	81 e8 00 00 	restore                                        <== NOT EXECUTED
     * skip to the offset in the block.                               
     */                                                               
    if (search)                                                       
      eoffset = 0;                                                    
    else                                                              
      eoffset = offset % rtems_rfs_fs_block_size (fs);                
4001d9c0:	90 10 00 1b 	mov  %i3, %o0                                  
4001d9c4:	40 00 4b 04 	call  400305d4 <.urem>                         
4001d9c8:	92 10 00 15 	mov  %l5, %o1                                  
4001d9cc:	10 bf ff 9e 	b  4001d844 <rtems_rfs_dir_del_entry+0xfc>     
4001d9d0:	a4 10 00 08 	mov  %o0, %l2                                  
      }                                                               
                                                                      
      if (ino == rtems_rfs_dir_entry_ino (entry))                     
      {                                                               
        uint32_t remaining;                                           
        remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength);
4001d9d4:	82 07 00 12 	add  %i4, %l2, %g1                             
        memmove (entry, entry + elength, remaining);                  
4001d9d8:	92 07 40 1c 	add  %i5, %i4, %o1                             
      }                                                               
                                                                      
      if (ino == rtems_rfs_dir_entry_ino (entry))                     
      {                                                               
        uint32_t remaining;                                           
        remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength);
4001d9dc:	aa 25 40 01 	sub  %l5, %g1, %l5                             
        memmove (entry, entry + elength, remaining);                  
4001d9e0:	90 10 00 1d 	mov  %i5, %o0                                  
4001d9e4:	40 00 18 96 	call  40023c3c <memmove>                       
4001d9e8:	94 10 00 15 	mov  %l5, %o2                                  
        memset (entry + remaining, 0xff, elength);                    
4001d9ec:	92 10 20 ff 	mov  0xff, %o1                                 
4001d9f0:	94 10 00 1c 	mov  %i4, %o2                                  
4001d9f4:	40 00 18 e4 	call  40023d84 <memset>                        
4001d9f8:	90 07 40 15 	add  %i5, %l5, %o0                             
         * 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);                 
4001d9fc:	c2 0f 60 09 	ldub  [ %i5 + 9 ], %g1                         
4001da00:	c4 0f 60 08 	ldub  [ %i5 + 8 ], %g2                         
                                                                      
        if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))          
4001da04:	90 10 20 00 	clr  %o0                                       
         * 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);                 
4001da08:	bb 28 a0 08 	sll  %g2, 8, %i5                               
                                                                      
        if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))          
4001da0c:	13 10 00 00 	sethi  %hi(0x40000000), %o1                    
4001da10:	7f ff d9 25 	call  40013ea4 <rtems_rfs_trace>               
4001da14:	ba 17 40 01 	or  %i5, %g1, %i5                              
4001da18:	80 8a 20 ff 	btst  0xff, %o0                                
4001da1c:	02 80 00 17 	be  4001da78 <rtems_rfs_dir_del_entry+0x330>   <== ALWAYS TAKEN
4001da20:	03 3f ff c0 	sethi  %hi(0xffff0000), %g1                    
          printf ("rtems-rfs: dir-del-entry: "                        
                  "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");    
4001da24:	c2 07 bf c0 	ld  [ %fp + -64 ], %g1                         <== NOT EXECUTED
         *       also empty. This way we could clean up an empty directory.
         */                                                           
        elength = rtems_rfs_dir_entry_length (entry);                 
                                                                      
        if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))          
          printf ("rtems-rfs: dir-del-entry: "                        
4001da28:	d6 07 bf a0 	ld  [ %fp + -96 ], %o3                         <== NOT EXECUTED
4001da2c:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4001da30:	12 80 00 05 	bne  4001da44 <rtems_rfs_dir_del_entry+0x2fc>  <== NOT EXECUTED
4001da34:	c4 07 bf b8 	ld  [ %fp + -72 ], %g2                         <== 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");    
4001da38:	80 a0 a0 00 	cmp  %g2, 0                                    <== NOT EXECUTED
4001da3c:	02 80 00 3e 	be  4001db34 <rtems_rfs_dir_del_entry+0x3ec>   <== NOT EXECUTED
4001da40:	1b 10 00 d7 	sethi  %hi(0x40035c00), %o5                    <== NOT EXECUTED
4001da44:	84 00 bf ff 	add  %g2, -1, %g2                              <== NOT EXECUTED
4001da48:	80 a0 40 02 	cmp  %g1, %g2                                  <== NOT EXECUTED
4001da4c:	02 80 00 3a 	be  4001db34 <rtems_rfs_dir_del_entry+0x3ec>   <== NOT EXECUTED
4001da50:	1b 10 00 d7 	sethi  %hi(0x40035c00), %o5                    <== NOT EXECUTED
         *       also empty. This way we could clean up an empty directory.
         */                                                           
        elength = rtems_rfs_dir_entry_length (entry);                 
                                                                      
        if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))          
          printf ("rtems-rfs: dir-del-entry: "                        
4001da54:	1b 10 00 d1 	sethi  %hi(0x40034400), %o5                    <== NOT EXECUTED
4001da58:	9a 13 60 00 	mov  %o5, %o5	! 40034400 <__FUNCTION__.6193+0x338><== NOT EXECUTED
4001da5c:	11 10 00 dd 	sethi  %hi(0x40037400), %o0                    <== NOT EXECUTED
4001da60:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
4001da64:	90 12 23 40 	or  %o0, 0x340, %o0                            <== NOT EXECUTED
4001da68:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
4001da6c:	40 00 19 44 	call  40023f7c <printf>                        <== NOT EXECUTED
4001da70:	98 10 00 12 	mov  %l2, %o4                                  <== 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) &&                 
4001da74:	03 3f ff c0 	sethi  %hi(0xffff0000), %g1                    <== NOT EXECUTED
4001da78:	ba 38 40 1d 	xnor  %g1, %i5, %i5                            
4001da7c:	80 a7 60 00 	cmp  %i5, 0                                    
4001da80:	12 80 00 1f 	bne  4001dafc <rtems_rfs_dir_del_entry+0x3b4>  
4001da84:	80 a4 a0 00 	cmp  %l2, 0                                    
4001da88:	12 80 00 1d 	bne  4001dafc <rtems_rfs_dir_del_entry+0x3b4>  <== ALWAYS TAKEN
4001da8c:	c2 07 bf c0 	ld  [ %fp + -64 ], %g1                         
            (eoffset == 0) && rtems_rfs_block_map_last (&map))        
4001da90:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4001da94:	12 80 00 2a 	bne  4001db3c <rtems_rfs_dir_del_entry+0x3f4>  <== NOT EXECUTED
4001da98:	c4 07 bf b8 	ld  [ %fp + -72 ], %g2                         <== NOT EXECUTED
4001da9c:	80 a0 a0 00 	cmp  %g2, 0                                    <== NOT EXECUTED
4001daa0:	12 80 00 28 	bne  4001db40 <rtems_rfs_dir_del_entry+0x3f8>  <== NOT EXECUTED
4001daa4:	84 00 bf ff 	add  %g2, -1, %g2                              <== NOT EXECUTED
        {                                                             
          rc = rtems_rfs_block_map_shrink (fs, &map, 1);              
4001daa8:	90 10 00 11 	mov  %l1, %o0                                  <== NOT EXECUTED
4001daac:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
4001dab0:	7f ff f9 27 	call  4001bf4c <rtems_rfs_block_map_shrink>    <== NOT EXECUTED
4001dab4:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
          if (rc > 0)                                                 
4001dab8:	ba 92 20 00 	orcc  %o0, 0, %i5                              <== NOT EXECUTED
4001dabc:	04 80 00 10 	ble  4001dafc <rtems_rfs_dir_del_entry+0x3b4>  <== NOT EXECUTED
4001dac0:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
          {                                                           
            if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))      
4001dac4:	7f ff d8 f8 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001dac8:	13 10 00 00 	sethi  %hi(0x40000000), %o1                    <== NOT EXECUTED
4001dacc:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001dad0:	02 80 00 0c 	be  4001db00 <rtems_rfs_dir_del_entry+0x3b8>   <== NOT EXECUTED
4001dad4:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
              printf ("rtems-rfs: dir-del-entry: "                    
4001dad8:	f8 06 60 08 	ld  [ %i1 + 8 ], %i4                           <== NOT EXECUTED
4001dadc:	40 00 1d 72 	call  400250a4 <strerror>                      <== NOT EXECUTED
4001dae0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001dae4:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
4001dae8:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
4001daec:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
4001daf0:	11 10 00 dd 	sethi  %hi(0x40037400), %o0                    <== NOT EXECUTED
4001daf4:	40 00 19 22 	call  40023f7c <printf>                        <== NOT EXECUTED
4001daf8:	90 12 23 a0 	or  %o0, 0x3a0, %o0	! 400377a0 <CSWTCH.2+0xbb0><== 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);                        
4001dafc:	82 10 20 01 	mov  1, %g1                                    
 */                                                                   
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);                       
4001db00:	92 07 bf a4 	add  %fp, -92, %o1                             
4001db04:	90 10 00 11 	mov  %l1, %o0                                  
4001db08:	7f ff fa 4c 	call  4001c438 <rtems_rfs_buffer_handle_release>
4001db0c:	c2 2f bf a4 	stb  %g1, [ %fp + -92 ]                        
        rtems_rfs_buffer_handle_close (fs, &buffer);                  
        rtems_rfs_block_map_close (fs, &map);                         
        return 0;                                                     
4001db10:	b0 10 20 00 	clr  %i0                                       
          }                                                           
        }                                                             
                                                                      
        rtems_rfs_buffer_mark_dirty (&buffer);                        
        rtems_rfs_buffer_handle_close (fs, &buffer);                  
        rtems_rfs_block_map_close (fs, &map);                         
4001db14:	90 10 00 11 	mov  %l1, %o0                                  
  handle->dirty = false;                                              
4001db18:	c0 2f bf a4 	clrb  [ %fp + -92 ]                            
  handle->bnum  = 0;                                                  
4001db1c:	c0 27 bf a8 	clr  [ %fp + -88 ]                             
  handle->buffer = NULL;                                              
4001db20:	c0 27 bf ac 	clr  [ %fp + -84 ]                             
4001db24:	7f ff f7 1c 	call  4001b794 <rtems_rfs_block_map_close>     
4001db28:	92 07 bf b0 	add  %fp, -80, %o1                             
4001db2c:	81 c7 e0 08 	ret                                            
4001db30:	81 e8 00 00 	restore                                        
         *       also empty. This way we could clean up an empty directory.
         */                                                           
        elength = rtems_rfs_dir_entry_length (entry);                 
                                                                      
        if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))          
          printf ("rtems-rfs: dir-del-entry: "                        
4001db34:	10 bf ff ca 	b  4001da5c <rtems_rfs_dir_del_entry+0x314>    <== NOT EXECUTED
4001db38:	9a 13 61 50 	or  %o5, 0x150, %o5                            <== 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))        
4001db3c:	84 00 bf ff 	add  %g2, -1, %g2                              <== NOT EXECUTED
4001db40:	80 a0 40 02 	cmp  %g1, %g2                                  <== NOT EXECUTED
4001db44:	12 bf ff ef 	bne  4001db00 <rtems_rfs_dir_del_entry+0x3b8>  <== NOT EXECUTED
4001db48:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
        {                                                             
          rc = rtems_rfs_block_map_shrink (fs, &map, 1);              
4001db4c:	10 bf ff d8 	b  4001daac <rtems_rfs_dir_del_entry+0x364>    <== NOT EXECUTED
4001db50:	90 10 00 11 	mov  %l1, %o0                                  <== NOT EXECUTED
                                                                      
    if (rc == 0)                                                      
    {                                                                 
      rc = rtems_rfs_block_map_next_block (fs, &map, &block);         
      if (rc == ENXIO)                                                
        rc = ENOENT;                                                  
4001db54:	10 bf ff 90 	b  4001d994 <rtems_rfs_dir_del_entry+0x24c>    <== NOT EXECUTED
4001db58:	b0 10 20 02 	mov  2, %i0                                    <== NOT EXECUTED
    int      eoffset;                                                 
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);  
    if (rc > 0)                                                       
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))            
4001db5c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001db60:	7f ff d8 d1 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001db64:	13 10 00 00 	sethi  %hi(0x40000000), %o1                    <== NOT EXECUTED
4001db68:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001db6c:	22 bf ff 8b 	be,a   4001d998 <rtems_rfs_dir_del_entry+0x250><== NOT EXECUTED
4001db70:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
        printf ("rtems-rfs: dir-del-entry: "                          
4001db74:	fa 06 60 08 	ld  [ %i1 + 8 ], %i5                           <== NOT EXECUTED
4001db78:	40 00 1d 4b 	call  400250a4 <strerror>                      <== NOT EXECUTED
4001db7c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001db80:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
4001db84:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
4001db88:	94 10 00 18 	mov  %i0, %o2                                  <== NOT EXECUTED
4001db8c:	11 10 00 dd 	sethi  %hi(0x40037400), %o0                    <== NOT EXECUTED
4001db90:	40 00 18 fb 	call  40023f7c <printf>                        <== NOT EXECUTED
4001db94:	90 12 22 a8 	or  %o0, 0x2a8, %o0	! 400376a8 <CSWTCH.2+0xab8><== 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);                       
4001db98:	10 bf ff 80 	b  4001d998 <rtems_rfs_dir_del_entry+0x250>    <== NOT EXECUTED
4001db9c:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
                                                                      

4001df54 <rtems_rfs_dir_empty>: } int rtems_rfs_dir_empty (rtems_rfs_file_system* fs, rtems_rfs_inode_handle* dir) {
4001df54:	9d e3 bf 40 	save  %sp, -192, %sp                           
  rtems_rfs_buffer_handle buffer;                                     
  rtems_rfs_block_no      block;                                      
  bool                    empty;                                      
  int                     rc;                                         
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))                     
4001df58:	90 10 20 00 	clr  %o0                                       
4001df5c:	13 20 00 00 	sethi  %hi(0x80000000), %o1                    
4001df60:	7f ff d7 d1 	call  40013ea4 <rtems_rfs_trace>               
4001df64:	b4 10 00 18 	mov  %i0, %i2                                  
4001df68:	80 8a 20 ff 	btst  0xff, %o0                                
4001df6c:	12 80 00 0a 	bne  4001df94 <rtems_rfs_dir_empty+0x40>       <== NEVER TAKEN
4001df70:	92 10 00 19 	mov  %i1, %o1                                  
    printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir));
                                                                      
  empty = true;                                                       
                                                                      
  rc = rtems_rfs_block_map_open (fs, dir, &map);                      
4001df74:	90 10 00 1a 	mov  %i2, %o0                                  
4001df78:	7f ff f5 a6 	call  4001b610 <rtems_rfs_block_map_open>      
4001df7c:	94 07 bf b0 	add  %fp, -80, %o2                             
  if (rc > 0)                                                         
4001df80:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001df84:	04 80 00 0f 	ble  4001dfc0 <rtems_rfs_dir_empty+0x6c>       <== ALWAYS TAKEN
4001df88:	90 10 00 1a 	mov  %i2, %o0                                  
    rc = ENOTEMPTY;                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &buffer);                        
  rtems_rfs_block_map_close (fs, &map);                               
  return rc;                                                          
}                                                                     
4001df8c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001df90:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  rtems_rfs_block_no      block;                                      
  bool                    empty;                                      
  int                     rc;                                         
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))                     
    printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir));
4001df94:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
4001df98:	11 10 00 de 	sethi  %hi(0x40037800), %o0                    <== NOT EXECUTED
4001df9c:	40 00 17 f8 	call  40023f7c <printf>                        <== NOT EXECUTED
4001dfa0:	90 12 20 d0 	or  %o0, 0xd0, %o0	! 400378d0 <CSWTCH.2+0xce0> <== NOT EXECUTED
                                                                      
  empty = true;                                                       
                                                                      
  rc = rtems_rfs_block_map_open (fs, dir, &map);                      
4001dfa4:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
4001dfa8:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
4001dfac:	7f ff f5 99 	call  4001b610 <rtems_rfs_block_map_open>      <== NOT EXECUTED
4001dfb0:	94 07 bf b0 	add  %fp, -80, %o2                             <== NOT EXECUTED
  if (rc > 0)                                                         
4001dfb4:	b0 92 20 00 	orcc  %o0, 0, %i0                              <== NOT EXECUTED
4001dfb8:	14 bf ff f5 	bg  4001df8c <rtems_rfs_dir_empty+0x38>        <== NOT EXECUTED
4001dfbc:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
    return rc;                                                        
                                                                      
  rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);                
4001dfc0:	92 07 bf b0 	add  %fp, -80, %o1                             
4001dfc4:	94 10 20 00 	clr  %o2                                       
4001dfc8:	96 10 20 00 	clr  %o3                                       
4001dfcc:	7f ff f6 c0 	call  4001bacc <rtems_rfs_block_map_seek>      
4001dfd0:	98 07 bf a0 	add  %fp, -96, %o4                             
  if (rc > 0)                                                         
4001dfd4:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001dfd8:	14 80 00 7d 	bg  4001e1cc <rtems_rfs_dir_empty+0x278>       <== NEVER TAKEN
4001dfdc:	23 00 00 3f 	sethi  %hi(0xfc00), %l1                        
        break;                                                        
                                                                      
      if (rtems_rfs_dir_entry_valid (fs, elength, eino))              
      {                                                               
        if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))              
          printf ("rtems-rfs: dir-empty: "                            
4001dfe0:	21 10 00 de 	sethi  %hi(0x40037800), %l0                    
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
4001dfe4:	c0 2f bf a4 	clrb  [ %fp + -92 ]                            
  handle->bnum  = 0;                                                  
4001dfe8:	c0 27 bf a8 	clr  [ %fp + -88 ]                             
  handle->buffer = NULL;                                              
4001dfec:	c0 27 bf ac 	clr  [ %fp + -84 ]                             
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
      eino    = rtems_rfs_dir_entry_ino (entry);                      
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
4001dff0:	a2 14 63 ff 	or  %l1, 0x3ff, %l1                            
        break;                                                        
                                                                      
      if (rtems_rfs_dir_entry_valid (fs, elength, eino))              
      {                                                               
        if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))              
          printf ("rtems-rfs: dir-empty: "                            
4001dff4:	a0 14 20 f0 	or  %l0, 0xf0, %l0                             
  while (empty)                                                       
  {                                                                   
    uint8_t* entry;                                                   
    int      offset;                                                  
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);  
4001dff8:	d4 07 bf a0 	ld  [ %fp + -96 ], %o2                         
4001dffc:	90 10 00 1a 	mov  %i2, %o0                                  
4001e000:	92 07 bf a4 	add  %fp, -92, %o1                             
4001e004:	7f ff f9 87 	call  4001c620 <rtems_rfs_buffer_handle_request>
4001e008:	96 10 20 01 	mov  1, %o3                                    
    if (rc > 0)                                                       
4001e00c:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001e010:	14 80 00 4d 	bg  4001e144 <rtems_rfs_dir_empty+0x1f0>       <== NEVER TAKEN
4001e014:	c2 07 bf ac 	ld  [ %fp + -84 ], %g1                         
      break;                                                          
                                                                      
    entry  = rtems_rfs_buffer_data (&buffer);                         
    offset = 0;                                                       
                                                                      
    while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001e018:	da 06 a0 08 	ld  [ %i2 + 8 ], %o5                           
4001e01c:	9a 83 7f f6 	addcc  %o5, -10, %o5                           
4001e020:	02 80 00 5f 	be  4001e19c <rtems_rfs_dir_empty+0x248>       <== NEVER TAKEN
4001e024:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        
    {                                                                 
      rtems_rfs_ino eino;                                             
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
4001e028:	fa 08 60 08 	ldub  [ %g1 + 8 ], %i5                         
4001e02c:	f6 08 60 09 	ldub  [ %g1 + 9 ], %i3                         
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001e030:	f8 08 40 00 	ldub  [ %g1 ], %i4                             
4001e034:	c8 08 60 02 	ldub  [ %g1 + 2 ], %g4                         
4001e038:	c6 08 60 03 	ldub  [ %g1 + 3 ], %g3                         
4001e03c:	c4 08 60 01 	ldub  [ %g1 + 1 ], %g2                         
    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);                   
4001e040:	bb 2f 60 08 	sll  %i5, 8, %i5                               
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001e044:	b9 2f 20 18 	sll  %i4, 0x18, %i4                            
    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);                   
4001e048:	ba 17 40 1b 	or  %i5, %i3, %i5                              
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001e04c:	89 29 20 08 	sll  %g4, 8, %g4                               
4001e050:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
4001e054:	b8 17 00 04 	or  %i4, %g4, %i4                              
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
4001e058:	80 a7 40 11 	cmp  %i5, %l1                                  
    {                                                                 
      rtems_rfs_ino eino;                                             
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001e05c:	b8 17 00 03 	or  %i4, %g3, %i4                              
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
4001e060:	02 80 00 4f 	be  4001e19c <rtems_rfs_dir_empty+0x248>       <== NEVER TAKEN
4001e064:	b8 17 00 02 	or  %i4, %g2, %i4                              
4001e068:	10 80 00 20 	b  4001e0e8 <rtems_rfs_dir_empty+0x194>        
4001e06c:	b6 10 20 00 	clr  %i3                                       
      /*                                                              
       * Ignore the current (.) and parent (..) entries. Anything else means
       * the directory is not empty.                                  
       */                                                             
      if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) ||             
           (entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.')) &&               
4001e070:	12 80 00 31 	bne  4001e134 <rtems_rfs_dir_empty+0x1e0>      
4001e074:	80 a0 00 18 	cmp  %g0, %i0                                  
          ((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 2)) ||             
4001e078:	c4 08 60 0a 	ldub  [ %g1 + 0xa ], %g2                       
4001e07c:	80 a0 a0 2e 	cmp  %g2, 0x2e                                 
4001e080:	12 80 00 2d 	bne  4001e134 <rtems_rfs_dir_empty+0x1e0>      <== NEVER TAKEN
4001e084:	80 a0 00 18 	cmp  %g0, %i0                                  
           (entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.') ||                
4001e088:	c4 08 60 0b 	ldub  [ %g1 + 0xb ], %g2                       
4001e08c:	80 a0 a0 2e 	cmp  %g2, 0x2e                                 
4001e090:	12 80 00 29 	bne  4001e134 <rtems_rfs_dir_empty+0x1e0>      <== NEVER TAKEN
4001e094:	80 a0 00 18 	cmp  %g0, %i0                                  
        empty = false;                                                
        break;                                                        
      }                                                               
                                                                      
      entry  += elength;                                              
      offset += elength;                                              
4001e098:	b6 06 c0 1d 	add  %i3, %i5, %i3                             
      break;                                                          
                                                                      
    entry  = rtems_rfs_buffer_data (&buffer);                         
    offset = 0;                                                       
                                                                      
    while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001e09c:	80 a6 c0 0d 	cmp  %i3, %o5                                  
4001e0a0:	1a 80 00 3f 	bcc  4001e19c <rtems_rfs_dir_empty+0x248>      <== NEVER TAKEN
4001e0a4:	82 00 40 1d 	add  %g1, %i5, %g1                             
    {                                                                 
      rtems_rfs_ino eino;                                             
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
4001e0a8:	fa 08 60 08 	ldub  [ %g1 + 8 ], %i5                         
4001e0ac:	de 08 60 09 	ldub  [ %g1 + 9 ], %o7                         
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001e0b0:	f8 08 40 00 	ldub  [ %g1 ], %i4                             
4001e0b4:	c8 08 60 01 	ldub  [ %g1 + 1 ], %g4                         
4001e0b8:	c6 08 60 03 	ldub  [ %g1 + 3 ], %g3                         
4001e0bc:	c4 08 60 02 	ldub  [ %g1 + 2 ], %g2                         
    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);                   
4001e0c0:	bb 2f 60 08 	sll  %i5, 8, %i5                               
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001e0c4:	b9 2f 20 18 	sll  %i4, 0x18, %i4                            
    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);                   
4001e0c8:	ba 17 40 0f 	or  %i5, %o7, %i5                              
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001e0cc:	89 29 20 10 	sll  %g4, 0x10, %g4                            
4001e0d0:	85 28 a0 08 	sll  %g2, 8, %g2                               
4001e0d4:	b8 17 00 04 	or  %i4, %g4, %i4                              
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
4001e0d8:	80 a7 40 11 	cmp  %i5, %l1                                  
    {                                                                 
      rtems_rfs_ino eino;                                             
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001e0dc:	b8 17 00 03 	or  %i4, %g3, %i4                              
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
4001e0e0:	02 80 00 2f 	be  4001e19c <rtems_rfs_dir_empty+0x248>       
4001e0e4:	b8 17 00 02 	or  %i4, %g2, %i4                              
        break;                                                        
                                                                      
      if (rtems_rfs_dir_entry_valid (fs, elength, eino))              
4001e0e8:	80 a7 60 0a 	cmp  %i5, 0xa                                  
4001e0ec:	04 80 00 21 	ble  4001e170 <rtems_rfs_dir_empty+0x21c>      <== NEVER TAKEN
4001e0f0:	90 10 20 01 	mov  1, %o0                                    
4001e0f4:	c4 06 a0 1c 	ld  [ %i2 + 0x1c ], %g2                        
4001e0f8:	80 a7 40 02 	cmp  %i5, %g2                                  
4001e0fc:	1a 80 00 1d 	bcc  4001e170 <rtems_rfs_dir_empty+0x21c>      <== NEVER TAKEN
4001e100:	80 a7 20 00 	cmp  %i4, 0                                    
4001e104:	02 80 00 1b 	be  4001e170 <rtems_rfs_dir_empty+0x21c>       <== NEVER TAKEN
4001e108:	01 00 00 00 	nop                                            
4001e10c:	c4 06 a0 14 	ld  [ %i2 + 0x14 ], %g2                        
4001e110:	80 a0 80 1c 	cmp  %g2, %i4                                  
4001e114:	0a 80 00 17 	bcs  4001e170 <rtems_rfs_dir_empty+0x21c>      <== NEVER TAKEN
4001e118:	80 a7 60 0b 	cmp  %i5, 0xb                                  
                                                                      
      /*                                                              
       * Ignore the current (.) and parent (..) entries. Anything else means
       * the directory is not empty.                                  
       */                                                             
      if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) ||             
4001e11c:	12 bf ff d5 	bne  4001e070 <rtems_rfs_dir_empty+0x11c>      
4001e120:	80 a7 60 0c 	cmp  %i5, 0xc                                  
4001e124:	c4 08 60 0a 	ldub  [ %g1 + 0xa ], %g2                       
4001e128:	80 a0 a0 2e 	cmp  %g2, 0x2e                                 
4001e12c:	02 bf ff db 	be  4001e098 <rtems_rfs_dir_empty+0x144>       <== ALWAYS TAKEN
4001e130:	80 a0 00 18 	cmp  %g0, %i0                                  
4001e134:	82 60 3f ff 	subx  %g0, -1, %g1                             
        break;                                                        
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if ((rc == 0) && !empty)                                            
4001e138:	80 88 60 ff 	btst  0xff, %g1                                
4001e13c:	32 80 00 02 	bne,a   4001e144 <rtems_rfs_dir_empty+0x1f0>   <== ALWAYS TAKEN
4001e140:	b0 10 20 5a 	mov  0x5a, %i0                                 
 */                                                                   
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);                       
4001e144:	92 07 bf a4 	add  %fp, -92, %o1                             
4001e148:	7f ff f8 bc 	call  4001c438 <rtems_rfs_buffer_handle_release>
4001e14c:	90 10 00 1a 	mov  %i2, %o0                                  
    rc = ENOTEMPTY;                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &buffer);                        
  rtems_rfs_block_map_close (fs, &map);                               
4001e150:	90 10 00 1a 	mov  %i2, %o0                                  
  handle->dirty = false;                                              
4001e154:	c0 2f bf a4 	clrb  [ %fp + -92 ]                            
  handle->bnum  = 0;                                                  
4001e158:	c0 27 bf a8 	clr  [ %fp + -88 ]                             
  handle->buffer = NULL;                                              
4001e15c:	c0 27 bf ac 	clr  [ %fp + -84 ]                             
4001e160:	7f ff f5 8d 	call  4001b794 <rtems_rfs_block_map_close>     
4001e164:	92 07 bf b0 	add  %fp, -80, %o1                             
4001e168:	81 c7 e0 08 	ret                                            
4001e16c:	81 e8 00 00 	restore                                        
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
        break;                                                        
                                                                      
      if (rtems_rfs_dir_entry_valid (fs, elength, eino))              
      {                                                               
        if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))              
4001e170:	7f ff d7 4d 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001e174:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4001e178:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001e17c:	02 80 00 09 	be  4001e1a0 <rtems_rfs_dir_empty+0x24c>       <== NOT EXECUTED
4001e180:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
          printf ("rtems-rfs: dir-empty: "                            
4001e184:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
4001e188:	90 10 00 10 	mov  %l0, %o0                                  <== NOT EXECUTED
4001e18c:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
4001e190:	96 10 00 1c 	mov  %i4, %o3                                  <== NOT EXECUTED
4001e194:	40 00 17 7a 	call  40023f7c <printf>                        <== NOT EXECUTED
4001e198:	98 10 00 1b 	mov  %i3, %o4                                  <== NOT EXECUTED
      offset += elength;                                              
    }                                                                 
                                                                      
    if (empty)                                                        
    {                                                                 
      rc = rtems_rfs_block_map_next_block (fs, &map, &block);         
4001e19c:	90 10 00 1a 	mov  %i2, %o0                                  
4001e1a0:	92 07 bf b0 	add  %fp, -80, %o1                             
4001e1a4:	7f ff f6 67 	call  4001bb40 <rtems_rfs_block_map_next_block>
4001e1a8:	94 07 bf a0 	add  %fp, -96, %o2                             
      if (rc > 0)                                                     
4001e1ac:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001e1b0:	04 bf ff 93 	ble  4001dffc <rtems_rfs_dir_empty+0xa8>       <== NEVER TAKEN
4001e1b4:	d4 07 bf a0 	ld  [ %fp + -96 ], %o2                         
      {                                                               
        if (rc == ENXIO)                                              
          rc = 0;                                                     
4001e1b8:	82 1e 20 06 	xor  %i0, 6, %g1                               
4001e1bc:	80 a0 00 01 	cmp  %g0, %g1                                  
4001e1c0:	82 60 20 00 	subx  %g0, 0, %g1                              
4001e1c4:	10 bf ff e0 	b  4001e144 <rtems_rfs_dir_empty+0x1f0>        
4001e1c8:	b0 0e 00 01 	and  %i0, %g1, %i0                             
    return rc;                                                        
                                                                      
  rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);                
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_block_map_close (fs, &map);                             
4001e1cc:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
4001e1d0:	7f ff f5 71 	call  4001b794 <rtems_rfs_block_map_close>     <== NOT EXECUTED
4001e1d4:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
4001e1d8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001e1dc:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40022578 <rtems_rfs_dir_hash>: */ #define initval (20010928) uint32_t rtems_rfs_dir_hash (const void *key, size_t length) {
40022578:	9d e3 bf a0 	save  %sp, -96, %sp                            
  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;              
4002257c:	09 37 f7 c5 	sethi  %hi(0xdfdf1400), %g4                    
                                                                      
  } 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)                                               
40022580:	82 10 00 18 	mov  %i0, %g1                                  
{                                                                     
  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;              
40022584:	88 11 22 9f 	or  %g4, 0x29f, %g4                            
                                                                      
  } 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)                                               
40022588:	80 a6 60 0c 	cmp  %i1, 0xc                                  
{                                                                     
  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;              
4002258c:	88 06 40 04 	add  %i1, %g4, %g4                             
                                                                      
  } 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)                                               
40022590:	84 10 00 04 	mov  %g4, %g2                                  
40022594:	08 80 00 4b 	bleu  400226c0 <rtems_rfs_dir_hash+0x148>      
40022598:	86 10 00 04 	mov  %g4, %g3                                  
      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;                                     
      c += ((uint32_t)k[11])<<24;                                     
4002259c:	f8 08 60 0b 	ldub  [ %g1 + 0xb ], %i4                       
    while (length > 12)                                               
    {                                                                 
      a += k[0];                                                      
      a += ((uint32_t)k[1])<<8;                                       
      a += ((uint32_t)k[2])<<16;                                      
      a += ((uint32_t)k[3])<<24;                                      
400225a0:	fa 08 60 03 	ldub  [ %g1 + 3 ], %i5                         
      b += k[4];                                                      
      b += ((uint32_t)k[5])<<8;                                       
400225a4:	d8 08 60 05 	ldub  [ %g1 + 5 ], %o4                         
      b += ((uint32_t)k[6])<<16;                                      
400225a8:	d0 08 60 06 	ldub  [ %g1 + 6 ], %o0                         
    {                                                                 
      a += k[0];                                                      
      a += ((uint32_t)k[1])<<8;                                       
      a += ((uint32_t)k[2])<<16;                                      
      a += ((uint32_t)k[3])<<24;                                      
      b += k[4];                                                      
400225ac:	d2 08 60 04 	ldub  [ %g1 + 4 ], %o1                         
      b += ((uint32_t)k[5])<<8;                                       
      b += ((uint32_t)k[6])<<16;                                      
      b += ((uint32_t)k[7])<<24;                                      
400225b0:	d4 08 60 07 	ldub  [ %g1 + 7 ], %o2                         
      c += k[8];                                                      
      c += ((uint32_t)k[9])<<8;                                       
400225b4:	d6 08 60 09 	ldub  [ %g1 + 9 ], %o3                         
      c += ((uint32_t)k[10])<<16;                                     
400225b8:	f0 08 60 0a 	ldub  [ %g1 + 0xa ], %i0                       
      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];                                                      
400225bc:	da 08 60 08 	ldub  [ %g1 + 8 ], %o5                         
                                                                      
    /*--------------- 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;                                       
400225c0:	de 08 60 01 	ldub  [ %g1 + 1 ], %o7                         
      a += ((uint32_t)k[2])<<16;                                      
400225c4:	f6 08 60 02 	ldub  [ %g1 + 2 ], %i3                         
    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];                                                      
400225c8:	f4 08 40 00 	ldub  [ %g1 ], %i2                             
      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;                                     
      c += ((uint32_t)k[11])<<24;                                     
400225cc:	b9 2f 20 18 	sll  %i4, 0x18, %i4                            
    while (length > 12)                                               
    {                                                                 
      a += k[0];                                                      
      a += ((uint32_t)k[1])<<8;                                       
      a += ((uint32_t)k[2])<<16;                                      
      a += ((uint32_t)k[3])<<24;                                      
400225d0:	bb 2f 60 18 	sll  %i5, 0x18, %i5                            
      b += k[4];                                                      
      b += ((uint32_t)k[5])<<8;                                       
400225d4:	99 2b 20 08 	sll  %o4, 8, %o4                               
      b += ((uint32_t)k[6])<<16;                                      
400225d8:	91 2a 20 10 	sll  %o0, 0x10, %o0                            
      b += ((uint32_t)k[7])<<24;                                      
400225dc:	95 2a a0 18 	sll  %o2, 0x18, %o2                            
    {                                                                 
      a += k[0];                                                      
      a += ((uint32_t)k[1])<<8;                                       
      a += ((uint32_t)k[2])<<16;                                      
      a += ((uint32_t)k[3])<<24;                                      
      b += k[4];                                                      
400225e0:	98 03 00 08 	add  %o4, %o0, %o4                             
      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;                                       
400225e4:	97 2a e0 08 	sll  %o3, 8, %o3                               
      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;                                       
400225e8:	98 03 00 09 	add  %o4, %o1, %o4                             
      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;                                     
400225ec:	b1 2e 20 10 	sll  %i0, 0x10, %i0                            
      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;                                      
400225f0:	98 03 00 0a 	add  %o4, %o2, %o4                             
      b += ((uint32_t)k[7])<<24;                                      
      c += k[8];                                                      
400225f4:	b0 02 c0 18 	add  %o3, %i0, %i0                             
      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;                                      
400225f8:	84 03 00 02 	add  %o4, %g2, %g2                             
      c += k[8];                                                      
      c += ((uint32_t)k[9])<<8;                                       
400225fc:	b0 06 00 0d 	add  %i0, %o5, %i0                             
                                                                      
    /*--------------- 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;                                       
40022600:	9f 2b e0 08 	sll  %o7, 8, %o7                               
      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;                                     
40022604:	b0 06 00 1c 	add  %i0, %i4, %i0                             
    /*--------------- 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;                                      
40022608:	b7 2e e0 10 	sll  %i3, 0x10, %i3                            
      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;                                     
      c += ((uint32_t)k[11])<<24;                                     
4002260c:	b0 06 00 04 	add  %i0, %g4, %i0                             
    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];                                                      
40022610:	b6 03 c0 1b 	add  %o7, %i3, %i3                             
      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);                                                     
40022614:	88 06 00 02 	add  %i0, %g2, %g4                             
40022618:	b9 2e 20 04 	sll  %i0, 4, %i4                               
                                                                      
    /*--------------- 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;                                       
4002261c:	b6 06 c0 1a 	add  %i3, %i2, %i3                             
      a += ((uint32_t)k[2])<<16;                                      
40022620:	b6 06 c0 1d 	add  %i3, %i5, %i3                             
      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);                                                     
40022624:	bb 36 20 1c 	srl  %i0, 0x1c, %i5                            
    while (length > 12)                                               
    {                                                                 
      a += k[0];                                                      
      a += ((uint32_t)k[1])<<8;                                       
      a += ((uint32_t)k[2])<<16;                                      
      a += ((uint32_t)k[3])<<24;                                      
40022628:	b0 26 c0 18 	sub  %i3, %i0, %i0                             
      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);                                                     
4002262c:	ba 17 00 1d 	or  %i4, %i5, %i5                              
40022630:	86 06 00 03 	add  %i0, %g3, %g3                             
40022634:	b8 18 c0 1d 	xor  %g3, %i5, %i4                             
40022638:	86 07 00 04 	add  %i4, %g4, %g3                             
4002263c:	84 20 80 1c 	sub  %g2, %i4, %g2                             
40022640:	bb 2f 20 06 	sll  %i4, 6, %i5                               
40022644:	b9 37 20 1a 	srl  %i4, 0x1a, %i4                            
40022648:	ba 17 40 1c 	or  %i5, %i4, %i5                              
4002264c:	ba 1f 40 02 	xor  %i5, %g2, %i5                             
40022650:	84 07 40 03 	add  %i5, %g3, %g2                             
40022654:	88 21 00 1d 	sub  %g4, %i5, %g4                             
40022658:	b9 2f 60 08 	sll  %i5, 8, %i4                               
4002265c:	bb 37 60 18 	srl  %i5, 0x18, %i5                            
40022660:	ba 17 00 1d 	or  %i4, %i5, %i5                              
40022664:	88 1f 40 04 	xor  %i5, %g4, %g4                             
40022668:	b0 01 00 02 	add  %g4, %g2, %i0                             
4002266c:	bb 29 20 10 	sll  %g4, 0x10, %i5                            
40022670:	86 20 c0 04 	sub  %g3, %g4, %g3                             
40022674:	89 31 20 10 	srl  %g4, 0x10, %g4                            
40022678:	88 17 40 04 	or  %i5, %g4, %g4                              
4002267c:	86 19 00 03 	xor  %g4, %g3, %g3                             
40022680:	bb 28 e0 13 	sll  %g3, 0x13, %i5                            
40022684:	89 30 e0 0d 	srl  %g3, 0xd, %g4                             
40022688:	88 17 40 04 	or  %i5, %g4, %g4                              
4002268c:	84 20 80 03 	sub  %g2, %g3, %g2                             
      length -= 12;                                                   
40022690:	b2 06 7f f4 	add  %i1, -12, %i1                             
      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);                                                     
40022694:	84 19 00 02 	xor  %g4, %g2, %g2                             
40022698:	86 00 c0 18 	add  %g3, %i0, %g3                             
4002269c:	bb 28 a0 04 	sll  %g2, 4, %i5                               
400226a0:	b0 26 00 02 	sub  %i0, %g2, %i0                             
400226a4:	89 30 a0 1c 	srl  %g2, 0x1c, %g4                            
      length -= 12;                                                   
      k += 12;                                                        
400226a8:	82 00 60 0c 	add  %g1, 0xc, %g1                             
      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);                                                     
400226ac:	88 17 40 04 	or  %i5, %g4, %g4                              
                                                                      
  } 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)                                               
400226b0:	80 a6 60 0c 	cmp  %i1, 0xc                                  
      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);                                                     
400226b4:	84 00 80 03 	add  %g2, %g3, %g2                             
                                                                      
  } 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)                                               
400226b8:	18 bf ff b9 	bgu  4002259c <rtems_rfs_dir_hash+0x24>        <== NEVER TAKEN
400226bc:	88 19 00 18 	xor  %g4, %i0, %g4                             
      length -= 12;                                                   
      k += 12;                                                        
    }                                                                 
                                                                      
    /*-------------------------------- last block: affect all 32 bits of (c) */
    switch(length)                   /* all the case statements fall through */
400226c0:	b3 2e 60 02 	sll  %i1, 2, %i1                               
400226c4:	3b 10 00 89 	sethi  %hi(0x40022400), %i5                    
400226c8:	ba 17 61 44 	or  %i5, 0x144, %i5	! 40022544 <rtems_rfs_buffer_bdbuf_release+0x8c>
400226cc:	fa 07 40 19 	ld  [ %i5 + %i1 ], %i5                         
400226d0:	81 c7 40 00 	jmp  %i5                                       
400226d4:	01 00 00 00 	nop                                            
    {                                                                 
      case 12: c+=((uint32_t)k[11])<<24;                              
400226d8:	fa 08 60 0b 	ldub  [ %g1 + 0xb ], %i5                       
400226dc:	bb 2f 60 18 	sll  %i5, 0x18, %i5                            
400226e0:	88 01 00 1d 	add  %g4, %i5, %g4                             
      case 11: c+=((uint32_t)k[10])<<16;                              
400226e4:	fa 08 60 0a 	ldub  [ %g1 + 0xa ], %i5                       
400226e8:	bb 2f 60 10 	sll  %i5, 0x10, %i5                            
400226ec:	88 01 00 1d 	add  %g4, %i5, %g4                             
      case 10: c+=((uint32_t)k[9])<<8;                                
400226f0:	fa 08 60 09 	ldub  [ %g1 + 9 ], %i5                         
400226f4:	bb 2f 60 08 	sll  %i5, 8, %i5                               
400226f8:	88 01 00 1d 	add  %g4, %i5, %g4                             
      case 9 : c+=k[8];                                               
400226fc:	fa 08 60 08 	ldub  [ %g1 + 8 ], %i5                         
40022700:	88 01 00 1d 	add  %g4, %i5, %g4                             
      case 8 : b+=((uint32_t)k[7])<<24;                               
40022704:	fa 08 60 07 	ldub  [ %g1 + 7 ], %i5                         
40022708:	bb 2f 60 18 	sll  %i5, 0x18, %i5                            
4002270c:	84 00 80 1d 	add  %g2, %i5, %g2                             
      case 7 : b+=((uint32_t)k[6])<<16;                               
40022710:	fa 08 60 06 	ldub  [ %g1 + 6 ], %i5                         
40022714:	bb 2f 60 10 	sll  %i5, 0x10, %i5                            
40022718:	84 00 80 1d 	add  %g2, %i5, %g2                             
      case 6 : b+=((uint32_t)k[5])<<8;                                
4002271c:	fa 08 60 05 	ldub  [ %g1 + 5 ], %i5                         
40022720:	bb 2f 60 08 	sll  %i5, 8, %i5                               
40022724:	84 00 80 1d 	add  %g2, %i5, %g2                             
      case 5 : b+=k[4];                                               
40022728:	fa 08 60 04 	ldub  [ %g1 + 4 ], %i5                         
4002272c:	84 00 80 1d 	add  %g2, %i5, %g2                             
      case 4 : a+=((uint32_t)k[3])<<24;                               
40022730:	fa 08 60 03 	ldub  [ %g1 + 3 ], %i5                         
40022734:	bb 2f 60 18 	sll  %i5, 0x18, %i5                            
40022738:	86 00 c0 1d 	add  %g3, %i5, %g3                             
      case 3 : a+=((uint32_t)k[2])<<16;                               
4002273c:	fa 08 60 02 	ldub  [ %g1 + 2 ], %i5                         
40022740:	bb 2f 60 10 	sll  %i5, 0x10, %i5                            
40022744:	86 00 c0 1d 	add  %g3, %i5, %g3                             
      case 2 : a+=((uint32_t)k[1])<<8;                                
40022748:	fa 08 60 01 	ldub  [ %g1 + 1 ], %i5                         
4002274c:	bb 2f 60 08 	sll  %i5, 8, %i5                               
40022750:	86 00 c0 1d 	add  %g3, %i5, %g3                             
      case 1 : a+=k[0];                                               
40022754:	c2 08 40 00 	ldub  [ %g1 ], %g1                             
        break;                                                        
      case 0 : return c;                                              
    }                                                                 
  }                                                                   
                                                                      
  final(a,b,c);                                                       
40022758:	bb 30 a0 12 	srl  %g2, 0x12, %i5                            
      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];                                               
4002275c:	86 00 c0 01 	add  %g3, %g1, %g3                             
        break;                                                        
      case 0 : return c;                                              
    }                                                                 
  }                                                                   
                                                                      
  final(a,b,c);                                                       
40022760:	83 28 a0 0e 	sll  %g2, 0xe, %g1                             
40022764:	82 17 40 01 	or  %i5, %g1, %g1                              
40022768:	88 19 00 02 	xor  %g4, %g2, %g4                             
4002276c:	88 21 00 01 	sub  %g4, %g1, %g4                             
40022770:	bb 29 20 0b 	sll  %g4, 0xb, %i5                             
40022774:	83 31 20 15 	srl  %g4, 0x15, %g1                            
40022778:	82 17 40 01 	or  %i5, %g1, %g1                              
4002277c:	86 19 00 03 	xor  %g4, %g3, %g3                             
40022780:	86 20 c0 01 	sub  %g3, %g1, %g3                             
40022784:	bb 28 e0 19 	sll  %g3, 0x19, %i5                            
40022788:	83 30 e0 07 	srl  %g3, 7, %g1                               
4002278c:	82 17 40 01 	or  %i5, %g1, %g1                              
40022790:	84 18 c0 02 	xor  %g3, %g2, %g2                             
40022794:	84 20 80 01 	sub  %g2, %g1, %g2                             
40022798:	bb 28 a0 10 	sll  %g2, 0x10, %i5                            
4002279c:	83 30 a0 10 	srl  %g2, 0x10, %g1                            
400227a0:	82 17 40 01 	or  %i5, %g1, %g1                              
400227a4:	88 18 80 04 	xor  %g2, %g4, %g4                             
400227a8:	88 21 00 01 	sub  %g4, %g1, %g4                             
400227ac:	bb 29 20 04 	sll  %g4, 4, %i5                               
400227b0:	83 31 20 1c 	srl  %g4, 0x1c, %g1                            
400227b4:	82 17 40 01 	or  %i5, %g1, %g1                              
400227b8:	86 19 00 03 	xor  %g4, %g3, %g3                             
400227bc:	86 20 c0 01 	sub  %g3, %g1, %g3                             
400227c0:	84 18 c0 02 	xor  %g3, %g2, %g2                             
400227c4:	83 28 e0 0e 	sll  %g3, 0xe, %g1                             
400227c8:	87 30 e0 12 	srl  %g3, 0x12, %g3                            
400227cc:	86 10 40 03 	or  %g1, %g3, %g3                              
400227d0:	84 20 80 03 	sub  %g2, %g3, %g2                             
400227d4:	88 18 80 04 	xor  %g2, %g4, %g4                             
400227d8:	b1 28 a0 18 	sll  %g2, 0x18, %i0                            
400227dc:	85 30 a0 08 	srl  %g2, 8, %g2                               
400227e0:	84 16 00 02 	or  %i0, %g2, %g2                              
400227e4:	88 21 00 02 	sub  %g4, %g2, %g4                             
  return c;                                                           
}                                                                     
400227e8:	81 c7 e0 08 	ret                                            
400227ec:	91 e8 00 04 	restore  %g0, %g4, %o0                         
                                                                      

4001cde8 <rtems_rfs_dir_lookup_ino>: rtems_rfs_inode_handle* inode, const char* name, int length, rtems_rfs_ino* ino, uint32_t* offset) {
4001cde8:	9d e3 bf 40 	save  %sp, -192, %sp                           
  rtems_rfs_block_map     map;                                        
  rtems_rfs_buffer_handle entries;                                    
  int                     rc;                                         
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))               
4001cdec:	90 10 20 00 	clr  %o0                                       
4001cdf0:	13 01 00 00 	sethi  %hi(0x4000000), %o1                     
4001cdf4:	7f ff dc 2c 	call  40013ea4 <rtems_rfs_trace>               
4001cdf8:	a2 10 00 18 	mov  %i0, %l1                                  
4001cdfc:	80 8a 20 ff 	btst  0xff, %o0                                
4001ce00:	12 80 00 1c 	bne  4001ce70 <rtems_rfs_dir_lookup_ino+0x88>  <== NEVER TAKEN
4001ce04:	92 10 00 19 	mov  %i1, %o1                                  
    for (c = 0; c < length; c++)                                      
      printf ("%c", name[c]);                                         
    printf (", len=%d\n", length);                                    
  }                                                                   
                                                                      
  *ino = RTEMS_RFS_EMPTY_INO;                                         
4001ce08:	c0 27 00 00 	clr  [ %i4 ]                                   
  *offset = 0;                                                        
4001ce0c:	c0 27 40 00 	clr  [ %i5 ]                                   
                                                                      
  rc = rtems_rfs_block_map_open (fs, inode, &map);                    
4001ce10:	90 10 00 11 	mov  %l1, %o0                                  
4001ce14:	7f ff f9 ff 	call  4001b610 <rtems_rfs_block_map_open>      
4001ce18:	94 07 bf b0 	add  %fp, -80, %o2                             
  if (rc > 0)                                                         
4001ce1c:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001ce20:	24 80 00 30 	ble,a   4001cee0 <rtems_rfs_dir_lookup_ino+0xf8><== ALWAYS TAKEN
4001ce24:	92 10 00 1b 	mov  %i3, %o1                                  
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))             
4001ce28:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001ce2c:	7f ff dc 1e 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001ce30:	13 01 00 00 	sethi  %hi(0x4000000), %o1                     <== NOT EXECUTED
4001ce34:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001ce38:	32 80 00 04 	bne,a   4001ce48 <rtems_rfs_dir_lookup_ino+0x60><== NOT EXECUTED
4001ce3c:	fa 06 60 08 	ld  [ %i1 + 8 ], %i5                           <== NOT EXECUTED
  }                                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &entries);                       
  rtems_rfs_block_map_close (fs, &map);                               
  return rc;                                                          
}                                                                     
4001ce40:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001ce44:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_block_map_open (fs, inode, &map);                    
  if (rc > 0)                                                         
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))             
      printf ("rtems-rfs: dir-lookup-ino: map open failed for ino %" PRIu32 ": %d: %s",
4001ce48:	40 00 20 97 	call  400250a4 <strerror>                      <== NOT EXECUTED
4001ce4c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001ce50:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
4001ce54:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
4001ce58:	94 10 00 18 	mov  %i0, %o2                                  <== NOT EXECUTED
4001ce5c:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
4001ce60:	40 00 1c 47 	call  40023f7c <printf>                        <== NOT EXECUTED
4001ce64:	90 12 22 80 	or  %o0, 0x280, %o0	! 40037280 <CSWTCH.2+0x690><== NOT EXECUTED
4001ce68:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001ce6c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  int                     rc;                                         
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))               
  {                                                                   
    int c;                                                            
    printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=",
4001ce70:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
4001ce74:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
4001ce78:	40 00 1c 41 	call  40023f7c <printf>                        <== NOT EXECUTED
4001ce7c:	90 12 22 38 	or  %o0, 0x238, %o0	! 40037238 <CSWTCH.2+0x648><== NOT EXECUTED
4001ce80:	b0 10 00 1a 	mov  %i2, %i0                                  <== NOT EXECUTED
            inode->ino);                                              
    for (c = 0; c < length; c++)                                      
4001ce84:	80 a6 e0 00 	cmp  %i3, 0                                    <== NOT EXECUTED
4001ce88:	04 80 00 08 	ble  4001cea8 <rtems_rfs_dir_lookup_ino+0xc0>  <== NOT EXECUTED
4001ce8c:	a0 06 80 1b 	add  %i2, %i3, %l0                             <== NOT EXECUTED
      printf ("%c", name[c]);                                         
4001ce90:	d0 4e 00 00 	ldsb  [ %i0 ], %o0                             <== NOT EXECUTED
4001ce94:	40 00 1c a4 	call  40024124 <putchar>                       <== NOT EXECUTED
4001ce98:	b0 06 20 01 	inc  %i0                                       <== NOT EXECUTED
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))               
  {                                                                   
    int c;                                                            
    printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=",
            inode->ino);                                              
    for (c = 0; c < length; c++)                                      
4001ce9c:	80 a6 00 10 	cmp  %i0, %l0                                  <== NOT EXECUTED
4001cea0:	32 bf ff fd 	bne,a   4001ce94 <rtems_rfs_dir_lookup_ino+0xac><== NOT EXECUTED
4001cea4:	d0 4e 00 00 	ldsb  [ %i0 ], %o0                             <== NOT EXECUTED
      printf ("%c", name[c]);                                         
    printf (", len=%d\n", length);                                    
4001cea8:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
4001ceac:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
4001ceb0:	40 00 1c 33 	call  40023f7c <printf>                        <== NOT EXECUTED
4001ceb4:	90 12 22 70 	or  %o0, 0x270, %o0	! 40037270 <CSWTCH.2+0x680><== NOT EXECUTED
  }                                                                   
                                                                      
  *ino = RTEMS_RFS_EMPTY_INO;                                         
4001ceb8:	c0 27 00 00 	clr  [ %i4 ]                                   <== NOT EXECUTED
  *offset = 0;                                                        
4001cebc:	c0 27 40 00 	clr  [ %i5 ]                                   <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_block_map_open (fs, inode, &map);                    
4001cec0:	90 10 00 11 	mov  %l1, %o0                                  <== NOT EXECUTED
4001cec4:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
4001cec8:	7f ff f9 d2 	call  4001b610 <rtems_rfs_block_map_open>      <== NOT EXECUTED
4001cecc:	94 07 bf b0 	add  %fp, -80, %o2                             <== NOT EXECUTED
  if (rc > 0)                                                         
4001ced0:	b0 92 20 00 	orcc  %o0, 0, %i0                              <== NOT EXECUTED
4001ced4:	14 bf ff d6 	bg  4001ce2c <rtems_rfs_dir_lookup_ino+0x44>   <== NOT EXECUTED
4001ced8:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
    uint32_t           hash;                                          
                                                                      
    /*                                                                
     * Calculate the hash of the look up string.                      
     */                                                               
    hash = rtems_rfs_dir_hash (name, length);                         
4001cedc:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
4001cee0:	c0 2f bf a4 	clrb  [ %fp + -92 ]                            
  handle->bnum  = 0;                                                  
4001cee4:	c0 27 bf a8 	clr  [ %fp + -88 ]                             
  handle->buffer = NULL;                                              
4001cee8:	c0 27 bf ac 	clr  [ %fp + -84 ]                             
4001ceec:	40 00 15 a3 	call  40022578 <rtems_rfs_dir_hash>            
4001cef0:	90 10 00 1a 	mov  %i2, %o0                                  
                                                                      
    /*                                                                
     * 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);              
4001cef4:	92 07 bf b0 	add  %fp, -80, %o1                             
    uint32_t           hash;                                          
                                                                      
    /*                                                                
     * Calculate the hash of the look up string.                      
     */                                                               
    hash = rtems_rfs_dir_hash (name, length);                         
4001cef8:	a6 10 00 08 	mov  %o0, %l3                                  
                                                                      
    /*                                                                
     * 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);              
4001cefc:	94 10 20 00 	clr  %o2                                       
4001cf00:	90 10 00 11 	mov  %l1, %o0                                  
4001cf04:	96 10 20 00 	clr  %o3                                       
4001cf08:	7f ff fa f1 	call  4001bacc <rtems_rfs_block_map_seek>      
4001cf0c:	98 07 bf a0 	add  %fp, -96, %o4                             
    if (rc > 0)                                                       
4001cf10:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001cf14:	04 80 00 15 	ble  4001cf68 <rtems_rfs_dir_lookup_ino+0x180> <== ALWAYS TAKEN
4001cf18:	90 10 20 00 	clr  %o0                                       
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))           
4001cf1c:	7f ff db e2 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001cf20:	13 01 00 00 	sethi  %hi(0x4000000), %o1                     <== NOT EXECUTED
4001cf24:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001cf28:	12 80 00 bf 	bne  4001d224 <rtems_rfs_dir_lookup_ino+0x43c> <== NOT EXECUTED
4001cf2c:	01 00 00 00 	nop                                            <== NOT EXECUTED
        printf ("rtems-rfs: dir-lookup-ino: block map find failed: %d: %s\n",
                rc, strerror (rc));                                   
      if (rc == ENXIO)                                                
4001cf30:	80 a6 20 06 	cmp  %i0, 6                                    <== NOT EXECUTED
4001cf34:	22 80 00 02 	be,a   4001cf3c <rtems_rfs_dir_lookup_ino+0x154><== NOT EXECUTED
4001cf38:	b0 10 20 02 	mov  2, %i0                                    <== 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);                       
4001cf3c:	92 07 bf a4 	add  %fp, -92, %o1                             
4001cf40:	7f ff fd 3e 	call  4001c438 <rtems_rfs_buffer_handle_release>
4001cf44:	90 10 00 11 	mov  %l1, %o0                                  
                rtems_rfs_inode_ino (inode), rc, strerror (rc));      
    }                                                                 
  }                                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &entries);                       
  rtems_rfs_block_map_close (fs, &map);                               
4001cf48:	90 10 00 11 	mov  %l1, %o0                                  
  handle->dirty = false;                                              
4001cf4c:	c0 2f bf a4 	clrb  [ %fp + -92 ]                            
  handle->bnum  = 0;                                                  
4001cf50:	c0 27 bf a8 	clr  [ %fp + -88 ]                             
  handle->buffer = NULL;                                              
4001cf54:	c0 27 bf ac 	clr  [ %fp + -84 ]                             
4001cf58:	7f ff fa 0f 	call  4001b794 <rtems_rfs_block_map_close>     
4001cf5c:	92 07 bf b0 	add  %fp, -80, %o1                             
4001cf60:	81 c7 e0 08 	ret                                            
4001cf64:	81 e8 00 00 	restore                                        
    while ((rc == 0) && block)                                        
    {                                                                 
      uint8_t* entry;                                                 
                                                                      
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))           
        printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
4001cf68:	2d 10 00 dc 	sethi  %hi(0x40037000), %l6                    
                                                                      
        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)                     
4001cf6c:	25 00 00 3f 	sethi  %hi(0xfc00), %l2                        
        }                                                             
                                                                      
        if (ehash == hash)                                            
        {                                                             
          if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK)) 
            printf ("rtems-rfs: dir-lookup-ino: "                     
4001cf70:	2b 10 00 dc 	sethi  %hi(0x40037000), %l5                    
    while ((rc == 0) && block)                                        
    {                                                                 
      uint8_t* entry;                                                 
                                                                      
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))           
        printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
4001cf74:	ac 15 a3 00 	or  %l6, 0x300, %l6                            
                                                                      
        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)                     
4001cf78:	a4 14 a3 ff 	or  %l2, 0x3ff, %l2                            
        }                                                             
                                                                      
        if (ehash == hash)                                            
        {                                                             
          if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK)) 
            printf ("rtems-rfs: dir-lookup-ino: "                     
4001cf7c:	aa 15 63 d0 	or  %l5, 0x3d0, %l5                            
      rtems_rfs_buffer_handle_close (fs, &entries);                   
      rtems_rfs_block_map_close (fs, &map);                           
      return rc;                                                      
    }                                                                 
                                                                      
    while ((rc == 0) && block)                                        
4001cf80:	80 a6 20 00 	cmp  %i0, 0                                    
4001cf84:	12 80 00 6b 	bne  4001d130 <rtems_rfs_dir_lookup_ino+0x348> <== NEVER TAKEN
4001cf88:	c2 07 bf a0 	ld  [ %fp + -96 ], %g1                         
4001cf8c:	80 a0 60 00 	cmp  %g1, 0                                    
4001cf90:	02 80 00 d3 	be  4001d2dc <rtems_rfs_dir_lookup_ino+0x4f4>  <== NEVER TAKEN
4001cf94:	90 10 20 00 	clr  %o0                                       
    {                                                                 
      uint8_t* entry;                                                 
                                                                      
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))           
4001cf98:	7f ff db c3 	call  40013ea4 <rtems_rfs_trace>               
4001cf9c:	13 01 00 00 	sethi  %hi(0x4000000), %o1                     
4001cfa0:	80 8a 20 ff 	btst  0xff, %o0                                
4001cfa4:	32 80 00 87 	bne,a   4001d1c0 <rtems_rfs_dir_lookup_ino+0x3d8><== NEVER TAKEN
4001cfa8:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
        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);
4001cfac:	d4 07 bf a0 	ld  [ %fp + -96 ], %o2                         
4001cfb0:	90 10 00 11 	mov  %l1, %o0                                  
4001cfb4:	92 07 bf a4 	add  %fp, -92, %o1                             
4001cfb8:	7f ff fd 9a 	call  4001c620 <rtems_rfs_buffer_handle_request>
4001cfbc:	96 10 20 01 	mov  1, %o3                                    
      if (rc > 0)                                                     
4001cfc0:	a8 92 20 00 	orcc  %o0, 0, %l4                              
4001cfc4:	14 80 00 b3 	bg  4001d290 <rtems_rfs_dir_lookup_ino+0x4a8>  <== NEVER TAKEN
4001cfc8:	c2 07 bf ac 	ld  [ %fp + -84 ], %g1                         
                                                                      
      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))
4001cfcc:	d8 04 60 08 	ld  [ %l1 + 8 ], %o4                           
       * means the entry is empty.                                    
       */                                                             
                                                                      
      entry = rtems_rfs_buffer_data (&entries);                       
                                                                      
      map.bpos.boff = 0;                                              
4001cfd0:	c0 27 bf c4 	clr  [ %fp + -60 ]                             
                                                                      
      while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001cfd4:	80 a3 20 0a 	cmp  %o4, 0xa                                  
4001cfd8:	12 80 00 0a 	bne  4001d000 <rtems_rfs_dir_lookup_ino+0x218> <== ALWAYS TAKEN
4001cfdc:	e0 00 60 1c 	ld  [ %g1 + 0x1c ], %l0                        
                                                                      
        map.bpos.boff += elength;                                     
        entry += elength;                                             
      }                                                               
                                                                      
      if (rc == 0)                                                    
4001cfe0:	10 80 00 47 	b  4001d0fc <rtems_rfs_dir_lookup_ino+0x314>   <== NOT EXECUTED
4001cfe4:	80 a5 20 00 	cmp  %l4, 0                                    <== 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))
4001cfe8:	86 03 3f f6 	add  %o4, -10, %g3                             
            rtems_rfs_block_map_close (fs, &map);                     
            return 0;                                                 
          }                                                           
        }                                                             
                                                                      
        map.bpos.boff += elength;                                     
4001cfec:	84 05 c0 02 	add  %l7, %g2, %g2                             
4001cff0:	c4 27 bf c4 	st  %g2, [ %fp + -60 ]                         
                                                                      
      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))
4001cff4:	80 a0 c0 02 	cmp  %g3, %g2                                  
4001cff8:	08 80 00 40 	bleu  4001d0f8 <rtems_rfs_dir_lookup_ino+0x310><== NEVER TAKEN
4001cffc:	a0 04 00 17 	add  %l0, %l7, %l0                             
        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);                       
4001d000:	c4 0c 00 00 	ldub  [ %l0 ], %g2                             
4001d004:	d0 0c 20 01 	ldub  [ %l0 + 1 ], %o0                         
4001d008:	d2 0c 20 03 	ldub  [ %l0 + 3 ], %o1                         
4001d00c:	d4 0c 20 02 	ldub  [ %l0 + 2 ], %o2                         
      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);                    
4001d010:	d6 0c 20 04 	ldub  [ %l0 + 4 ], %o3                         
4001d014:	c8 0c 20 05 	ldub  [ %l0 + 5 ], %g4                         
4001d018:	da 0c 20 07 	ldub  [ %l0 + 7 ], %o5                         
4001d01c:	c6 0c 20 06 	ldub  [ %l0 + 6 ], %g3                         
        elength = rtems_rfs_dir_entry_length (entry);                 
4001d020:	c2 0c 20 08 	ldub  [ %l0 + 8 ], %g1                         
4001d024:	de 0c 20 09 	ldub  [ %l0 + 9 ], %o7                         
        *ino = rtems_rfs_dir_entry_ino (entry);                       
4001d028:	85 28 a0 18 	sll  %g2, 0x18, %g2                            
4001d02c:	91 2a 20 10 	sll  %o0, 0x10, %o0                            
4001d030:	95 2a a0 08 	sll  %o2, 8, %o2                               
4001d034:	84 10 80 08 	or  %g2, %o0, %g2                              
4001d038:	84 10 80 09 	or  %g2, %o1, %g2                              
4001d03c:	84 10 80 0a 	or  %g2, %o2, %g2                              
4001d040:	c4 27 00 00 	st  %g2, [ %i4 ]                               
      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);                    
4001d044:	97 2a e0 18 	sll  %o3, 0x18, %o3                            
4001d048:	89 29 20 10 	sll  %g4, 0x10, %g4                            
4001d04c:	87 28 e0 08 	sll  %g3, 8, %g3                               
4001d050:	88 12 c0 04 	or  %o3, %g4, %g4                              
        elength = rtems_rfs_dir_entry_length (entry);                 
4001d054:	83 28 60 08 	sll  %g1, 8, %g1                               
      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);                    
4001d058:	88 11 00 0d 	or  %g4, %o5, %g4                              
        elength = rtems_rfs_dir_entry_length (entry);                 
4001d05c:	ae 10 40 0f 	or  %g1, %o7, %l7                              
        *ino = rtems_rfs_dir_entry_ino (entry);                       
                                                                      
        if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                     
4001d060:	80 a5 c0 12 	cmp  %l7, %l2                                  
4001d064:	02 80 00 25 	be  4001d0f8 <rtems_rfs_dir_lookup_ino+0x310>  
4001d068:	86 11 00 03 	or  %g4, %g3, %g3                              
          break;                                                      
                                                                      
        if (rtems_rfs_dir_entry_valid (fs, elength, *ino))            
4001d06c:	80 a5 e0 0a 	cmp  %l7, 0xa                                  
4001d070:	24 80 00 34 	ble,a   4001d140 <rtems_rfs_dir_lookup_ino+0x358><== NEVER TAKEN
4001d074:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001d078:	de 04 60 1c 	ld  [ %l1 + 0x1c ], %o7                        
4001d07c:	80 a5 c0 0f 	cmp  %l7, %o7                                  
4001d080:	1a 80 00 2f 	bcc  4001d13c <rtems_rfs_dir_lookup_ino+0x354> <== NEVER TAKEN
4001d084:	80 a0 a0 00 	cmp  %g2, 0                                    
4001d088:	22 80 00 2e 	be,a   4001d140 <rtems_rfs_dir_lookup_ino+0x358><== NEVER TAKEN
4001d08c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001d090:	c8 04 60 14 	ld  [ %l1 + 0x14 ], %g4                        
4001d094:	80 a0 80 04 	cmp  %g2, %g4                                  
4001d098:	18 80 00 29 	bgu  4001d13c <rtems_rfs_dir_lookup_ino+0x354> <== NEVER TAKEN
4001d09c:	80 a0 c0 13 	cmp  %g3, %l3                                  
                    rtems_rfs_inode_ino (inode), elength, *ino, map.bpos.boff);
          rc = EIO;                                                   
          break;                                                      
        }                                                             
                                                                      
        if (ehash == hash)                                            
4001d0a0:	12 bf ff d2 	bne  4001cfe8 <rtems_rfs_dir_lookup_ino+0x200> 
4001d0a4:	c4 07 bf c4 	ld  [ %fp + -60 ], %g2                         
        {                                                             
          if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK)) 
4001d0a8:	90 10 20 00 	clr  %o0                                       
4001d0ac:	7f ff db 7e 	call  40013ea4 <rtems_rfs_trace>               
4001d0b0:	13 02 00 00 	sethi  %hi(0x8000000), %o1                     
4001d0b4:	80 8a 20 ff 	btst  0xff, %o0                                
4001d0b8:	32 80 00 32 	bne,a   4001d180 <rtems_rfs_dir_lookup_ino+0x398><== NEVER TAKEN
4001d0bc:	c8 0c 20 01 	ldub  [ %l0 + 1 ], %g4                         <== 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)
4001d0c0:	90 04 20 0a 	add  %l0, 0xa, %o0                             
4001d0c4:	92 10 00 1a 	mov  %i2, %o1                                  
4001d0c8:	40 00 1a 76 	call  40023aa0 <memcmp>                        
4001d0cc:	94 10 00 1b 	mov  %i3, %o2                                  
4001d0d0:	80 a2 20 00 	cmp  %o0, 0                                    
4001d0d4:	02 80 00 5d 	be  4001d248 <rtems_rfs_dir_lookup_ino+0x460>  <== ALWAYS TAKEN
4001d0d8:	c4 07 bf c4 	ld  [ %fp + -60 ], %g2                         
4001d0dc:	d8 04 60 08 	ld  [ %l1 + 8 ], %o4                           <== NOT EXECUTED
            rtems_rfs_block_map_close (fs, &map);                     
            return 0;                                                 
          }                                                           
        }                                                             
                                                                      
        map.bpos.boff += elength;                                     
4001d0e0:	84 05 c0 02 	add  %l7, %g2, %g2                             <== NOT EXECUTED
4001d0e4:	c4 27 bf c4 	st  %g2, [ %fp + -60 ]                         <== 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))
4001d0e8:	86 03 3f f6 	add  %o4, -10, %g3                             <== NOT EXECUTED
4001d0ec:	80 a0 c0 02 	cmp  %g3, %g2                                  <== NOT EXECUTED
4001d0f0:	18 bf ff c4 	bgu  4001d000 <rtems_rfs_dir_lookup_ino+0x218> <== NOT EXECUTED
4001d0f4:	a0 04 00 17 	add  %l0, %l7, %l0                             <== NOT EXECUTED
                                                                      
        map.bpos.boff += elength;                                     
        entry += elength;                                             
      }                                                               
                                                                      
      if (rc == 0)                                                    
4001d0f8:	80 a5 20 00 	cmp  %l4, 0                                    
4001d0fc:	32 bf ff 90 	bne,a   4001cf3c <rtems_rfs_dir_lookup_ino+0x154><== NEVER TAKEN
4001d100:	b0 10 00 14 	mov  %l4, %i0                                  <== NOT EXECUTED
      {                                                               
        rc = rtems_rfs_block_map_next_block (fs, &map, &block);       
4001d104:	90 10 00 11 	mov  %l1, %o0                                  
4001d108:	92 07 bf b0 	add  %fp, -80, %o1                             
4001d10c:	7f ff fa 8d 	call  4001bb40 <rtems_rfs_block_map_next_block>
4001d110:	94 07 bf a0 	add  %fp, -96, %o2                             
        if ((rc > 0) && (rc != ENXIO))                                
4001d114:	80 a2 20 06 	cmp  %o0, 6                                    
4001d118:	12 80 00 2f 	bne  4001d1d4 <rtems_rfs_dir_lookup_ino+0x3ec> <== NEVER TAKEN
4001d11c:	b0 10 00 08 	mov  %o0, %i0                                  
          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)                                              
4001d120:	80 a6 20 06 	cmp  %i0, 6                                    
4001d124:	12 bf ff 98 	bne  4001cf84 <rtems_rfs_dir_lookup_ino+0x19c> <== NEVER TAKEN
4001d128:	80 a6 20 00 	cmp  %i0, 0                                    
          rc = ENOENT;                                                
4001d12c:	b0 10 20 02 	mov  2, %i0                                    
      rtems_rfs_buffer_handle_close (fs, &entries);                   
      rtems_rfs_block_map_close (fs, &map);                           
      return rc;                                                      
    }                                                                 
                                                                      
    while ((rc == 0) && block)                                        
4001d130:	a8 10 00 18 	mov  %i0, %l4                                  
            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)                                              
          rc = ENOENT;                                                
4001d134:	10 bf ff 82 	b  4001cf3c <rtems_rfs_dir_lookup_ino+0x154>   
4001d138:	b0 10 00 14 	mov  %l4, %i0                                  
        if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                     
          break;                                                      
                                                                      
        if (rtems_rfs_dir_entry_valid (fs, elength, *ino))            
        {                                                             
          if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))       
4001d13c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001d140:	7f ff db 59 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001d144:	13 01 00 00 	sethi  %hi(0x4000000), %o1                     <== NOT EXECUTED
4001d148:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001d14c:	12 80 00 04 	bne  4001d15c <rtems_rfs_dir_lookup_ino+0x374> <== NOT EXECUTED
4001d150:	a8 10 20 05 	mov  5, %l4                                    <== NOT EXECUTED
            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)                                              
          rc = ENOENT;                                                
4001d154:	10 bf ff 7a 	b  4001cf3c <rtems_rfs_dir_lookup_ino+0x154>   <== NOT EXECUTED
4001d158:	b0 10 00 14 	mov  %l4, %i0                                  <== NOT EXECUTED
          break;                                                      
                                                                      
        if (rtems_rfs_dir_entry_valid (fs, elength, *ino))            
        {                                                             
          if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))       
            printf ("rtems-rfs: dir-lookup-ino: "                     
4001d15c:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
4001d160:	d6 07 00 00 	ld  [ %i4 ], %o3                               <== NOT EXECUTED
4001d164:	d8 07 bf c4 	ld  [ %fp + -60 ], %o4                         <== NOT EXECUTED
4001d168:	94 10 00 17 	mov  %l7, %o2                                  <== NOT EXECUTED
4001d16c:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
4001d170:	40 00 1b 83 	call  40023f7c <printf>                        <== NOT EXECUTED
4001d174:	90 12 23 80 	or  %o0, 0x380, %o0	! 40037380 <CSWTCH.2+0x790><== NOT EXECUTED
4001d178:	10 bf ff 71 	b  4001cf3c <rtems_rfs_dir_lookup_ino+0x154>   <== NOT EXECUTED
4001d17c:	b0 10 00 14 	mov  %l4, %i0                                  <== NOT EXECUTED
          if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK)) 
            printf ("rtems-rfs: dir-lookup-ino: "                     
                    "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));        
4001d180:	c4 0c 20 02 	ldub  [ %l0 + 2 ], %g2                         <== NOT EXECUTED
4001d184:	da 0c 00 00 	ldub  [ %l0 ], %o5                             <== NOT EXECUTED
4001d188:	c6 0c 20 03 	ldub  [ %l0 + 3 ], %g3                         <== NOT EXECUTED
        }                                                             
                                                                      
        if (ehash == hash)                                            
        {                                                             
          if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK)) 
            printf ("rtems-rfs: dir-lookup-ino: "                     
4001d18c:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
4001d190:	d4 1f bf c0 	ldd  [ %fp + -64 ], %o2                        <== 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));        
4001d194:	89 29 20 10 	sll  %g4, 0x10, %g4                            <== NOT EXECUTED
4001d198:	85 28 a0 08 	sll  %g2, 8, %g2                               <== NOT EXECUTED
4001d19c:	9b 2b 60 18 	sll  %o5, 0x18, %o5                            <== NOT EXECUTED
        }                                                             
                                                                      
        if (ehash == hash)                                            
        {                                                             
          if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK)) 
            printf ("rtems-rfs: dir-lookup-ino: "                     
4001d1a0:	90 10 00 15 	mov  %l5, %o0                                  <== 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));        
4001d1a4:	9a 13 40 04 	or  %o5, %g4, %o5                              <== NOT EXECUTED
        }                                                             
                                                                      
        if (ehash == hash)                                            
        {                                                             
          if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK)) 
            printf ("rtems-rfs: dir-lookup-ino: "                     
4001d1a8:	98 10 00 17 	mov  %l7, %o4                                  <== 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));        
4001d1ac:	9a 13 40 03 	or  %o5, %g3, %o5                              <== NOT EXECUTED
        }                                                             
                                                                      
        if (ehash == hash)                                            
        {                                                             
          if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK)) 
            printf ("rtems-rfs: dir-lookup-ino: "                     
4001d1b0:	40 00 1b 73 	call  40023f7c <printf>                        <== NOT EXECUTED
4001d1b4:	9a 13 40 02 	or  %o5, %g2, %o5                              <== 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)
4001d1b8:	10 bf ff c3 	b  4001d0c4 <rtems_rfs_dir_lookup_ino+0x2dc>   <== NOT EXECUTED
4001d1bc:	90 04 20 0a 	add  %l0, 0xa, %o0                             <== NOT EXECUTED
    while ((rc == 0) && block)                                        
    {                                                                 
      uint8_t* entry;                                                 
                                                                      
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))           
        printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
4001d1c0:	d4 07 bf c0 	ld  [ %fp + -64 ], %o2                         <== NOT EXECUTED
4001d1c4:	40 00 1b 6e 	call  40023f7c <printf>                        <== NOT EXECUTED
4001d1c8:	90 10 00 16 	mov  %l6, %o0                                  <== NOT EXECUTED
                rtems_rfs_inode_ino (inode), map.bpos.bno);           
                                                                      
      rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true);
4001d1cc:	10 bf ff 79 	b  4001cfb0 <rtems_rfs_dir_lookup_ino+0x1c8>   <== NOT EXECUTED
4001d1d0:	d4 07 bf a0 	ld  [ %fp + -96 ], %o2                         <== NOT EXECUTED
      }                                                               
                                                                      
      if (rc == 0)                                                    
      {                                                               
        rc = rtems_rfs_block_map_next_block (fs, &map, &block);       
        if ((rc > 0) && (rc != ENXIO))                                
4001d1d4:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4001d1d8:	04 bf ff d3 	ble  4001d124 <rtems_rfs_dir_lookup_ino+0x33c> <== NOT EXECUTED
4001d1dc:	80 a6 20 06 	cmp  %i0, 6                                    <== NOT EXECUTED
        {                                                             
          if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))       
4001d1e0:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001d1e4:	7f ff db 30 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001d1e8:	13 01 00 00 	sethi  %hi(0x4000000), %o1                     <== NOT EXECUTED
4001d1ec:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001d1f0:	22 bf ff cd 	be,a   4001d124 <rtems_rfs_dir_lookup_ino+0x33c><== NOT EXECUTED
4001d1f4:	80 a6 20 06 	cmp  %i0, 6                                    <== NOT EXECUTED
            printf ("rtems-rfs: dir-lookup-ino: "                     
4001d1f8:	e0 06 60 08 	ld  [ %i1 + 8 ], %l0                           <== NOT EXECUTED
4001d1fc:	40 00 1f aa 	call  400250a4 <strerror>                      <== NOT EXECUTED
4001d200:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001d204:	92 10 00 10 	mov  %l0, %o1                                  <== NOT EXECUTED
4001d208:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
4001d20c:	94 10 00 18 	mov  %i0, %o2                                  <== NOT EXECUTED
4001d210:	11 10 00 dd 	sethi  %hi(0x40037400), %o0                    <== NOT EXECUTED
4001d214:	40 00 1b 5a 	call  40023f7c <printf>                        <== NOT EXECUTED
4001d218:	90 12 20 78 	or  %o0, 0x78, %o0	! 40037478 <CSWTCH.2+0x888> <== NOT EXECUTED
      rtems_rfs_buffer_handle_close (fs, &entries);                   
      rtems_rfs_block_map_close (fs, &map);                           
      return rc;                                                      
    }                                                                 
                                                                      
    while ((rc == 0) && block)                                        
4001d21c:	10 bf ff 5a 	b  4001cf84 <rtems_rfs_dir_lookup_ino+0x19c>   <== NOT EXECUTED
4001d220:	80 a6 20 00 	cmp  %i0, 0                                    <== NOT EXECUTED
     */                                                               
    rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);              
    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",
4001d224:	40 00 1f a0 	call  400250a4 <strerror>                      <== NOT EXECUTED
4001d228:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001d22c:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
4001d230:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
4001d234:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
4001d238:	40 00 1b 51 	call  40023f7c <printf>                        <== NOT EXECUTED
4001d23c:	90 12 22 c0 	or  %o0, 0x2c0, %o0	! 400372c0 <CSWTCH.2+0x6d0><== NOT EXECUTED
                rc, strerror (rc));                                   
      if (rc == ENXIO)                                                
4001d240:	10 bf ff 3d 	b  4001cf34 <rtems_rfs_dir_lookup_ino+0x14c>   <== NOT EXECUTED
4001d244:	80 a6 20 06 	cmp  %i0, 6                                    <== 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);             
4001d248:	90 10 00 11 	mov  %l1, %o0                                  
4001d24c:	7f ff f8 bc 	call  4001b53c <rtems_rfs_block_get_pos>       
4001d250:	92 07 bf c0 	add  %fp, -64, %o1                             
                                                                      
            if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
4001d254:	90 10 20 00 	clr  %o0                                       
                    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);             
4001d258:	d2 27 40 00 	st  %o1, [ %i5 ]                               
                                                                      
            if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
4001d25c:	7f ff db 12 	call  40013ea4 <rtems_rfs_trace>               
4001d260:	13 04 00 00 	sethi  %hi(0x10000000), %o1                    
4001d264:	80 8a 20 ff 	btst  0xff, %o0                                
4001d268:	22 bf ff 36 	be,a   4001cf40 <rtems_rfs_dir_lookup_ino+0x158><== ALWAYS TAKEN
4001d26c:	92 07 bf a4 	add  %fp, -92, %o1                             
              printf ("rtems-rfs: dir-lookup-ino: "                   
4001d270:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
4001d274:	d4 07 00 00 	ld  [ %i4 ], %o2                               <== NOT EXECUTED
4001d278:	d6 07 40 00 	ld  [ %i5 ], %o3                               <== NOT EXECUTED
4001d27c:	11 10 00 dd 	sethi  %hi(0x40037400), %o0                    <== NOT EXECUTED
4001d280:	40 00 1b 3f 	call  40023f7c <printf>                        <== NOT EXECUTED
4001d284:	90 12 20 30 	or  %o0, 0x30, %o0	! 40037430 <CSWTCH.2+0x840> <== 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);                       
4001d288:	10 bf ff 2e 	b  4001cf40 <rtems_rfs_dir_lookup_ino+0x158>   <== NOT EXECUTED
4001d28c:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
                rtems_rfs_inode_ino (inode), map.bpos.bno);           
                                                                      
      rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true);
      if (rc > 0)                                                     
      {                                                               
        if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))         
4001d290:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001d294:	7f ff db 04 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001d298:	13 01 00 00 	sethi  %hi(0x4000000), %o1                     <== NOT EXECUTED
4001d29c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001d2a0:	22 bf ff 27 	be,a   4001cf3c <rtems_rfs_dir_lookup_ino+0x154><== NOT EXECUTED
4001d2a4:	b0 10 00 14 	mov  %l4, %i0                                  <== NOT EXECUTED
          printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " block=%" PRId32 ": %d: %s\n",
4001d2a8:	f8 06 60 08 	ld  [ %i1 + 8 ], %i4                           <== NOT EXECUTED
4001d2ac:	fa 07 bf a0 	ld  [ %fp + -96 ], %i5                         <== NOT EXECUTED
4001d2b0:	40 00 1f 7d 	call  400250a4 <strerror>                      <== NOT EXECUTED
4001d2b4:	90 10 00 14 	mov  %l4, %o0                                  <== NOT EXECUTED
4001d2b8:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
4001d2bc:	98 10 00 08 	mov  %o0, %o4                                  <== NOT EXECUTED
4001d2c0:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
4001d2c4:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
4001d2c8:	96 10 00 14 	mov  %l4, %o3                                  <== NOT EXECUTED
4001d2cc:	40 00 1b 2c 	call  40023f7c <printf>                        <== NOT EXECUTED
4001d2d0:	90 12 23 38 	or  %o0, 0x338, %o0                            <== NOT EXECUTED
4001d2d4:	10 bf ff 1a 	b  4001cf3c <rtems_rfs_dir_lookup_ino+0x154>   <== NOT EXECUTED
4001d2d8:	b0 10 00 14 	mov  %l4, %i0                                  <== NOT EXECUTED
    }                                                                 
                                                                      
    if ((rc == 0) && (block == 0))                                    
    {                                                                 
      rc = EIO;                                                       
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))           
4001d2dc:	13 01 00 00 	sethi  %hi(0x4000000), %o1                     <== NOT EXECUTED
4001d2e0:	7f ff da f1 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001d2e4:	b0 10 20 05 	mov  5, %i0                                    <== NOT EXECUTED
4001d2e8:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001d2ec:	22 bf ff 15 	be,a   4001cf40 <rtems_rfs_dir_lookup_ino+0x158><== NOT EXECUTED
4001d2f0:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
        printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n",
4001d2f4:	fa 06 60 08 	ld  [ %i1 + 8 ], %i5                           <== NOT EXECUTED
4001d2f8:	40 00 1f 6b 	call  400250a4 <strerror>                      <== NOT EXECUTED
4001d2fc:	90 10 20 05 	mov  5, %o0                                    <== NOT EXECUTED
4001d300:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
4001d304:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
4001d308:	94 10 20 05 	mov  5, %o2                                    <== NOT EXECUTED
4001d30c:	11 10 00 dd 	sethi  %hi(0x40037400), %o0                    <== NOT EXECUTED
      }                                                               
    }                                                                 
                                                                      
    if ((rc == 0) && (block == 0))                                    
    {                                                                 
      rc = EIO;                                                       
4001d310:	b0 10 20 05 	mov  5, %i0                                    <== NOT EXECUTED
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))           
        printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n",
4001d314:	40 00 1b 1a 	call  40023f7c <printf>                        <== NOT EXECUTED
4001d318:	90 12 20 c8 	or  %o0, 0xc8, %o0                             <== NOT EXECUTED
4001d31c:	10 bf ff 09 	b  4001cf40 <rtems_rfs_dir_lookup_ino+0x158>   <== NOT EXECUTED
4001d320:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
                                                                      

4001dba0 <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) {
4001dba0:	9d e3 bf 40 	save  %sp, -192, %sp                           
  rtems_rfs_block_map     map;                                        
  rtems_rfs_buffer_handle buffer;                                     
  rtems_rfs_block_no      block;                                      
  int                     rc;                                         
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))                     
4001dba4:	90 10 20 00 	clr  %o0                                       
4001dba8:	7f ff d8 bf 	call  40013ea4 <rtems_rfs_trace>               
4001dbac:	13 20 00 00 	sethi  %hi(0x80000000), %o1                    
4001dbb0:	80 8a 20 ff 	btst  0xff, %o0                                
4001dbb4:	32 80 00 27 	bne,a   4001dc50 <rtems_rfs_dir_read+0xb0>     <== NEVER TAKEN
4001dbb8:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
    printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n",
            rtems_rfs_inode_ino (dir), offset);                       
                                                                      
  *length = 0;                                                        
4001dbbc:	c0 27 40 00 	clr  [ %i5 ]                                   
                                                                      
  rc = rtems_rfs_block_map_open (fs, dir, &map);                      
4001dbc0:	90 10 00 18 	mov  %i0, %o0                                  
4001dbc4:	92 10 00 19 	mov  %i1, %o1                                  
4001dbc8:	7f ff f6 92 	call  4001b610 <rtems_rfs_block_map_open>      
4001dbcc:	94 07 bf b0 	add  %fp, -80, %o2                             
  if (rc > 0)                                                         
4001dbd0:	a0 92 20 00 	orcc  %o0, 0, %l0                              
4001dbd4:	24 80 00 04 	ble,a   4001dbe4 <rtems_rfs_dir_read+0x44>     <== ALWAYS TAKEN
4001dbd8:	e0 06 20 08 	ld  [ %i0 + 8 ], %l0                           
  }                                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &buffer);                        
  rtems_rfs_block_map_close (fs, &map);                               
  return rc;                                                          
}                                                                     
4001dbdc:	81 c7 e0 08 	ret                                            
4001dbe0:	91 e8 00 10 	restore  %g0, %l0, %o0                         
  rc = rtems_rfs_block_map_open (fs, dir, &map);                      
  if (rc > 0)                                                         
    return rc;                                                        
                                                                      
  if (((rtems_rfs_fs_block_size (fs) -                                
        (offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
4001dbe4:	90 10 00 1a 	mov  %i2, %o0                                  
4001dbe8:	a2 10 00 10 	mov  %l0, %l1                                  
4001dbec:	92 10 00 1b 	mov  %i3, %o1                                  
4001dbf0:	a0 10 20 00 	clr  %l0                                       
4001dbf4:	96 10 00 11 	mov  %l1, %o3                                  
4001dbf8:	40 00 4c 40 	call  40030cf8 <__moddi3>                      
4001dbfc:	94 10 00 10 	mov  %l0, %o2                                  
                                                                      
  rc = rtems_rfs_block_map_open (fs, dir, &map);                      
  if (rc > 0)                                                         
    return rc;                                                        
                                                                      
  if (((rtems_rfs_fs_block_size (fs) -                                
4001dc00:	92 a4 40 09 	subcc  %l1, %o1, %o1                           
4001dc04:	90 64 00 08 	subx  %l0, %o0, %o0                            
4001dc08:	80 a2 20 00 	cmp  %o0, 0                                    
4001dc0c:	04 80 00 18 	ble  4001dc6c <rtems_rfs_dir_read+0xcc>        <== ALWAYS TAKEN
4001dc10:	01 00 00 00 	nop                                            
        (offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
    offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) *         
              rtems_rfs_fs_block_size (fs));                          
                                                                      
  rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);           
4001dc14:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001dc18:	92 07 bf b0 	add  %fp, -80, %o1                             
4001dc1c:	94 10 00 1a 	mov  %i2, %o2                                  
4001dc20:	96 10 00 1b 	mov  %i3, %o3                                  
4001dc24:	7f ff f7 aa 	call  4001bacc <rtems_rfs_block_map_seek>      
4001dc28:	98 07 bf a0 	add  %fp, -96, %o4                             
  if (rc > 0)                                                         
4001dc2c:	a0 92 20 00 	orcc  %o0, 0, %l0                              
4001dc30:	04 80 00 25 	ble  4001dcc4 <rtems_rfs_dir_read+0x124>       <== ALWAYS TAKEN
4001dc34:	80 a4 20 06 	cmp  %l0, 6                                    
  {                                                                   
    if (rc == ENXIO)                                                  
4001dc38:	02 80 00 1f 	be  4001dcb4 <rtems_rfs_dir_read+0x114>        <== NOT EXECUTED
4001dc3c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
      rc = ENOENT;                                                    
    rtems_rfs_block_map_close (fs, &map);                             
4001dc40:	7f ff f6 d5 	call  4001b794 <rtems_rfs_block_map_close>     <== NOT EXECUTED
4001dc44:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
  }                                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &buffer);                        
  rtems_rfs_block_map_close (fs, &map);                               
  return rc;                                                          
}                                                                     
4001dc48:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001dc4c:	91 e8 00 10 	restore  %g0, %l0, %o0                         <== NOT EXECUTED
  rtems_rfs_buffer_handle buffer;                                     
  rtems_rfs_block_no      block;                                      
  int                     rc;                                         
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))                     
    printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n",
4001dc50:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
4001dc54:	11 10 00 dd 	sethi  %hi(0x40037400), %o0                    <== NOT EXECUTED
4001dc58:	96 10 00 1b 	mov  %i3, %o3                                  <== NOT EXECUTED
4001dc5c:	40 00 18 c8 	call  40023f7c <printf>                        <== NOT EXECUTED
4001dc60:	90 12 23 e8 	or  %o0, 0x3e8, %o0                            <== NOT EXECUTED
            rtems_rfs_inode_ino (dir), offset);                       
                                                                      
  *length = 0;                                                        
4001dc64:	10 bf ff d7 	b  4001dbc0 <rtems_rfs_dir_read+0x20>          <== NOT EXECUTED
4001dc68:	c0 27 40 00 	clr  [ %i5 ]                                   <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_block_map_open (fs, dir, &map);                      
  if (rc > 0)                                                         
    return rc;                                                        
                                                                      
  if (((rtems_rfs_fs_block_size (fs) -                                
4001dc6c:	32 80 00 06 	bne,a   4001dc84 <rtems_rfs_dir_read+0xe4>     <== NEVER TAKEN
4001dc70:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
4001dc74:	80 a2 60 0a 	cmp  %o1, 0xa                                  
4001dc78:	38 bf ff e8 	bgu,a   4001dc18 <rtems_rfs_dir_read+0x78>     <== ALWAYS TAKEN
4001dc7c:	90 10 00 18 	mov  %i0, %o0                                  
        (offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
    offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) *         
4001dc80:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
4001dc84:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
4001dc88:	94 10 00 10 	mov  %l0, %o2                                  <== NOT EXECUTED
4001dc8c:	40 00 4b 30 	call  4003094c <__divdi3>                      <== NOT EXECUTED
4001dc90:	96 10 00 11 	mov  %l1, %o3                                  <== NOT EXECUTED
4001dc94:	96 82 60 01 	addcc  %o1, 1, %o3                             <== NOT EXECUTED
4001dc98:	92 10 00 11 	mov  %l1, %o1                                  <== NOT EXECUTED
4001dc9c:	94 42 20 00 	addx  %o0, 0, %o2                              <== NOT EXECUTED
4001dca0:	40 00 4a f9 	call  40030884 <__muldi3>                      <== NOT EXECUTED
4001dca4:	90 10 00 10 	mov  %l0, %o0                                  <== NOT EXECUTED
4001dca8:	b4 10 00 08 	mov  %o0, %i2                                  <== NOT EXECUTED
4001dcac:	10 bf ff da 	b  4001dc14 <rtems_rfs_dir_read+0x74>          <== NOT EXECUTED
4001dcb0:	b6 10 00 09 	mov  %o1, %i3                                  <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);           
  if (rc > 0)                                                         
  {                                                                   
    if (rc == ENXIO)                                                  
      rc = ENOENT;                                                    
4001dcb4:	a0 10 20 02 	mov  2, %l0                                    <== NOT EXECUTED
    rtems_rfs_block_map_close (fs, &map);                             
4001dcb8:	7f ff f6 b7 	call  4001b794 <rtems_rfs_block_map_close>     <== NOT EXECUTED
4001dcbc:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
4001dcc0:	30 bf ff e2 	b,a   4001dc48 <rtems_rfs_dir_read+0xa8>       <== NOT EXECUTED
    entry += map.bpos.boff;                                           
                                                                      
    elength = rtems_rfs_dir_entry_length (entry);                     
    eino    = rtems_rfs_dir_entry_ino (entry);                        
                                                                      
    if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)                         
4001dcc4:	29 00 00 3f 	sethi  %hi(0xfc00), %l4                        
    }                                                                 
                                                                      
    *length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;          
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))                   
      printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
4001dcc8:	2b 10 00 de 	sethi  %hi(0x40037800), %l5                    
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
4001dccc:	c0 2f bf a4 	clrb  [ %fp + -92 ]                            
  handle->bnum  = 0;                                                  
4001dcd0:	c0 27 bf a8 	clr  [ %fp + -88 ]                             
  handle->buffer = NULL;                                              
4001dcd4:	c0 27 bf ac 	clr  [ %fp + -84 ]                             
    entry += map.bpos.boff;                                           
                                                                      
    elength = rtems_rfs_dir_entry_length (entry);                     
    eino    = rtems_rfs_dir_entry_ino (entry);                        
                                                                      
    if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)                         
4001dcd8:	a8 15 23 ff 	or  %l4, 0x3ff, %l4                            
    }                                                                 
                                                                      
    *length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;          
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))                   
      printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
4001dcdc:	aa 15 60 98 	or  %l5, 0x98, %l5                             
    uint8_t*      entry;                                              
    rtems_rfs_ino eino;                                               
    int           elength;                                            
    int           remaining;                                          
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);  
4001dce0:	d4 07 bf a0 	ld  [ %fp + -96 ], %o2                         
4001dce4:	96 10 20 01 	mov  1, %o3                                    
4001dce8:	92 07 bf a4 	add  %fp, -92, %o1                             
4001dcec:	7f ff fa 4d 	call  4001c620 <rtems_rfs_buffer_handle_request>
4001dcf0:	90 10 00 18 	mov  %i0, %o0                                  
    if (rc > 0)                                                       
4001dcf4:	a0 92 20 00 	orcc  %o0, 0, %l0                              
4001dcf8:	14 80 00 32 	bg  4001ddc0 <rtems_rfs_dir_read+0x220>        <== NEVER TAKEN
4001dcfc:	c2 07 bf ac 	ld  [ %fp + -84 ], %g1                         
      rtems_rfs_block_map_close (fs, &map);                           
      return rc;                                                      
    }                                                                 
                                                                      
    entry  = rtems_rfs_buffer_data (&buffer);                         
    entry += map.bpos.boff;                                           
4001dd00:	e4 07 bf c4 	ld  [ %fp + -60 ], %l2                         
      rtems_rfs_buffer_handle_close (fs, &buffer);                    
      rtems_rfs_block_map_close (fs, &map);                           
      return rc;                                                      
    }                                                                 
                                                                      
    entry  = rtems_rfs_buffer_data (&buffer);                         
4001dd04:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        
      break;                                                          
    }                                                                 
                                                                      
    *length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;          
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))                   
4001dd08:	90 10 20 00 	clr  %o0                                       
      rtems_rfs_block_map_close (fs, &map);                           
      return rc;                                                      
    }                                                                 
                                                                      
    entry  = rtems_rfs_buffer_data (&buffer);                         
    entry += map.bpos.boff;                                           
4001dd0c:	a2 00 40 12 	add  %g1, %l2, %l1                             
                                                                      
    elength = rtems_rfs_dir_entry_length (entry);                     
4001dd10:	c4 0c 60 09 	ldub  [ %l1 + 9 ], %g2                         
4001dd14:	e6 0c 60 08 	ldub  [ %l1 + 8 ], %l3                         
    eino    = rtems_rfs_dir_entry_ino (entry);                        
4001dd18:	c8 08 40 12 	ldub  [ %g1 + %l2 ], %g4                       
    }                                                                 
                                                                      
    entry  = rtems_rfs_buffer_data (&buffer);                         
    entry += map.bpos.boff;                                           
                                                                      
    elength = rtems_rfs_dir_entry_length (entry);                     
4001dd1c:	a7 2c e0 08 	sll  %l3, 8, %l3                               
      break;                                                          
    }                                                                 
                                                                      
    *length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;          
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))                   
4001dd20:	13 20 00 00 	sethi  %hi(0x80000000), %o1                    
    }                                                                 
                                                                      
    entry  = rtems_rfs_buffer_data (&buffer);                         
    entry += map.bpos.boff;                                           
                                                                      
    elength = rtems_rfs_dir_entry_length (entry);                     
4001dd24:	a6 14 c0 02 	or  %l3, %g2, %l3                              
    eino    = rtems_rfs_dir_entry_ino (entry);                        
4001dd28:	c6 0c 60 01 	ldub  [ %l1 + 1 ], %g3                         
4001dd2c:	c2 0c 60 02 	ldub  [ %l1 + 2 ], %g1                         
                                                                      
    if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)                         
4001dd30:	80 a4 c0 14 	cmp  %l3, %l4                                  
4001dd34:	12 80 00 2d 	bne  4001dde8 <rtems_rfs_dir_read+0x248>       
4001dd38:	c4 0c 60 03 	ldub  [ %l1 + 3 ], %g2                         
        printf ("rtems-rfs: dir-read: found off:%" PRIooff_t " ino:%ld name=%s\n",
                dirent->d_off, dirent->d_ino, dirent->d_name);        
      break;                                                          
    }                                                                 
                                                                      
    *length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;          
4001dd3c:	c4 06 20 08 	ld  [ %i0 + 8 ], %g2                           
4001dd40:	c2 07 40 00 	ld  [ %i5 ], %g1                               
4001dd44:	a4 20 80 12 	sub  %g2, %l2, %l2                             
4001dd48:	a4 00 40 12 	add  %g1, %l2, %l2                             
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))                   
4001dd4c:	7f ff d8 56 	call  40013ea4 <rtems_rfs_trace>               
4001dd50:	e4 27 40 00 	st  %l2, [ %i5 ]                               
4001dd54:	80 8a 20 ff 	btst  0xff, %o0                                
4001dd58:	12 80 00 0d 	bne  4001dd8c <rtems_rfs_dir_read+0x1ec>       <== NEVER TAKEN
4001dd5c:	90 10 00 18 	mov  %i0, %o0                                  
      printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
              offset, *length);                                       
                                                                      
    rc = rtems_rfs_block_map_next_block (fs, &map, &block);           
4001dd60:	92 07 bf b0 	add  %fp, -80, %o1                             
4001dd64:	7f ff f7 77 	call  4001bb40 <rtems_rfs_block_map_next_block>
4001dd68:	94 07 bf a0 	add  %fp, -96, %o2                             
    if (rc == ENXIO)                                                  
4001dd6c:	80 a2 20 06 	cmp  %o0, 6                                    
4001dd70:	02 80 00 13 	be  4001ddbc <rtems_rfs_dir_read+0x21c>        <== ALWAYS TAKEN
4001dd74:	a0 10 00 08 	mov  %o0, %l0                                  
                                                                      
  /*                                                                  
   * Look for an empty entry and if this is the last block that is the end of
   * the directory.                                                   
   */                                                                 
  while (rc == 0)                                                     
4001dd78:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4001dd7c:	02 bf ff da 	be  4001dce4 <rtems_rfs_dir_read+0x144>        <== NOT EXECUTED
4001dd80:	d4 07 bf a0 	ld  [ %fp + -96 ], %o2                         <== 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);                       
4001dd84:	10 80 00 10 	b  4001ddc4 <rtems_rfs_dir_read+0x224>         <== NOT EXECUTED
4001dd88:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
    }                                                                 
                                                                      
    *length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;          
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))                   
      printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
4001dd8c:	d6 07 40 00 	ld  [ %i5 ], %o3                               <== NOT EXECUTED
4001dd90:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
4001dd94:	94 10 00 1b 	mov  %i3, %o2                                  <== NOT EXECUTED
4001dd98:	40 00 18 79 	call  40023f7c <printf>                        <== NOT EXECUTED
4001dd9c:	90 10 00 15 	mov  %l5, %o0                                  <== NOT EXECUTED
              offset, *length);                                       
                                                                      
    rc = rtems_rfs_block_map_next_block (fs, &map, &block);           
4001dda0:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001dda4:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
4001dda8:	7f ff f7 66 	call  4001bb40 <rtems_rfs_block_map_next_block><== NOT EXECUTED
4001ddac:	94 07 bf a0 	add  %fp, -96, %o2                             <== NOT EXECUTED
    if (rc == ENXIO)                                                  
4001ddb0:	80 a2 20 06 	cmp  %o0, 6                                    <== NOT EXECUTED
4001ddb4:	12 bf ff f1 	bne  4001dd78 <rtems_rfs_dir_read+0x1d8>       <== NOT EXECUTED
4001ddb8:	a0 10 00 08 	mov  %o0, %l0                                  <== NOT EXECUTED
      rc = ENOENT;                                                    
4001ddbc:	a0 10 20 02 	mov  2, %l0                                    
4001ddc0:	92 07 bf a4 	add  %fp, -92, %o1                             
4001ddc4:	7f ff f9 9d 	call  4001c438 <rtems_rfs_buffer_handle_release>
4001ddc8:	90 10 00 18 	mov  %i0, %o0                                  
  }                                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &buffer);                        
  rtems_rfs_block_map_close (fs, &map);                               
4001ddcc:	90 10 00 18 	mov  %i0, %o0                                  
  handle->dirty = false;                                              
4001ddd0:	c0 2f bf a4 	clrb  [ %fp + -92 ]                            
  handle->bnum  = 0;                                                  
4001ddd4:	c0 27 bf a8 	clr  [ %fp + -88 ]                             
  handle->buffer = NULL;                                              
4001ddd8:	c0 27 bf ac 	clr  [ %fp + -84 ]                             
4001dddc:	7f ff f6 6e 	call  4001b794 <rtems_rfs_block_map_close>     
4001dde0:	92 07 bf b0 	add  %fp, -80, %o1                             
4001dde4:	30 bf ff 7e 	b,a   4001dbdc <rtems_rfs_dir_read+0x3c>       
                                                                      
    entry  = rtems_rfs_buffer_data (&buffer);                         
    entry += map.bpos.boff;                                           
                                                                      
    elength = rtems_rfs_dir_entry_length (entry);                     
    eino    = rtems_rfs_dir_entry_ino (entry);                        
4001dde8:	89 29 20 18 	sll  %g4, 0x18, %g4                            
4001ddec:	86 08 e0 ff 	and  %g3, 0xff, %g3                            
4001ddf0:	84 08 a0 ff 	and  %g2, 0xff, %g2                            
4001ddf4:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
4001ddf8:	82 08 60 ff 	and  %g1, 0xff, %g1                            
4001ddfc:	88 11 00 03 	or  %g4, %g3, %g4                              
4001de00:	83 28 60 08 	sll  %g1, 8, %g1                               
4001de04:	84 11 00 02 	or  %g4, %g2, %g2                              
                                                                      
    if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)                         
    {                                                                 
      if (rtems_rfs_dir_entry_valid (fs, elength, eino))              
4001de08:	80 a4 e0 0a 	cmp  %l3, 0xa                                  
4001de0c:	04 80 00 0d 	ble  4001de40 <rtems_rfs_dir_read+0x2a0>       <== NEVER TAKEN
4001de10:	a8 10 80 01 	or  %g2, %g1, %l4                              
4001de14:	c2 06 20 1c 	ld  [ %i0 + 0x1c ], %g1                        
4001de18:	80 a4 c0 01 	cmp  %l3, %g1                                  
4001de1c:	1a 80 00 0a 	bcc  4001de44 <rtems_rfs_dir_read+0x2a4>       <== NEVER TAKEN
4001de20:	90 10 20 00 	clr  %o0                                       
4001de24:	80 a5 20 00 	cmp  %l4, 0                                    
4001de28:	02 80 00 08 	be  4001de48 <rtems_rfs_dir_read+0x2a8>        <== NEVER TAKEN
4001de2c:	13 20 00 00 	sethi  %hi(0x80000000), %o1                    
4001de30:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
4001de34:	80 a5 00 01 	cmp  %l4, %g1                                  
4001de38:	08 80 00 12 	bleu  4001de80 <rtems_rfs_dir_read+0x2e0>      <== ALWAYS TAKEN
4001de3c:	90 10 00 1c 	mov  %i4, %o0                                  
      {                                                               
        if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))               
4001de40:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001de44:	13 20 00 00 	sethi  %hi(0x80000000), %o1                    <== NOT EXECUTED
4001de48:	7f ff d8 17 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001de4c:	a0 10 20 05 	mov  5, %l0                                    <== NOT EXECUTED
4001de50:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001de54:	22 bf ff dc 	be,a   4001ddc4 <rtems_rfs_dir_read+0x224>     <== NOT EXECUTED
4001de58:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
          printf ("rtems-rfs: dir-read: "                             
4001de5c:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
4001de60:	d8 07 bf c4 	ld  [ %fp + -60 ], %o4                         <== NOT EXECUTED
4001de64:	94 10 00 13 	mov  %l3, %o2                                  <== NOT EXECUTED
4001de68:	11 10 00 de 	sethi  %hi(0x40037800), %o0                    <== NOT EXECUTED
4001de6c:	96 10 00 14 	mov  %l4, %o3                                  <== NOT EXECUTED
4001de70:	40 00 18 43 	call  40023f7c <printf>                        <== NOT EXECUTED
4001de74:	90 12 20 18 	or  %o0, 0x18, %o0                             <== 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);                       
4001de78:	10 bf ff d3 	b  4001ddc4 <rtems_rfs_dir_read+0x224>         <== NOT EXECUTED
4001de7c:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
                  rtems_rfs_inode_ino (dir), elength, eino, map.bpos.boff);
        rc = EIO;                                                     
        break;                                                        
      }                                                               
                                                                      
      memset (dirent, 0, sizeof (struct dirent));                     
4001de80:	92 10 20 00 	clr  %o1                                       
4001de84:	40 00 17 c0 	call  40023d84 <memset>                        
4001de88:	94 10 21 18 	mov  0x118, %o2                                
      dirent->d_off = offset;                                         
      dirent->d_reclen = sizeof (struct dirent);                      
                                                                      
      *length += elength;                                             
4001de8c:	c2 07 40 00 	ld  [ %i5 ], %g1                               
        break;                                                        
      }                                                               
                                                                      
      memset (dirent, 0, sizeof (struct dirent));                     
      dirent->d_off = offset;                                         
      dirent->d_reclen = sizeof (struct dirent);                      
4001de90:	84 10 21 18 	mov  0x118, %g2                                
        rc = EIO;                                                     
        break;                                                        
      }                                                               
                                                                      
      memset (dirent, 0, sizeof (struct dirent));                     
      dirent->d_off = offset;                                         
4001de94:	f4 3f 20 08 	std  %i2, [ %i4 + 8 ]                          
      dirent->d_reclen = sizeof (struct dirent);                      
4001de98:	c4 37 20 10 	sth  %g2, [ %i4 + 0x10 ]                       
                                                                      
      *length += elength;                                             
4001de9c:	82 04 c0 01 	add  %l3, %g1, %g1                             
4001dea0:	c2 27 40 00 	st  %g1, [ %i5 ]                               
                                                                      
      remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
4001dea4:	c4 06 20 08 	ld  [ %i0 + 8 ], %g2                           
4001dea8:	84 20 80 12 	sub  %g2, %l2, %g2                             
4001deac:	84 20 80 13 	sub  %g2, %l3, %g2                             
                                                                      
      if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)                      
4001deb0:	80 a0 a0 0a 	cmp  %g2, 0xa                                  
4001deb4:	14 80 00 04 	bg  4001dec4 <rtems_rfs_dir_read+0x324>        <== ALWAYS TAKEN
4001deb8:	a6 04 ff f6 	add  %l3, -10, %l3                             
        *length += remaining;                                         
4001debc:	82 00 80 01 	add  %g2, %g1, %g1                             <== NOT EXECUTED
4001dec0:	c2 27 40 00 	st  %g1, [ %i5 ]                               <== NOT EXECUTED
4001dec4:	80 a4 e0 ff 	cmp  %l3, 0xff                                 
4001dec8:	34 80 00 02 	bg,a   4001ded0 <rtems_rfs_dir_read+0x330>     <== NEVER TAKEN
4001decc:	a6 10 20 ff 	mov  0xff, %l3                                 <== 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);
4001ded0:	92 04 60 0a 	add  %l1, 0xa, %o1                             
4001ded4:	94 10 00 13 	mov  %l3, %o2                                  
4001ded8:	ba 07 20 14 	add  %i4, 0x14, %i5                            
4001dedc:	40 00 17 1b 	call  40023b48 <memcpy>                        
4001dee0:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
      dirent->d_ino = rtems_rfs_dir_entry_ino (entry);                
4001dee4:	c8 0c 40 00 	ldub  [ %l1 ], %g4                             
4001dee8:	c6 0c 60 01 	ldub  [ %l1 + 1 ], %g3                         
4001deec:	c4 0c 60 03 	ldub  [ %l1 + 3 ], %g2                         
4001def0:	c2 0c 60 02 	ldub  [ %l1 + 2 ], %g1                         
4001def4:	89 29 20 18 	sll  %g4, 0x18, %g4                            
4001def8:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
4001defc:	83 28 60 08 	sll  %g1, 8, %g1                               
4001df00:	86 11 00 03 	or  %g4, %g3, %g3                              
4001df04:	84 10 c0 02 	or  %g3, %g2, %g2                              
4001df08:	82 10 80 01 	or  %g2, %g1, %g1                              
      dirent->d_namlen = elength;                                     
4001df0c:	e6 37 20 12 	sth  %l3, [ %i4 + 0x12 ]                       
                                                                      
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))                 
4001df10:	90 10 20 00 	clr  %o0                                       
4001df14:	13 20 00 00 	sethi  %hi(0x80000000), %o1                    
4001df18:	7f ff d7 e3 	call  40013ea4 <rtems_rfs_trace>               
4001df1c:	c2 27 00 00 	st  %g1, [ %i4 ]                               
4001df20:	80 8a 20 ff 	btst  0xff, %o0                                
4001df24:	22 bf ff a8 	be,a   4001ddc4 <rtems_rfs_dir_read+0x224>     <== ALWAYS TAKEN
4001df28:	92 07 bf a4 	add  %fp, -92, %o1                             
        printf ("rtems-rfs: dir-read: found off:%" PRIooff_t " ino:%ld name=%s\n",
4001df2c:	c4 1f 20 08 	ldd  [ %i4 + 8 ], %g2                          <== NOT EXECUTED
4001df30:	d6 07 00 00 	ld  [ %i4 ], %o3                               <== NOT EXECUTED
4001df34:	92 10 00 02 	mov  %g2, %o1                                  <== NOT EXECUTED
4001df38:	94 10 00 03 	mov  %g3, %o2                                  <== NOT EXECUTED
4001df3c:	11 10 00 de 	sethi  %hi(0x40037800), %o0                    <== NOT EXECUTED
4001df40:	98 10 00 1d 	mov  %i5, %o4                                  <== NOT EXECUTED
4001df44:	40 00 18 0e 	call  40023f7c <printf>                        <== NOT EXECUTED
4001df48:	90 12 20 60 	or  %o0, 0x60, %o0                             <== NOT EXECUTED
4001df4c:	10 bf ff 9e 	b  4001ddc4 <rtems_rfs_dir_read+0x224>         <== NOT EXECUTED
4001df50:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
                                                                      

4001e524 <rtems_rfs_file_close>: } int rtems_rfs_file_close (rtems_rfs_file_system* fs, rtems_rfs_file_handle* handle) {
4001e524:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rrc;                                                            
  int rc;                                                             
                                                                      
  rrc = 0;                                                            
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))                   
4001e528:	90 10 20 10 	mov  0x10, %o0                                 
4001e52c:	92 10 20 00 	clr  %o1                                       
4001e530:	7f ff d6 5d 	call  40013ea4 <rtems_rfs_trace>               
4001e534:	ba 10 00 18 	mov  %i0, %i5                                  
4001e538:	80 8a 20 ff 	btst  0xff, %o0                                
4001e53c:	32 80 00 87 	bne,a   4001e758 <rtems_rfs_file_close+0x234>  <== NEVER TAKEN
4001e540:	c2 06 60 1c 	ld  [ %i1 + 0x1c ], %g1                        <== NOT EXECUTED
    printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",        
            handle->shared->inode.ino);                               
                                                                      
  if (handle->shared->references > 0)                                 
4001e544:	d2 06 60 1c 	ld  [ %i1 + 0x1c ], %o1                        
4001e548:	c2 02 60 08 	ld  [ %o1 + 8 ], %g1                           
4001e54c:	80 a0 60 00 	cmp  %g1, 0                                    
4001e550:	04 80 00 04 	ble  4001e560 <rtems_rfs_file_close+0x3c>      <== NEVER TAKEN
4001e554:	82 00 7f ff 	add  %g1, -1, %g1                              
    handle->shared->references--;                                     
4001e558:	c2 22 60 08 	st  %g1, [ %o1 + 8 ]                           
                                                                      
  if (handle->shared->references == 0)                                
4001e55c:	80 a0 60 00 	cmp  %g1, 0                                    
4001e560:	12 80 00 74 	bne  4001e730 <rtems_rfs_file_close+0x20c>     <== NEVER TAKEN
4001e564:	90 10 00 1d 	mov  %i5, %o0                                  
  {                                                                   
    if (!rtems_rfs_inode_is_loaded (&handle->shared->inode))          
4001e568:	c2 02 60 18 	ld  [ %o1 + 0x18 ], %g1                        
4001e56c:	80 a0 60 00 	cmp  %g1, 0                                    
4001e570:	22 80 00 a7 	be,a   4001e80c <rtems_rfs_file_close+0x2e8>   <== ALWAYS TAKEN
4001e574:	92 02 60 0c 	add  %o1, 0xc, %o1                             
    if (rrc == 0)                                                     
    {                                                                 
      /*                                                              
       * @todo This could be clever and only update if different.     
       */                                                             
      rtems_rfs_inode_set_atime (&handle->shared->inode,              
4001e578:	c4 02 60 8c 	ld  [ %o1 + 0x8c ], %g2                        
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);                      
4001e57c:	86 10 20 01 	mov  1, %g3                                    
 */                                                                   
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);                  
4001e580:	89 30 a0 18 	srl  %g2, 0x18, %g4                            
4001e584:	c8 28 60 10 	stb  %g4, [ %g1 + 0x10 ]                       
4001e588:	c2 02 60 18 	ld  [ %o1 + 0x18 ], %g1                        
4001e58c:	89 30 a0 10 	srl  %g2, 0x10, %g4                            
4001e590:	c8 28 60 11 	stb  %g4, [ %g1 + 0x11 ]                       
4001e594:	c2 02 60 18 	ld  [ %o1 + 0x18 ], %g1                        
4001e598:	89 30 a0 08 	srl  %g2, 8, %g4                               
4001e59c:	c8 28 60 12 	stb  %g4, [ %g1 + 0x12 ]                       
4001e5a0:	c2 02 60 18 	ld  [ %o1 + 0x18 ], %g1                        
4001e5a4:	c4 28 60 13 	stb  %g2, [ %g1 + 0x13 ]                       
                                 handle->shared->atime);              
      rtems_rfs_inode_set_mtime (&handle->shared->inode,              
4001e5a8:	c4 06 60 1c 	ld  [ %i1 + 0x1c ], %g2                        
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
4001e5ac:	c6 2a 60 1c 	stb  %g3, [ %o1 + 0x1c ]                       
4001e5b0:	c2 00 a0 90 	ld  [ %g2 + 0x90 ], %g1                        
 */                                                                   
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);                  
4001e5b4:	c8 00 a0 18 	ld  [ %g2 + 0x18 ], %g4                        
4001e5b8:	b9 30 60 18 	srl  %g1, 0x18, %i4                            
4001e5bc:	f8 29 20 14 	stb  %i4, [ %g4 + 0x14 ]                       
4001e5c0:	c8 00 a0 18 	ld  [ %g2 + 0x18 ], %g4                        
4001e5c4:	b9 30 60 10 	srl  %g1, 0x10, %i4                            
4001e5c8:	f8 29 20 15 	stb  %i4, [ %g4 + 0x15 ]                       
4001e5cc:	c8 00 a0 18 	ld  [ %g2 + 0x18 ], %g4                        
4001e5d0:	b9 30 60 08 	srl  %g1, 8, %i4                               
4001e5d4:	f8 29 20 16 	stb  %i4, [ %g4 + 0x16 ]                       
4001e5d8:	c8 00 a0 18 	ld  [ %g2 + 0x18 ], %g4                        
4001e5dc:	c2 29 20 17 	stb  %g1, [ %g4 + 0x17 ]                       
                                 handle->shared->mtime);              
      rtems_rfs_inode_set_ctime (&handle->shared->inode,              
4001e5e0:	c2 06 60 1c 	ld  [ %i1 + 0x1c ], %g1                        
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
4001e5e4:	c6 28 a0 1c 	stb  %g3, [ %g2 + 0x1c ]                       
 */                                                                   
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);                  
4001e5e8:	c8 00 60 18 	ld  [ %g1 + 0x18 ], %g4                        
4001e5ec:	c4 00 60 94 	ld  [ %g1 + 0x94 ], %g2                        
4001e5f0:	b9 30 a0 18 	srl  %g2, 0x18, %i4                            
4001e5f4:	f8 29 20 18 	stb  %i4, [ %g4 + 0x18 ]                       
4001e5f8:	c8 00 60 18 	ld  [ %g1 + 0x18 ], %g4                        
4001e5fc:	b9 30 a0 10 	srl  %g2, 0x10, %i4                            
4001e600:	f8 29 20 19 	stb  %i4, [ %g4 + 0x19 ]                       
4001e604:	c8 00 60 18 	ld  [ %g1 + 0x18 ], %g4                        
4001e608:	b9 30 a0 08 	srl  %g2, 8, %i4                               
4001e60c:	f8 29 20 1a 	stb  %i4, [ %g4 + 0x1a ]                       
4001e610:	c8 00 60 18 	ld  [ %g1 + 0x18 ], %g4                        
4001e614:	c4 29 20 1b 	stb  %g2, [ %g4 + 0x1b ]                       
                                 handle->shared->ctime);              
      if (!rtems_rfs_block_size_equal (&handle->shared->size,         
4001e618:	d2 06 60 1c 	ld  [ %i1 + 0x1c ], %o1                        
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
4001e61c:	c6 28 60 1c 	stb  %g3, [ %g1 + 0x1c ]                       
4001e620:	c4 02 60 3c 	ld  [ %o1 + 0x3c ], %g2                        
4001e624:	c2 02 60 84 	ld  [ %o1 + 0x84 ], %g1                        
4001e628:	80 a0 40 02 	cmp  %g1, %g2                                  
4001e62c:	02 80 00 72 	be  4001e7f4 <rtems_rfs_file_close+0x2d0>      <== ALWAYS TAKEN
4001e630:	c4 02 60 88 	ld  [ %o1 + 0x88 ], %g2                        
 */                                                                   
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);                       
4001e634:	c2 22 60 3c 	st  %g1, [ %o1 + 0x3c ]                        <== NOT EXECUTED
4001e638:	c4 22 60 40 	st  %g2, [ %o1 + 0x40 ]                        <== NOT EXECUTED
  map->dirty = true;                                                  
4001e63c:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
4001e640:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
4001e644:	c2 2a 60 34 	stb  %g1, [ %o1 + 0x34 ]                       <== 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);        
4001e648:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001e64c:	7f ff f4 52 	call  4001b794 <rtems_rfs_block_map_close>     
4001e650:	92 02 60 34 	add  %o1, 0x34, %o1                            
    if (rc > 0)                                                       
4001e654:	b8 92 20 00 	orcc  %o0, 0, %i4                              
4001e658:	04 80 00 0a 	ble  4001e680 <rtems_rfs_file_close+0x15c>     <== ALWAYS TAKEN
4001e65c:	90 10 20 10 	mov  0x10, %o0                                 
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))               
4001e660:	7f ff d6 11 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001e664:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4001e668:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001e66c:	32 80 00 57 	bne,a   4001e7c8 <rtems_rfs_file_close+0x2a4>  <== NOT EXECUTED
4001e670:	c2 06 60 1c 	ld  [ %i1 + 0x1c ], %g1                        <== NOT EXECUTED
        printf ("rtems-rfs: file-close: map close error: ino=%" PRId32 ": %d: %s\n",
                handle->shared->inode.ino, rc, strerror (rc));        
      if (rrc == 0)                                                   
4001e674:	80 a6 20 00 	cmp  %i0, 0                                    <== NOT EXECUTED
4001e678:	22 80 00 02 	be,a   4001e680 <rtems_rfs_file_close+0x15c>   <== NOT EXECUTED
4001e67c:	b0 10 00 1c 	mov  %i4, %i0                                  <== NOT EXECUTED
        rrc = rc;                                                     
    }                                                                 
                                                                      
    rc = rtems_rfs_inode_close (fs, &handle->shared->inode);          
4001e680:	d2 06 60 1c 	ld  [ %i1 + 0x1c ], %o1                        
4001e684:	90 10 00 1d 	mov  %i5, %o0                                  
4001e688:	7f ff cf d8 	call  400125e8 <rtems_rfs_inode_close>         
4001e68c:	92 02 60 0c 	add  %o1, 0xc, %o1                             
    if (rc > 0)                                                       
4001e690:	b8 92 20 00 	orcc  %o0, 0, %i4                              
4001e694:	04 80 00 0a 	ble  4001e6bc <rtems_rfs_file_close+0x198>     <== ALWAYS TAKEN
4001e698:	90 10 20 10 	mov  0x10, %o0                                 
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))               
4001e69c:	7f ff d6 02 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001e6a0:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4001e6a4:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001e6a8:	32 80 00 3d 	bne,a   4001e79c <rtems_rfs_file_close+0x278>  <== NOT EXECUTED
4001e6ac:	c2 06 60 1c 	ld  [ %i1 + 0x1c ], %g1                        <== NOT EXECUTED
        printf ("rtems-rfs: file-close: inode close error: ino=%" PRId32 ": %d: %s\n",
                handle->shared->inode.ino, rc, strerror (rc));        
      if (rrc == 0)                                                   
4001e6b0:	80 a6 20 00 	cmp  %i0, 0                                    <== NOT EXECUTED
4001e6b4:	22 80 00 2f 	be,a   4001e770 <rtems_rfs_file_close+0x24c>   <== NOT EXECUTED
4001e6b8:	d0 06 60 1c 	ld  [ %i1 + 0x1c ], %o0                        <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void rtems_chain_extract(                        
  rtems_chain_node *the_node                                          
)                                                                     
{                                                                     
  _Chain_Extract( the_node );                                         
4001e6bc:	7f ff ea e8 	call  4001925c <_Chain_Extract>                
4001e6c0:	d0 06 60 1c 	ld  [ %i1 + 0x1c ], %o0                        
        rrc = rc;                                                     
    }                                                                 
                                                                      
    rtems_chain_extract (&handle->shared->link);                      
    free (handle->shared);                                            
4001e6c4:	7f ff a6 21 	call  40007f48 <free>                          
4001e6c8:	d0 06 60 1c 	ld  [ %i1 + 0x1c ], %o0                        
 */                                                                   
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);                       
4001e6cc:	90 10 00 1d 	mov  %i5, %o0                                  
4001e6d0:	7f ff f7 5a 	call  4001c438 <rtems_rfs_buffer_handle_release>
4001e6d4:	92 06 60 04 	add  %i1, 4, %o1                               
  handle->dirty = false;                                              
4001e6d8:	c0 2e 60 04 	clrb  [ %i1 + 4 ]                              
  handle->bnum  = 0;                                                  
4001e6dc:	c0 26 60 08 	clr  [ %i1 + 8 ]                               
                                                                      
  rc = rtems_rfs_buffer_handle_close (fs, &handle->buffer);           
  if ((rrc == 0) && (rc > 0))                                         
    rrc = rc;                                                         
                                                                      
  if (rrc > 0)                                                        
4001e6e0:	80 a6 20 00 	cmp  %i0, 0                                    
4001e6e4:	04 80 00 19 	ble  4001e748 <rtems_rfs_file_close+0x224>     <== ALWAYS TAKEN
4001e6e8:	c0 26 60 0c 	clr  [ %i1 + 0xc ]                             
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))                 
4001e6ec:	90 10 20 10 	mov  0x10, %o0                                 <== NOT EXECUTED
4001e6f0:	7f ff d5 ed 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001e6f4:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4001e6f8:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001e6fc:	02 80 00 13 	be  4001e748 <rtems_rfs_file_close+0x224>      <== NOT EXECUTED
4001e700:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: file-close: result: %d: %s\n", rrc, strerror (rrc));
4001e704:	40 00 1a 68 	call  400250a4 <strerror>                      <== NOT EXECUTED
4001e708:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001e70c:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
4001e710:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
4001e714:	11 10 00 de 	sethi  %hi(0x40037800), %o0                    <== NOT EXECUTED
4001e718:	40 00 16 19 	call  40023f7c <printf>                        <== NOT EXECUTED
4001e71c:	90 12 22 c8 	or  %o0, 0x2c8, %o0	! 40037ac8 <CSWTCH.2+0xed8><== NOT EXECUTED
  }                                                                   
                                                                      
  free (handle);                                                      
4001e720:	7f ff a6 0a 	call  40007f48 <free>                          <== NOT EXECUTED
4001e724:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
4001e728:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001e72c:	81 e8 00 00 	restore                                        <== 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);                       
4001e730:	92 06 60 04 	add  %i1, 4, %o1                               <== NOT EXECUTED
4001e734:	7f ff f7 41 	call  4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001e738:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
  handle->dirty = false;                                              
4001e73c:	c0 2e 60 04 	clrb  [ %i1 + 4 ]                              <== NOT EXECUTED
  handle->bnum  = 0;                                                  
4001e740:	c0 26 60 08 	clr  [ %i1 + 8 ]                               <== NOT EXECUTED
  handle->buffer = NULL;                                              
4001e744:	c0 26 60 0c 	clr  [ %i1 + 0xc ]                             <== NOT EXECUTED
4001e748:	7f ff a6 00 	call  40007f48 <free>                          
4001e74c:	90 10 00 19 	mov  %i1, %o0                                  
4001e750:	81 c7 e0 08 	ret                                            
4001e754:	81 e8 00 00 	restore                                        
  int rc;                                                             
                                                                      
  rrc = 0;                                                            
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))                   
    printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",        
4001e758:	11 10 00 de 	sethi  %hi(0x40037800), %o0                    <== NOT EXECUTED
4001e75c:	d2 00 60 14 	ld  [ %g1 + 0x14 ], %o1                        <== NOT EXECUTED
4001e760:	40 00 16 07 	call  40023f7c <printf>                        <== NOT EXECUTED
4001e764:	90 12 22 20 	or  %o0, 0x220, %o0                            <== NOT EXECUTED
            handle->shared->inode.ino);                               
                                                                      
  if (handle->shared->references > 0)                                 
4001e768:	10 bf ff 78 	b  4001e548 <rtems_rfs_file_close+0x24>        <== NOT EXECUTED
4001e76c:	d2 06 60 1c 	ld  [ %i1 + 0x1c ], %o1                        <== NOT EXECUTED
4001e770:	7f ff ea bb 	call  4001925c <_Chain_Extract>                <== NOT EXECUTED
4001e774:	b0 10 00 1c 	mov  %i4, %i0                                  <== NOT EXECUTED
      if (rrc == 0)                                                   
        rrc = rc;                                                     
    }                                                                 
                                                                      
    rtems_chain_extract (&handle->shared->link);                      
    free (handle->shared);                                            
4001e778:	7f ff a5 f4 	call  40007f48 <free>                          <== NOT EXECUTED
4001e77c:	d0 06 60 1c 	ld  [ %i1 + 0x1c ], %o0                        <== 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);                       
4001e780:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001e784:	7f ff f7 2d 	call  4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001e788:	92 06 60 04 	add  %i1, 4, %o1                               <== NOT EXECUTED
  handle->dirty = false;                                              
4001e78c:	c0 2e 60 04 	clrb  [ %i1 + 4 ]                              <== NOT EXECUTED
  handle->bnum  = 0;                                                  
4001e790:	c0 26 60 08 	clr  [ %i1 + 8 ]                               <== NOT EXECUTED
  handle->buffer = NULL;                                              
4001e794:	10 bf ff d6 	b  4001e6ec <rtems_rfs_file_close+0x1c8>       <== NOT EXECUTED
4001e798:	c0 26 60 0c 	clr  [ %i1 + 0xc ]                             <== NOT EXECUTED
                                                                      
    rc = rtems_rfs_inode_close (fs, &handle->shared->inode);          
    if (rc > 0)                                                       
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))               
        printf ("rtems-rfs: file-close: inode close error: ino=%" PRId32 ": %d: %s\n",
4001e79c:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
4001e7a0:	40 00 1a 41 	call  400250a4 <strerror>                      <== NOT EXECUTED
4001e7a4:	f6 00 60 14 	ld  [ %g1 + 0x14 ], %i3                        <== NOT EXECUTED
4001e7a8:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
4001e7ac:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
4001e7b0:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
4001e7b4:	11 10 00 de 	sethi  %hi(0x40037800), %o0                    <== NOT EXECUTED
4001e7b8:	40 00 15 f1 	call  40023f7c <printf>                        <== NOT EXECUTED
4001e7bc:	90 12 22 88 	or  %o0, 0x288, %o0	! 40037a88 <CSWTCH.2+0xe98><== NOT EXECUTED
                handle->shared->inode.ino, rc, strerror (rc));        
      if (rrc == 0)                                                   
4001e7c0:	10 bf ff bd 	b  4001e6b4 <rtems_rfs_file_close+0x190>       <== NOT EXECUTED
4001e7c4:	80 a6 20 00 	cmp  %i0, 0                                    <== NOT EXECUTED
                                                                      
    rc = rtems_rfs_block_map_close (fs, &handle->shared->map);        
    if (rc > 0)                                                       
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))               
        printf ("rtems-rfs: file-close: map close error: ino=%" PRId32 ": %d: %s\n",
4001e7c8:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
4001e7cc:	40 00 1a 36 	call  400250a4 <strerror>                      <== NOT EXECUTED
4001e7d0:	f6 00 60 14 	ld  [ %g1 + 0x14 ], %i3                        <== NOT EXECUTED
4001e7d4:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
4001e7d8:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
4001e7dc:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
4001e7e0:	11 10 00 de 	sethi  %hi(0x40037800), %o0                    <== NOT EXECUTED
4001e7e4:	40 00 15 e6 	call  40023f7c <printf>                        <== NOT EXECUTED
4001e7e8:	90 12 22 48 	or  %o0, 0x248, %o0	! 40037a48 <CSWTCH.2+0xe58><== NOT EXECUTED
                handle->shared->inode.ino, rc, strerror (rc));        
      if (rrc == 0)                                                   
4001e7ec:	10 bf ff a3 	b  4001e678 <rtems_rfs_file_close+0x154>       <== NOT EXECUTED
4001e7f0:	80 a6 20 00 	cmp  %i0, 0                                    <== NOT EXECUTED
                                 handle->shared->atime);              
      rtems_rfs_inode_set_mtime (&handle->shared->inode,              
                                 handle->shared->mtime);              
      rtems_rfs_inode_set_ctime (&handle->shared->inode,              
                                 handle->shared->ctime);              
      if (!rtems_rfs_block_size_equal (&handle->shared->size,         
4001e7f4:	c6 02 60 40 	ld  [ %o1 + 0x40 ], %g3                        
4001e7f8:	80 a0 80 03 	cmp  %g2, %g3                                  
4001e7fc:	12 bf ff 8e 	bne  4001e634 <rtems_rfs_file_close+0x110>     <== NEVER TAKEN
4001e800:	b0 10 20 00 	clr  %i0                                       
                                       &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);        
4001e804:	10 bf ff 92 	b  4001e64c <rtems_rfs_file_close+0x128>       
4001e808:	90 10 00 1d 	mov  %i5, %o0                                  
    handle->shared->references--;                                     
                                                                      
  if (handle->shared->references == 0)                                
  {                                                                   
    if (!rtems_rfs_inode_is_loaded (&handle->shared->inode))          
      rrc = rtems_rfs_inode_load (fs, &handle->shared->inode);        
4001e80c:	7f ff ce d2 	call  40012354 <rtems_rfs_inode_load>          
4001e810:	90 10 00 1d 	mov  %i5, %o0                                  
4001e814:	d2 06 60 1c 	ld  [ %i1 + 0x1c ], %o1                        
                                                                      
    if (rrc == 0)                                                     
4001e818:	80 a2 20 00 	cmp  %o0, 0                                    
4001e81c:	12 bf ff 8b 	bne  4001e648 <rtems_rfs_file_close+0x124>     <== NEVER TAKEN
4001e820:	b0 10 00 08 	mov  %o0, %i0                                  
4001e824:	10 bf ff 55 	b  4001e578 <rtems_rfs_file_close+0x54>        
4001e828:	c2 02 60 18 	ld  [ %o1 + 0x18 ], %g1                        
                                                                      

4001f1d4 <rtems_rfs_file_get_shared>: */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next;
4001f1d4:	c2 02 20 74 	ld  [ %o0 + 0x74 ], %g1                        
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(                             
  const Chain_Control *the_chain,                                     
  const Chain_Node    *the_node                                       
)                                                                     
{                                                                     
  return (the_node == _Chain_Immutable_tail( the_chain ));            
4001f1d8:	90 02 20 78 	add  %o0, 0x78, %o0                            
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))               
4001f1dc:	80 a0 40 08 	cmp  %g1, %o0                                  
4001f1e0:	32 80 00 08 	bne,a   4001f200 <rtems_rfs_file_get_shared+0x2c>
4001f1e4:	c4 00 60 14 	ld  [ %g1 + 0x14 ], %g2                        
    shared = (rtems_rfs_file_shared*) node;                           
    if (shared->inode.ino == ino)                                     
      return shared;                                                  
    node = rtems_chain_next (node);                                   
  }                                                                   
  return NULL;                                                        
4001f1e8:	81 c3 e0 08 	retl                                           
4001f1ec:	90 10 20 00 	clr  %o0                                       
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))               
4001f1f0:	80 a0 40 08 	cmp  %g1, %o0                                  
4001f1f4:	22 80 00 08 	be,a   4001f214 <rtems_rfs_file_get_shared+0x40><== ALWAYS TAKEN
4001f1f8:	90 10 20 00 	clr  %o0                                       
  {                                                                   
    rtems_rfs_file_shared* shared;                                    
    shared = (rtems_rfs_file_shared*) node;                           
    if (shared->inode.ino == ino)                                     
4001f1fc:	c4 00 60 14 	ld  [ %g1 + 0x14 ], %g2                        <== NOT EXECUTED
4001f200:	80 a0 80 09 	cmp  %g2, %o1                                  
4001f204:	32 bf ff fb 	bne,a   4001f1f0 <rtems_rfs_file_get_shared+0x1c>
4001f208:	c2 00 40 00 	ld  [ %g1 ], %g1                               
      return shared;                                                  
    node = rtems_chain_next (node);                                   
  }                                                                   
  return NULL;                                                        
}                                                                     
4001f20c:	81 c3 e0 08 	retl                                           
4001f210:	90 10 00 01 	mov  %g1, %o0                                  
4001f214:	81 c3 e0 08 	retl                                           
                                                                      

4001ea70 <rtems_rfs_file_io_end>: int rtems_rfs_file_io_end (rtems_rfs_file_handle* handle, size_t size, bool read) {
4001ea70:	9d e3 bf a0 	save  %sp, -96, %sp                            
  bool atime;                                                         
  bool mtime;                                                         
  bool length;                                                        
  int  rc = 0;                                                        
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                      
4001ea74:	90 10 20 20 	mov  0x20, %o0                                 
4001ea78:	92 10 20 00 	clr  %o1                                       
4001ea7c:	7f ff d5 0a 	call  40013ea4 <rtems_rfs_trace>               
4001ea80:	ba 10 00 18 	mov  %i0, %i5                                  
4001ea84:	80 8a 20 ff 	btst  0xff, %o0                                
4001ea88:	22 80 00 0c 	be,a   4001eab8 <rtems_rfs_file_io_end+0x48>   <== ALWAYS TAKEN
4001ea8c:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
    printf ("rtems-rfs: file-io:   end: %s size=%zu\n",               
4001ea90:	80 a6 a0 00 	cmp  %i2, 0                                    <== NOT EXECUTED
4001ea94:	12 80 00 22 	bne  4001eb1c <rtems_rfs_file_io_end+0xac>     <== NOT EXECUTED
4001ea98:	13 10 00 d8 	sethi  %hi(0x40036000), %o1                    <== NOT EXECUTED
4001ea9c:	13 10 00 de 	sethi  %hi(0x40037800), %o1                    <== NOT EXECUTED
4001eaa0:	92 12 62 f0 	or  %o1, 0x2f0, %o1	! 40037af0 <CSWTCH.2+0xf00><== NOT EXECUTED
4001eaa4:	11 10 00 de 	sethi  %hi(0x40037800), %o0                    <== NOT EXECUTED
4001eaa8:	94 10 00 19 	mov  %i1, %o2                                  <== NOT EXECUTED
4001eaac:	40 00 15 34 	call  40023f7c <printf>                        <== NOT EXECUTED
4001eab0:	90 12 23 b0 	or  %o0, 0x3b0, %o0                            <== NOT EXECUTED
            read ? "read" : "write", size);                           
                                                                      
  if (rtems_rfs_buffer_handle_has_block (&handle->buffer))            
4001eab4:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         <== NOT EXECUTED
4001eab8:	80 a0 60 00 	cmp  %g1, 0                                    
4001eabc:	02 80 00 1a 	be  4001eb24 <rtems_rfs_file_io_end+0xb4>      <== NEVER TAKEN
4001eac0:	80 a6 a0 00 	cmp  %i2, 0                                    
  {                                                                   
    if (!read)                                                        
4001eac4:	12 80 00 8b 	bne  4001ecf0 <rtems_rfs_file_io_end+0x280>    
4001eac8:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
      rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));   
    rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle), 
4001eacc:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
            read ? "read" : "write", size);                           
                                                                      
  if (rtems_rfs_buffer_handle_has_block (&handle->buffer))            
  {                                                                   
    if (!read)                                                        
      rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));   
4001ead0:	82 10 20 01 	mov  1, %g1                                    
    rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle), 
4001ead4:	92 07 60 04 	add  %i5, 4, %o1                               
4001ead8:	7f ff f6 58 	call  4001c438 <rtems_rfs_buffer_handle_release>
4001eadc:	c2 2f 60 04 	stb  %g1, [ %i5 + 4 ]                          
                                          rtems_rfs_file_buffer (handle));
    if (rc > 0)                                                       
4001eae0:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001eae4:	04 80 00 11 	ble  4001eb28 <rtems_rfs_file_io_end+0xb8>     <== ALWAYS TAKEN
4001eae8:	39 10 00 de 	sethi  %hi(0x40037800), %i4                    
    {                                                                 
      printf (                                                        
4001eaec:	b8 17 22 f0 	or  %i4, 0x2f0, %i4	! 40037af0 <CSWTCH.2+0xf00><== NOT EXECUTED
4001eaf0:	40 00 19 6d 	call  400250a4 <strerror>                      <== NOT EXECUTED
4001eaf4:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001eaf8:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
4001eafc:	98 10 00 08 	mov  %o0, %o4                                  <== NOT EXECUTED
4001eb00:	94 10 00 19 	mov  %i1, %o2                                  <== NOT EXECUTED
4001eb04:	11 10 00 de 	sethi  %hi(0x40037800), %o0                    <== NOT EXECUTED
4001eb08:	96 10 00 18 	mov  %i0, %o3                                  <== NOT EXECUTED
4001eb0c:	40 00 15 1c 	call  40023f7c <printf>                        <== NOT EXECUTED
4001eb10:	90 12 23 d8 	or  %o0, 0x3d8, %o0                            <== 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;                                                      
4001eb14:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001eb18:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  bool mtime;                                                         
  bool length;                                                        
  int  rc = 0;                                                        
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                      
    printf ("rtems-rfs: file-io:   end: %s size=%zu\n",               
4001eb1c:	10 bf ff e2 	b  4001eaa4 <rtems_rfs_file_io_end+0x34>       <== NOT EXECUTED
4001eb20:	92 12 62 d0 	or  %o1, 0x2d0, %o1                            <== NOT EXECUTED
                       bool                   read)                   
{                                                                     
  bool atime;                                                         
  bool mtime;                                                         
  bool length;                                                        
  int  rc = 0;                                                        
4001eb24:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
   * the size with the new length. The map holds the block count.     
   */                                                                 
  handle->bpos.boff += size;                                          
                                                                      
  if (handle->bpos.boff >=                                            
      rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))           
4001eb28:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
   * 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;                                          
4001eb2c:	c6 07 60 14 	ld  [ %i5 + 0x14 ], %g3                        
                                                                      
  if (handle->bpos.boff >=                                            
      rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))           
4001eb30:	c4 00 60 98 	ld  [ %g1 + 0x98 ], %g2                        
   * 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;                                          
4001eb34:	b2 06 40 03 	add  %i1, %g3, %i1                             
                                                                      
  if (handle->bpos.boff >=                                            
      rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))           
4001eb38:	c4 00 a0 08 	ld  [ %g2 + 8 ], %g2                           
   * 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;                                          
                                                                      
  if (handle->bpos.boff >=                                            
4001eb3c:	80 a6 40 02 	cmp  %i1, %g2                                  
4001eb40:	0a 80 00 07 	bcs  4001eb5c <rtems_rfs_file_io_end+0xec>     
4001eb44:	f2 27 60 14 	st  %i1, [ %i5 + 0x14 ]                        
      rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))           
  {                                                                   
    handle->bpos.bno++;                                               
4001eb48:	c6 07 60 10 	ld  [ %i5 + 0x10 ], %g3                        
    handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
4001eb4c:	b2 26 40 02 	sub  %i1, %g2, %i1                             
  handle->bpos.boff += size;                                          
                                                                      
  if (handle->bpos.boff >=                                            
      rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))           
  {                                                                   
    handle->bpos.bno++;                                               
4001eb50:	86 00 e0 01 	inc  %g3                                       
    handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
4001eb54:	f2 27 60 14 	st  %i1, [ %i5 + 0x14 ]                        
  handle->bpos.boff += size;                                          
                                                                      
  if (handle->bpos.boff >=                                            
      rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))           
  {                                                                   
    handle->bpos.bno++;                                               
4001eb58:	c6 27 60 10 	st  %g3, [ %i5 + 0x10 ]                        
  }                                                                   
                                                                      
  length = false;                                                     
  mtime = false;                                                      
                                                                      
  if (!read &&                                                        
4001eb5c:	80 a6 a0 00 	cmp  %i2, 0                                    
4001eb60:	32 80 00 11 	bne,a   4001eba4 <rtems_rfs_file_io_end+0x134> 
4001eb64:	f2 07 40 00 	ld  [ %i5 ], %i1                               
      rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),      
4001eb68:	c4 07 60 10 	ld  [ %i5 + 0x10 ], %g2                        
  }                                                                   
                                                                      
  length = false;                                                     
  mtime = false;                                                      
                                                                      
  if (!read &&                                                        
4001eb6c:	80 a0 a0 00 	cmp  %g2, 0                                    
4001eb70:	02 80 00 05 	be  4001eb84 <rtems_rfs_file_io_end+0x114>     
4001eb74:	c6 00 60 3c 	ld  [ %g1 + 0x3c ], %g3                        
      rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),      
4001eb78:	80 a0 e0 00 	cmp  %g3, 0                                    
4001eb7c:	22 80 00 25 	be,a   4001ec10 <rtems_rfs_file_io_end+0x1a0>  <== NEVER TAKEN
4001eb80:	c6 07 60 14 	ld  [ %i5 + 0x14 ], %g3                        <== NOT EXECUTED
4001eb84:	80 a0 c0 02 	cmp  %g3, %g2                                  
4001eb88:	28 80 00 22 	bleu,a   4001ec10 <rtems_rfs_file_io_end+0x1a0>
4001eb8c:	c6 07 60 14 	ld  [ %i5 + 0x14 ], %g3                        
4001eb90:	86 00 ff ff 	add  %g3, -1, %g3                              
4001eb94:	80 a0 80 03 	cmp  %g2, %g3                                  
4001eb98:	22 80 00 5f 	be,a   4001ed14 <rtems_rfs_file_io_end+0x2a4>  
4001eb9c:	c6 07 60 14 	ld  [ %i5 + 0x14 ], %g3                        
                                         handle->bpos.boff);          
    length = true;                                                    
    mtime = true;                                                     
  }                                                                   
                                                                      
  atime  = rtems_rfs_file_update_atime (handle);                      
4001eba0:	f2 07 40 00 	ld  [ %i5 ], %i1                               
  mtime  = rtems_rfs_file_update_mtime (handle) && mtime;             
4001eba4:	b8 10 20 00 	clr  %i4                                       
                                         handle->bpos.boff);          
    length = true;                                                    
    mtime = true;                                                     
  }                                                                   
                                                                      
  atime  = rtems_rfs_file_update_atime (handle);                      
4001eba8:	b2 0e 60 01 	and  %i1, 1, %i1                               
4001ebac:	b2 1e 60 01 	xor  %i1, 1, %i1                               
  mtime  = rtems_rfs_file_update_mtime (handle) && mtime;             
  length = rtems_rfs_file_update_length (handle) && length;           
4001ebb0:	b6 10 20 00 	clr  %i3                                       
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                      
4001ebb4:	90 10 20 20 	mov  0x20, %o0                                 
4001ebb8:	92 10 20 00 	clr  %o1                                       
4001ebbc:	7f ff d4 ba 	call  40013ea4 <rtems_rfs_trace>               
4001ebc0:	b2 0e 60 ff 	and  %i1, 0xff, %i1                            
4001ebc4:	80 8a 20 ff 	btst  0xff, %o0                                
4001ebc8:	12 80 00 22 	bne  4001ec50 <rtems_rfs_file_io_end+0x1e0>    <== NEVER TAKEN
4001ebcc:	80 a0 00 19 	cmp  %g0, %i1                                  
4001ebd0:	b8 0f 20 ff 	and  %i4, 0xff, %i4                            
    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)                                                 
4001ebd4:	80 a7 20 00 	cmp  %i4, 0                                    
4001ebd8:	12 80 00 33 	bne  4001eca4 <rtems_rfs_file_io_end+0x234>    
4001ebdc:	b6 0e e0 ff 	and  %i3, 0xff, %i3                            
4001ebe0:	80 a6 60 00 	cmp  %i1, 0                                    
4001ebe4:	12 80 00 30 	bne  4001eca4 <rtems_rfs_file_io_end+0x234>    <== ALWAYS TAKEN
4001ebe8:	80 a6 e0 00 	cmp  %i3, 0                                    
    if (read && atime)                                                
      handle->shared->atime = now;                                    
    if (!read && mtime)                                               
      handle->shared->mtime = now;                                    
  }                                                                   
  if (length)                                                         
4001ebec:	02 80 00 17 	be  4001ec48 <rtems_rfs_file_io_end+0x1d8>     
4001ebf0:	01 00 00 00 	nop                                            
  {                                                                   
    handle->shared->size.count =                                      
      rtems_rfs_block_map_count (rtems_rfs_file_map (handle));        
4001ebf4:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
    if (!read && mtime)                                               
      handle->shared->mtime = now;                                    
  }                                                                   
  if (length)                                                         
  {                                                                   
    handle->shared->size.count =                                      
4001ebf8:	c6 00 60 3c 	ld  [ %g1 + 0x3c ], %g3                        
      rtems_rfs_block_map_count (rtems_rfs_file_map (handle));        
    handle->shared->size.offset =                                     
4001ebfc:	c4 00 60 40 	ld  [ %g1 + 0x40 ], %g2                        
    if (!read && mtime)                                               
      handle->shared->mtime = now;                                    
  }                                                                   
  if (length)                                                         
  {                                                                   
    handle->shared->size.count =                                      
4001ec00:	c6 20 60 84 	st  %g3, [ %g1 + 0x84 ]                        
      rtems_rfs_block_map_count (rtems_rfs_file_map (handle));        
    handle->shared->size.offset =                                     
4001ec04:	c4 20 60 88 	st  %g2, [ %g1 + 0x88 ]                        
4001ec08:	81 c7 e0 08 	ret                                            
4001ec0c:	81 e8 00 00 	restore                                        
                                         handle->bpos.boff);          
    length = true;                                                    
    mtime = true;                                                     
  }                                                                   
                                                                      
  atime  = rtems_rfs_file_update_atime (handle);                      
4001ec10:	c4 07 40 00 	ld  [ %i5 ], %g2                               
 */                                                                   
static inline void                                                    
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,        
                                     rtems_rfs_block_off  offset)     
{                                                                     
  map->size.offset = offset;                                          
4001ec14:	c6 20 60 40 	st  %g3, [ %g1 + 0x40 ]                        
  map->dirty = true;                                                  
4001ec18:	86 10 20 01 	mov  1, %g3                                    
4001ec1c:	c6 28 60 34 	stb  %g3, [ %g1 + 0x34 ]                       
4001ec20:	b2 08 a0 01 	and  %g2, 1, %i1                               
  mtime  = rtems_rfs_file_update_mtime (handle) && mtime;             
4001ec24:	b9 30 a0 01 	srl  %g2, 1, %i4                               
                                         handle->bpos.boff);          
    length = true;                                                    
    mtime = true;                                                     
  }                                                                   
                                                                      
  atime  = rtems_rfs_file_update_atime (handle);                      
4001ec28:	b2 1e 60 01 	xor  %i1, 1, %i1                               
  mtime  = rtems_rfs_file_update_mtime (handle) && mtime;             
4001ec2c:	b8 1f 20 01 	xor  %i4, 1, %i4                               
  length = rtems_rfs_file_update_length (handle) && length;           
4001ec30:	b6 10 20 01 	mov  1, %i3                                    
4001ec34:	80 88 a0 04 	btst  4, %g2                                   
4001ec38:	02 bf ff df 	be  4001ebb4 <rtems_rfs_file_io_end+0x144>     <== ALWAYS TAKEN
4001ec3c:	b8 0f 20 01 	and  %i4, 1, %i4                               
4001ec40:	10 bf ff dd 	b  4001ebb4 <rtems_rfs_file_io_end+0x144>      <== NOT EXECUTED
4001ec44:	b6 10 20 00 	clr  %i3                                       <== NOT EXECUTED
    handle->shared->size.offset =                                     
      rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));  
  }                                                                   
                                                                      
  return rc;                                                          
}                                                                     
4001ec48:	81 c7 e0 08 	ret                                            
4001ec4c:	81 e8 00 00 	restore                                        
  atime  = rtems_rfs_file_update_atime (handle);                      
  mtime  = rtems_rfs_file_update_mtime (handle) && mtime;             
  length = rtems_rfs_file_update_length (handle) && length;           
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                      
    printf ("rtems-rfs: file-io:   end: pos=%" PRIu32 ":%" PRIu32 " %c %c %c\n",
4001ec50:	b8 0f 20 ff 	and  %i4, 0xff, %i4                            <== NOT EXECUTED
4001ec54:	96 40 3f ff 	addx  %g0, -1, %o3                             <== NOT EXECUTED
4001ec58:	d2 07 60 10 	ld  [ %i5 + 0x10 ], %o1                        <== NOT EXECUTED
4001ec5c:	80 a0 00 1c 	cmp  %g0, %i4                                  <== NOT EXECUTED
4001ec60:	d4 07 60 14 	ld  [ %i5 + 0x14 ], %o2                        <== NOT EXECUTED
4001ec64:	98 40 3f ff 	addx  %g0, -1, %o4                             <== NOT EXECUTED
4001ec68:	b6 0e e0 ff 	and  %i3, 0xff, %i3                            <== NOT EXECUTED
4001ec6c:	80 a0 00 1b 	cmp  %g0, %i3                                  <== NOT EXECUTED
4001ec70:	96 0a ff ec 	and  %o3, -20, %o3                             <== NOT EXECUTED
4001ec74:	9a 40 3f ff 	addx  %g0, -1, %o5                             <== NOT EXECUTED
4001ec78:	98 0b 3f e0 	and  %o4, -32, %o4                             <== NOT EXECUTED
4001ec7c:	9a 0b 7f e1 	and  %o5, -31, %o5                             <== NOT EXECUTED
4001ec80:	11 10 00 df 	sethi  %hi(0x40037c00), %o0                    <== NOT EXECUTED
4001ec84:	96 02 e0 41 	add  %o3, 0x41, %o3                            <== NOT EXECUTED
4001ec88:	90 12 20 20 	or  %o0, 0x20, %o0                             <== NOT EXECUTED
4001ec8c:	98 03 20 4d 	add  %o4, 0x4d, %o4                            <== NOT EXECUTED
4001ec90:	40 00 14 bb 	call  40023f7c <printf>                        <== NOT EXECUTED
4001ec94:	9a 03 60 4c 	add  %o5, 0x4c, %o5                            <== NOT EXECUTED
            handle->bpos.bno, handle->bpos.boff,                      
            atime ? 'A' : '-', mtime ? 'M' : '-', length ? 'L' : '-');
                                                                      
  if (atime || mtime)                                                 
4001ec98:	80 a7 20 00 	cmp  %i4, 0                                    <== NOT EXECUTED
4001ec9c:	02 bf ff d2 	be  4001ebe4 <rtems_rfs_file_io_end+0x174>     <== NOT EXECUTED
4001eca0:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
  {                                                                   
    time_t now = time (NULL);                                         
4001eca4:	40 00 24 fa 	call  4002808c <time>                          
4001eca8:	90 10 20 00 	clr  %o0                                       
    if (read && atime)                                                
4001ecac:	80 a6 60 00 	cmp  %i1, 0                                    
4001ecb0:	02 80 00 06 	be  4001ecc8 <rtems_rfs_file_io_end+0x258>     <== NEVER TAKEN
4001ecb4:	80 a7 20 00 	cmp  %i4, 0                                    
4001ecb8:	80 a6 a0 00 	cmp  %i2, 0                                    
4001ecbc:	32 80 00 0b 	bne,a   4001ece8 <rtems_rfs_file_io_end+0x278> 
4001ecc0:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
      handle->shared->atime = now;                                    
    if (!read && mtime)                                               
4001ecc4:	80 a7 20 00 	cmp  %i4, 0                                    
4001ecc8:	02 bf ff c9 	be  4001ebec <rtems_rfs_file_io_end+0x17c>     
4001eccc:	80 a6 e0 00 	cmp  %i3, 0                                    
4001ecd0:	80 a6 a0 01 	cmp  %i2, 1                                    
4001ecd4:	02 bf ff c6 	be  4001ebec <rtems_rfs_file_io_end+0x17c>     <== NEVER TAKEN
4001ecd8:	80 a6 e0 00 	cmp  %i3, 0                                    
      handle->shared->mtime = now;                                    
4001ecdc:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
4001ece0:	10 bf ff c3 	b  4001ebec <rtems_rfs_file_io_end+0x17c>      
4001ece4:	d0 20 60 90 	st  %o0, [ %g1 + 0x90 ]                        
                                                                      
  if (atime || mtime)                                                 
  {                                                                   
    time_t now = time (NULL);                                         
    if (read && atime)                                                
      handle->shared->atime = now;                                    
4001ece8:	10 bf ff f7 	b  4001ecc4 <rtems_rfs_file_io_end+0x254>      
4001ecec:	d0 20 60 8c 	st  %o0, [ %g1 + 0x8c ]                        
                                                                      
  if (rtems_rfs_buffer_handle_has_block (&handle->buffer))            
  {                                                                   
    if (!read)                                                        
      rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));   
    rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle), 
4001ecf0:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
4001ecf4:	92 07 60 04 	add  %i5, 4, %o1                               
4001ecf8:	7f ff f5 d0 	call  4001c438 <rtems_rfs_buffer_handle_release>
4001ecfc:	39 10 00 d8 	sethi  %hi(0x40036000), %i4                    
                                          rtems_rfs_file_buffer (handle));
    if (rc > 0)                                                       
4001ed00:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001ed04:	14 bf ff 7b 	bg  4001eaf0 <rtems_rfs_file_io_end+0x80>      <== NEVER TAKEN
4001ed08:	b8 17 22 d0 	or  %i4, 0x2d0, %i4                            
   * the size with the new length. The map holds the block count.     
   */                                                                 
  handle->bpos.boff += size;                                          
                                                                      
  if (handle->bpos.boff >=                                            
      rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))           
4001ed0c:	10 bf ff 88 	b  4001eb2c <rtems_rfs_file_io_end+0xbc>       
4001ed10:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
                                                                      
  length = false;                                                     
  mtime = false;                                                      
                                                                      
  if (!read &&                                                        
      rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),      
4001ed14:	c4 00 60 40 	ld  [ %g1 + 0x40 ], %g2                        
4001ed18:	80 a0 c0 02 	cmp  %g3, %g2                                  
4001ed1c:	28 bf ff a2 	bleu,a   4001eba4 <rtems_rfs_file_io_end+0x134>
4001ed20:	f2 07 40 00 	ld  [ %i5 ], %i1                               
                                         handle->bpos.boff);          
    length = true;                                                    
    mtime = true;                                                     
  }                                                                   
                                                                      
  atime  = rtems_rfs_file_update_atime (handle);                      
4001ed24:	10 bf ff bc 	b  4001ec14 <rtems_rfs_file_io_end+0x1a4>      
4001ed28:	c4 07 40 00 	ld  [ %i5 ], %g2                               
                                                                      

4001ed2c <rtems_rfs_file_io_release>: int rtems_rfs_file_io_release (rtems_rfs_file_handle* handle) { int rc = 0; if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
4001ed2c:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
4001ed30:	80 a0 60 00 	cmp  %g1, 0                                    
4001ed34:	02 80 00 07 	be  4001ed50 <rtems_rfs_file_io_release+0x24>  <== ALWAYS TAKEN
4001ed38:	92 02 20 04 	add  %o0, 4, %o1                               
    rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle), 
4001ed3c:	c2 02 20 1c 	ld  [ %o0 + 0x1c ], %g1                        <== NOT EXECUTED
4001ed40:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        <== NOT EXECUTED
4001ed44:	82 13 c0 00 	mov  %o7, %g1                                  <== NOT EXECUTED
4001ed48:	7f ff f5 bc 	call  4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001ed4c:	9e 10 40 00 	mov  %g1, %o7                                  <== NOT EXECUTED
                                          rtems_rfs_file_buffer (handle));
  return rc;                                                          
}                                                                     
4001ed50:	81 c3 e0 08 	retl                                           
4001ed54:	90 10 20 00 	clr  %o0                                       
                                                                      

4001e82c <rtems_rfs_file_io_start>: int rtems_rfs_file_io_start (rtems_rfs_file_handle* handle, size_t* available, bool read) {
4001e82c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  size_t size;                                                        
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                      
4001e830:	90 10 20 20 	mov  0x20, %o0                                 
4001e834:	92 10 20 00 	clr  %o1                                       
4001e838:	7f ff d5 9b 	call  40013ea4 <rtems_rfs_trace>               
4001e83c:	ba 10 00 18 	mov  %i0, %i5                                  
4001e840:	80 8a 20 ff 	btst  0xff, %o0                                
4001e844:	22 80 00 0d 	be,a   4001e878 <rtems_rfs_file_io_start+0x4c> <== ALWAYS TAKEN
4001e848:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
    printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
4001e84c:	80 a6 a0 00 	cmp  %i2, 0                                    <== NOT EXECUTED
4001e850:	02 80 00 2f 	be  4001e90c <rtems_rfs_file_io_start+0xe0>    <== NOT EXECUTED
4001e854:	13 10 00 de 	sethi  %hi(0x40037800), %o1                    <== NOT EXECUTED
4001e858:	13 10 00 d8 	sethi  %hi(0x40036000), %o1                    <== NOT EXECUTED
4001e85c:	92 12 62 d0 	or  %o1, 0x2d0, %o1	! 400362d0 <rtems_rfs_rtems_eval_config+0x2d0><== NOT EXECUTED
4001e860:	d4 07 60 10 	ld  [ %i5 + 0x10 ], %o2                        <== NOT EXECUTED
4001e864:	d6 07 60 14 	ld  [ %i5 + 0x14 ], %o3                        <== NOT EXECUTED
4001e868:	11 10 00 de 	sethi  %hi(0x40037800), %o0                    <== NOT EXECUTED
4001e86c:	40 00 15 c4 	call  40023f7c <printf>                        <== NOT EXECUTED
4001e870:	90 12 22 f8 	or  %o0, 0x2f8, %o0	! 40037af8 <CSWTCH.2+0xf08><== NOT EXECUTED
            read ? "read" : "write",  handle->bpos.bno, handle->bpos.boff);
                                                                      
  if (!rtems_rfs_buffer_handle_has_block (&handle->buffer))           
4001e874:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         <== NOT EXECUTED
4001e878:	80 a0 60 00 	cmp  %g1, 0                                    
4001e87c:	22 80 00 2c 	be,a   4001e92c <rtems_rfs_file_io_start+0x100>
4001e880:	d2 07 60 1c 	ld  [ %i5 + 0x1c ], %o1                        
                                          block, request_read);       
    if (rc > 0)                                                       
      return rc;                                                      
  }                                                                   
                                                                      
  if (read                                                            
4001e884:	80 a6 a0 00 	cmp  %i2, 0                                    
4001e888:	02 80 00 0d 	be  4001e8bc <rtems_rfs_file_io_start+0x90>    
4001e88c:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
      && rtems_rfs_block_map_last (rtems_rfs_file_map (handle))       
4001e890:	c4 00 60 44 	ld  [ %g1 + 0x44 ], %g2                        
4001e894:	80 a0 a0 00 	cmp  %g2, 0                                    
4001e898:	12 80 00 1f 	bne  4001e914 <rtems_rfs_file_io_start+0xe8>   
4001e89c:	c6 00 60 3c 	ld  [ %g1 + 0x3c ], %g3                        
4001e8a0:	80 a0 e0 00 	cmp  %g3, 0                                    
4001e8a4:	12 80 00 1d 	bne  4001e918 <rtems_rfs_file_io_start+0xec>   <== ALWAYS TAKEN
4001e8a8:	86 00 ff ff 	add  %g3, -1, %g3                              
      && rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
4001e8ac:	f8 00 60 40 	ld  [ %g1 + 0x40 ], %i4                        <== NOT EXECUTED
4001e8b0:	80 a7 20 00 	cmp  %i4, 0                                    
4001e8b4:	32 80 00 05 	bne,a   4001e8c8 <rtems_rfs_file_io_start+0x9c>
4001e8b8:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
    size = rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));
  else                                                                
    size = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));      
4001e8bc:	c2 00 60 98 	ld  [ %g1 + 0x98 ], %g1                        
4001e8c0:	f8 00 60 08 	ld  [ %g1 + 8 ], %i4                           
                                                                      
  *available = size - rtems_rfs_file_block_offset (handle);           
4001e8c4:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                      
4001e8c8:	90 10 20 20 	mov  0x20, %o0                                 
      && 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));      
                                                                      
  *available = size - rtems_rfs_file_block_offset (handle);           
4001e8cc:	82 27 00 01 	sub  %i4, %g1, %g1                             
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                      
4001e8d0:	92 10 20 00 	clr  %o1                                       
      && 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));      
                                                                      
  *available = size - rtems_rfs_file_block_offset (handle);           
4001e8d4:	c2 26 40 00 	st  %g1, [ %i1 ]                               
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                      
4001e8d8:	7f ff d5 73 	call  40013ea4 <rtems_rfs_trace>               
4001e8dc:	b0 10 20 00 	clr  %i0                                       
4001e8e0:	80 8a 20 ff 	btst  0xff, %o0                                
4001e8e4:	32 80 00 04 	bne,a   4001e8f4 <rtems_rfs_file_io_start+0xc8><== NEVER TAKEN
4001e8e8:	d2 06 40 00 	ld  [ %i1 ], %o1                               <== NOT EXECUTED
    printf ("rtems-rfs: file-io: start: available=%zu (%zu)\n",       
            *available, size);                                        
                                                                      
  return 0;                                                           
}                                                                     
4001e8ec:	81 c7 e0 08 	ret                                            
4001e8f0:	81 e8 00 00 	restore                                        
    size = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));      
                                                                      
  *available = size - rtems_rfs_file_block_offset (handle);           
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                      
    printf ("rtems-rfs: file-io: start: available=%zu (%zu)\n",       
4001e8f4:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
4001e8f8:	11 10 00 de 	sethi  %hi(0x40037800), %o0                    <== NOT EXECUTED
4001e8fc:	40 00 15 a0 	call  40023f7c <printf>                        <== NOT EXECUTED
4001e900:	90 12 23 80 	or  %o0, 0x380, %o0	! 40037b80 <CSWTCH.2+0xf90><== NOT EXECUTED
            *available, size);                                        
                                                                      
  return 0;                                                           
}                                                                     
4001e904:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001e908:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                         bool                   read)                 
{                                                                     
  size_t size;                                                        
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                      
    printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
4001e90c:	10 bf ff d5 	b  4001e860 <rtems_rfs_file_io_start+0x34>     <== NOT EXECUTED
4001e910:	92 12 62 f0 	or  %o1, 0x2f0, %o1                            <== NOT EXECUTED
    if (rc > 0)                                                       
      return rc;                                                      
  }                                                                   
                                                                      
  if (read                                                            
      && rtems_rfs_block_map_last (rtems_rfs_file_map (handle))       
4001e914:	86 00 ff ff 	add  %g3, -1, %g3                              
4001e918:	80 a0 80 03 	cmp  %g2, %g3                                  
4001e91c:	32 bf ff e9 	bne,a   4001e8c0 <rtems_rfs_file_io_start+0x94>
4001e920:	c2 00 60 98 	ld  [ %g1 + 0x98 ], %g1                        
      && rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
4001e924:	10 bf ff e3 	b  4001e8b0 <rtems_rfs_file_io_start+0x84>     
4001e928:	f8 00 60 40 	ld  [ %g1 + 0x40 ], %i4                        
    bool                   request_read;                              
    int                    rc;                                        
                                                                      
    request_read = read;                                              
                                                                      
    rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),        
4001e92c:	94 07 60 10 	add  %i5, 0x10, %o2                            
4001e930:	d0 02 60 98 	ld  [ %o1 + 0x98 ], %o0                        
4001e934:	96 07 bf fc 	add  %fp, -4, %o3                              
4001e938:	7f ff f4 0b 	call  4001b964 <rtems_rfs_block_map_find>      
4001e93c:	92 02 60 34 	add  %o1, 0x34, %o1                            
                                   rtems_rfs_file_map (handle),       
                                   rtems_rfs_file_bpos (handle),      
                                   &block);                           
    if (rc > 0)                                                       
4001e940:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001e944:	04 80 00 0a 	ble  4001e96c <rtems_rfs_file_io_start+0x140>  
4001e948:	80 a6 20 06 	cmp  %i0, 6                                    
    {                                                                 
      /*                                                              
       * Has the read reached the EOF ?                               
       */                                                             
      if (read && (rc == ENXIO))                                      
4001e94c:	32 bf ff e8 	bne,a   4001e8ec <rtems_rfs_file_io_start+0xc0><== NEVER TAKEN
4001e950:	90 10 20 20 	mov  0x20, %o0                                 <== NOT EXECUTED
4001e954:	80 a6 a0 00 	cmp  %i2, 0                                    
4001e958:	22 80 00 2d 	be,a   4001ea0c <rtems_rfs_file_io_start+0x1e0><== ALWAYS TAKEN
4001e95c:	80 a6 20 06 	cmp  %i0, 6                                    
      {                                                               
        *available = 0;                                               
4001e960:	c0 26 40 00 	clr  [ %i1 ]                                   <== NOT EXECUTED
        return 0;                                                     
4001e964:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001e968:	91 e8 20 00 	restore  %g0, 0, %o0                           <== 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 &&                                                    
4001e96c:	80 a6 a0 00 	cmp  %i2, 0                                    
4001e970:	12 80 00 0d 	bne  4001e9a4 <rtems_rfs_file_io_start+0x178>  
4001e974:	82 10 00 1a 	mov  %i2, %g1                                  
4001e978:	c4 07 60 14 	ld  [ %i5 + 0x14 ], %g2                        
4001e97c:	80 a0 a0 00 	cmp  %g2, 0                                    
4001e980:	12 80 00 09 	bne  4001e9a4 <rtems_rfs_file_io_start+0x178>  
4001e984:	82 10 20 01 	mov  1, %g1                                    
          (rtems_rfs_file_block_offset (handle) ||                    
           (*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
4001e988:	c4 07 60 1c 	ld  [ %i5 + 0x1c ], %g2                        
       * 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 &&                                                    
          (rtems_rfs_file_block_offset (handle) ||                    
4001e98c:	c6 06 40 00 	ld  [ %i1 ], %g3                               
           (*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
4001e990:	c4 00 a0 98 	ld  [ %g2 + 0x98 ], %g2                        
       * 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 &&                                                    
          (rtems_rfs_file_block_offset (handle) ||                    
4001e994:	c4 00 a0 08 	ld  [ %g2 + 8 ], %g2                           
4001e998:	80 a0 c0 02 	cmp  %g3, %g2                                  
4001e99c:	3a 80 00 02 	bcc,a   4001e9a4 <rtems_rfs_file_io_start+0x178><== NEVER TAKEN
4001e9a0:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
           (*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
        request_read = true;                                          
    }                                                                 
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                    
4001e9a4:	90 10 20 20 	mov  0x20, %o0                                 
4001e9a8:	92 10 20 00 	clr  %o1                                       
4001e9ac:	7f ff d5 3e 	call  40013ea4 <rtems_rfs_trace>               
4001e9b0:	b8 08 60 ff 	and  %g1, 0xff, %i4                            
4001e9b4:	80 8a 20 ff 	btst  0xff, %o0                                
4001e9b8:	22 80 00 0b 	be,a   4001e9e4 <rtems_rfs_file_io_start+0x1b8><== ALWAYS TAKEN
4001e9bc:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
      printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
4001e9c0:	80 a7 20 00 	cmp  %i4, 0                                    <== NOT EXECUTED
4001e9c4:	02 80 00 24 	be  4001ea54 <rtems_rfs_file_io_start+0x228>   <== NOT EXECUTED
4001e9c8:	d2 07 bf fc 	ld  [ %fp + -4 ], %o1                          <== NOT EXECUTED
4001e9cc:	15 10 00 d7 	sethi  %hi(0x40035c00), %o2                    <== NOT EXECUTED
4001e9d0:	94 12 a1 50 	or  %o2, 0x150, %o2	! 40035d50 <_CPU_Trap_slot_template+0xa68><== NOT EXECUTED
4001e9d4:	11 10 00 de 	sethi  %hi(0x40037800), %o0                    <== NOT EXECUTED
4001e9d8:	40 00 15 69 	call  40023f7c <printf>                        <== NOT EXECUTED
4001e9dc:	90 12 23 48 	or  %o0, 0x348, %o0	! 40037b48 <CSWTCH.2+0xf58><== NOT EXECUTED
              block, request_read ? "yes" : "no");                    
                                                                      
    rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle), 
4001e9e0:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        <== NOT EXECUTED
4001e9e4:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          
4001e9e8:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
4001e9ec:	92 07 60 04 	add  %i5, 4, %o1                               
4001e9f0:	7f ff f7 0c 	call  4001c620 <rtems_rfs_buffer_handle_request>
4001e9f4:	96 10 00 1c 	mov  %i4, %o3                                  
                                          rtems_rfs_file_buffer (handle),
                                          block, request_read);       
    if (rc > 0)                                                       
4001e9f8:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001e9fc:	04 bf ff a3 	ble  4001e888 <rtems_rfs_file_io_start+0x5c>   <== ALWAYS TAKEN
4001ea00:	80 a6 a0 00 	cmp  %i2, 0                                    
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                      
    printf ("rtems-rfs: file-io: start: available=%zu (%zu)\n",       
            *available, size);                                        
                                                                      
  return 0;                                                           
}                                                                     
4001ea04:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001ea08:	81 e8 00 00 	restore                                        <== NOT EXECUTED
      {                                                               
        *available = 0;                                               
        return 0;                                                     
      }                                                               
                                                                      
      if (rc != ENXIO)                                                
4001ea0c:	12 bf ff b8 	bne  4001e8ec <rtems_rfs_file_io_start+0xc0>   <== NEVER TAKEN
4001ea10:	90 10 20 20 	mov  0x20, %o0                                 
        return rc;                                                    
                                                                      
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                  
4001ea14:	7f ff d5 24 	call  40013ea4 <rtems_rfs_trace>               
4001ea18:	92 10 20 00 	clr  %o1                                       
4001ea1c:	80 8a 20 ff 	btst  0xff, %o0                                
4001ea20:	12 80 00 10 	bne  4001ea60 <rtems_rfs_file_io_start+0x234>  <== NEVER TAKEN
4001ea24:	11 10 00 de 	sethi  %hi(0x40037800), %o0                    
        printf ("rtems-rfs: file-io: start: grow\n");                 
                                                                      
      rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),      
4001ea28:	d2 07 60 1c 	ld  [ %i5 + 0x1c ], %o1                        
4001ea2c:	94 10 20 01 	mov  1, %o2                                    
4001ea30:	d0 02 60 98 	ld  [ %o1 + 0x98 ], %o0                        
4001ea34:	96 07 bf fc 	add  %fp, -4, %o3                              
4001ea38:	7f ff f4 4f 	call  4001bb74 <rtems_rfs_block_map_grow>      
4001ea3c:	92 02 60 34 	add  %o1, 0x34, %o1                            
                                     rtems_rfs_file_map (handle),     
                                     1, &block);                      
      if (rc > 0)                                                     
4001ea40:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001ea44:	14 bf ff aa 	bg  4001e8ec <rtems_rfs_file_io_start+0xc0>    
4001ea48:	82 10 20 00 	clr  %g1                                       
          (rtems_rfs_file_block_offset (handle) ||                    
           (*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
        request_read = true;                                          
    }                                                                 
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                    
4001ea4c:	10 bf ff d7 	b  4001e9a8 <rtems_rfs_file_io_start+0x17c>    
4001ea50:	90 10 20 20 	mov  0x20, %o0                                 
      printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
4001ea54:	15 10 00 d1 	sethi  %hi(0x40034400), %o2                    <== NOT EXECUTED
4001ea58:	10 bf ff df 	b  4001e9d4 <rtems_rfs_file_io_start+0x1a8>    <== NOT EXECUTED
4001ea5c:	94 12 a0 00 	mov  %o2, %o2	! 40034400 <__FUNCTION__.6193+0x338><== NOT EXECUTED
                                                                      
      if (rc != ENXIO)                                                
        return rc;                                                    
                                                                      
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                  
        printf ("rtems-rfs: file-io: start: grow\n");                 
4001ea60:	40 00 15 df 	call  400241dc <puts>                          <== NOT EXECUTED
4001ea64:	90 12 23 28 	or  %o0, 0x328, %o0                            <== NOT EXECUTED
                                                                      
      rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),      
4001ea68:	10 bf ff f1 	b  4001ea2c <rtems_rfs_file_io_start+0x200>    <== NOT EXECUTED
4001ea6c:	d2 07 60 1c 	ld  [ %i5 + 0x1c ], %o1                        <== NOT EXECUTED
                                                                      

4001e1e0 <rtems_rfs_file_open>: int rtems_rfs_file_open (rtems_rfs_file_system* fs, rtems_rfs_ino ino, int oflag, rtems_rfs_file_handle** file) {
4001e1e0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_rfs_file_handle* handle;                                      
  rtems_rfs_file_shared* shared;                                      
  int                    rc;                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))                    
4001e1e4:	90 10 20 08 	mov  8, %o0                                    
4001e1e8:	92 10 20 00 	clr  %o1                                       
4001e1ec:	7f ff d7 2e 	call  40013ea4 <rtems_rfs_trace>               
4001e1f0:	a0 10 00 18 	mov  %i0, %l0                                  
4001e1f4:	80 8a 20 ff 	btst  0xff, %o0                                
4001e1f8:	12 80 00 2b 	bne  4001e2a4 <rtems_rfs_file_open+0xc4>       <== NEVER TAKEN
4001e1fc:	92 10 00 19 	mov  %i1, %o1                                  
    printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);          
                                                                      
  *file = NULL;                                                       
4001e200:	c0 26 c0 00 	clr  [ %i3 ]                                   
  /*                                                                  
   * 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));                   
4001e204:	90 10 20 20 	mov  0x20, %o0                                 
4001e208:	7f ff a8 ed 	call  400085bc <malloc>                        
4001e20c:	b0 10 20 0c 	mov  0xc, %i0                                  
  if (!handle)                                                        
4001e210:	80 a2 20 00 	cmp  %o0, 0                                    
4001e214:	02 80 00 4f 	be  4001e350 <rtems_rfs_file_open+0x170>       <== NEVER TAKEN
4001e218:	b8 10 00 08 	mov  %o0, %i4                                  
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return _Chain_Head( the_chain )->next;                              
4001e21c:	fa 04 20 74 	ld  [ %l0 + 0x74 ], %i5                        
    return ENOMEM;                                                    
                                                                      
  memset (handle, 0, sizeof (rtems_rfs_file_handle));                 
4001e220:	c0 22 00 00 	clr  [ %o0 ]                                   
4001e224:	c0 22 20 04 	clr  [ %o0 + 4 ]                               
4001e228:	c0 22 20 10 	clr  [ %o0 + 0x10 ]                            
4001e22c:	c0 22 20 14 	clr  [ %o0 + 0x14 ]                            
4001e230:	c0 22 20 18 	clr  [ %o0 + 0x18 ]                            
4001e234:	c0 22 20 1c 	clr  [ %o0 + 0x1c ]                            
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
  handle->bnum  = 0;                                                  
4001e238:	c0 22 20 08 	clr  [ %o0 + 8 ]                               
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(                             
  const Chain_Control *the_chain,                                     
  const Chain_Node    *the_node                                       
)                                                                     
{                                                                     
  return (the_node == _Chain_Immutable_tail( the_chain ));            
4001e23c:	84 04 20 78 	add  %l0, 0x78, %g2                            
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))               
4001e240:	80 a7 40 02 	cmp  %i5, %g2                                  
4001e244:	12 80 00 06 	bne  4001e25c <rtems_rfs_file_open+0x7c>       
4001e248:	c0 22 20 0c 	clr  [ %o0 + 0xc ]                             
4001e24c:	30 80 00 1b 	b,a   4001e2b8 <rtems_rfs_file_open+0xd8>      
4001e250:	80 a7 40 02 	cmp  %i5, %g2                                  
4001e254:	02 80 00 19 	be  4001e2b8 <rtems_rfs_file_open+0xd8>        <== ALWAYS TAKEN
4001e258:	01 00 00 00 	nop                                            
  {                                                                   
    rtems_rfs_file_shared* shared;                                    
    shared = (rtems_rfs_file_shared*) node;                           
    if (shared->inode.ino == ino)                                     
4001e25c:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
4001e260:	80 a6 40 01 	cmp  %i1, %g1                                  
4001e264:	32 bf ff fb 	bne,a   4001e250 <rtems_rfs_file_open+0x70>    <== ALWAYS TAKEN
4001e268:	fa 07 40 00 	ld  [ %i5 ], %i5                               
   * the reference count and return the pointer to the data.          
   */                                                                 
  shared = rtems_rfs_file_get_shared (fs, ino);                       
  if (shared)                                                         
  {                                                                   
    shared->references++;                                             
4001e26c:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           <== NOT EXECUTED
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))                  
4001e270:	90 10 20 08 	mov  8, %o0                                    <== NOT EXECUTED
   * the reference count and return the pointer to the data.          
   */                                                                 
  shared = rtems_rfs_file_get_shared (fs, ino);                       
  if (shared)                                                         
  {                                                                   
    shared->references++;                                             
4001e274:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))                  
4001e278:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4001e27c:	7f ff d7 0a 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001e280:	c2 27 60 08 	st  %g1, [ %i5 + 8 ]                           <== NOT EXECUTED
4001e284:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001e288:	12 80 00 34 	bne  4001e358 <rtems_rfs_file_open+0x178>      <== NOT EXECUTED
4001e28c:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))                  
      printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
  }                                                                   
                                                                      
  handle->flags  = oflag;                                             
4001e290:	f4 27 00 00 	st  %i2, [ %i4 ]                               <== NOT EXECUTED
  handle->shared = shared;                                            
4001e294:	fa 27 20 1c 	st  %i5, [ %i4 + 0x1c ]                        
                                                                      
  *file = handle;                                                     
4001e298:	f8 26 c0 00 	st  %i4, [ %i3 ]                               
                                                                      
  return 0;                                                           
4001e29c:	81 c7 e0 08 	ret                                            
4001e2a0:	91 e8 20 00 	restore  %g0, 0, %o0                           
  rtems_rfs_file_handle* handle;                                      
  rtems_rfs_file_shared* shared;                                      
  int                    rc;                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))                    
    printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);          
4001e2a4:	11 10 00 de 	sethi  %hi(0x40037800), %o0                    <== NOT EXECUTED
4001e2a8:	40 00 17 35 	call  40023f7c <printf>                        <== NOT EXECUTED
4001e2ac:	90 12 21 38 	or  %o0, 0x138, %o0	! 40037938 <CSWTCH.2+0xd48><== NOT EXECUTED
                                                                      
  *file = NULL;                                                       
4001e2b0:	10 bf ff d5 	b  4001e204 <rtems_rfs_file_open+0x24>         <== NOT EXECUTED
4001e2b4:	c0 26 c0 00 	clr  [ %i3 ]                                   <== 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));                 
4001e2b8:	7f ff a8 c1 	call  400085bc <malloc>                        
4001e2bc:	90 10 20 9c 	mov  0x9c, %o0                                 
    if (!shared)                                                      
4001e2c0:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001e2c4:	02 80 00 46 	be  4001e3dc <rtems_rfs_file_open+0x1fc>       <== NEVER TAKEN
4001e2c8:	92 10 20 00 	clr  %o1                                       
      rtems_rfs_buffer_handle_close (fs, &handle->buffer);            
      free (handle);                                                  
      return ENOMEM;                                                  
    }                                                                 
                                                                      
    memset (shared, 0, sizeof (rtems_rfs_file_shared));               
4001e2cc:	40 00 16 ae 	call  40023d84 <memset>                        
4001e2d0:	94 10 20 9c 	mov  0x9c, %o2                                 
                                                                      
    rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);        
4001e2d4:	a2 07 60 0c 	add  %i5, 0xc, %l1                             
4001e2d8:	90 10 00 10 	mov  %l0, %o0                                  
4001e2dc:	92 10 00 19 	mov  %i1, %o1                                  
4001e2e0:	94 10 00 11 	mov  %l1, %o2                                  
4001e2e4:	7f ff d0 49 	call  40012408 <rtems_rfs_inode_open>          
4001e2e8:	96 10 20 01 	mov  1, %o3                                    
    if (rc > 0)                                                       
4001e2ec:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001e2f0:	04 80 00 23 	ble  4001e37c <rtems_rfs_file_open+0x19c>      <== ALWAYS TAKEN
4001e2f4:	90 10 20 08 	mov  8, %o0                                    
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))                
4001e2f8:	7f ff d6 eb 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001e2fc:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4001e300:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001e304:	02 80 00 09 	be  4001e328 <rtems_rfs_file_open+0x148>       <== NOT EXECUTED
4001e308:	01 00 00 00 	nop                                            <== NOT EXECUTED
        printf ("rtems-rfs: file-open: inode open failed: %d: %s\n",  
4001e30c:	40 00 1b 66 	call  400250a4 <strerror>                      <== NOT EXECUTED
4001e310:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001e314:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
4001e318:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
4001e31c:	11 10 00 de 	sethi  %hi(0x40037800), %o0                    <== NOT EXECUTED
4001e320:	40 00 17 17 	call  40023f7c <printf>                        <== NOT EXECUTED
4001e324:	90 12 21 80 	or  %o0, 0x180, %o0	! 40037980 <CSWTCH.2+0xd90><== 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);                     
      free (shared);                                                  
4001e328:	7f ff a7 08 	call  40007f48 <free>                          <== NOT EXECUTED
4001e32c:	90 10 00 1d 	mov  %i5, %o0                                  <== 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);                       
4001e330:	90 10 00 10 	mov  %l0, %o0                                  <== NOT EXECUTED
4001e334:	7f ff f8 41 	call  4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001e338:	92 07 20 04 	add  %i4, 4, %o1                               <== NOT EXECUTED
      rtems_rfs_buffer_handle_close (fs, &handle->buffer);            
      free (handle);                                                  
4001e33c:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
4001e340:	c0 2f 20 04 	clrb  [ %i4 + 4 ]                              <== NOT EXECUTED
  handle->bnum  = 0;                                                  
4001e344:	c0 27 20 08 	clr  [ %i4 + 8 ]                               <== NOT EXECUTED
4001e348:	7f ff a7 00 	call  40007f48 <free>                          <== NOT EXECUTED
4001e34c:	c0 27 20 0c 	clr  [ %i4 + 0xc ]                             <== NOT EXECUTED
      return rc;                                                      
4001e350:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001e354:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  shared = rtems_rfs_file_get_shared (fs, ino);                       
  if (shared)                                                         
  {                                                                   
    shared->references++;                                             
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))                  
      printf ("rtems-rfs: file-open: ino=%" PRId32 " shared\n", ino); 
4001e358:	11 10 00 de 	sethi  %hi(0x40037800), %o0                    <== NOT EXECUTED
  handle->flags  = oflag;                                             
  handle->shared = shared;                                            
                                                                      
  *file = handle;                                                     
                                                                      
  return 0;                                                           
4001e35c:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
  shared = rtems_rfs_file_get_shared (fs, ino);                       
  if (shared)                                                         
  {                                                                   
    shared->references++;                                             
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))                  
      printf ("rtems-rfs: file-open: ino=%" PRId32 " shared\n", ino); 
4001e360:	40 00 17 07 	call  40023f7c <printf>                        <== NOT EXECUTED
4001e364:	90 12 21 58 	or  %o0, 0x158, %o0                            <== NOT EXECUTED
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))                  
      printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
  }                                                                   
                                                                      
  handle->flags  = oflag;                                             
4001e368:	f4 27 00 00 	st  %i2, [ %i4 ]                               <== NOT EXECUTED
  handle->shared = shared;                                            
4001e36c:	fa 27 20 1c 	st  %i5, [ %i4 + 0x1c ]                        <== NOT EXECUTED
                                                                      
  *file = handle;                                                     
4001e370:	f8 26 c0 00 	st  %i4, [ %i3 ]                               <== NOT EXECUTED
                                                                      
  return 0;                                                           
4001e374:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001e378:	81 e8 00 00 	restore                                        <== 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); 
4001e37c:	90 10 00 10 	mov  %l0, %o0                                  
4001e380:	92 10 00 11 	mov  %l1, %o1                                  
4001e384:	7f ff f4 a3 	call  4001b610 <rtems_rfs_block_map_open>      
4001e388:	94 07 60 34 	add  %i5, 0x34, %o2                            
    if (rc > 0)                                                       
4001e38c:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001e390:	24 80 00 1e 	ble,a   4001e408 <rtems_rfs_file_open+0x228>   <== ALWAYS TAKEN
4001e394:	c2 07 60 18 	ld  [ %i5 + 0x18 ], %g1                        
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))                
4001e398:	90 10 20 08 	mov  8, %o0                                    <== NOT EXECUTED
4001e39c:	7f ff d6 c2 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001e3a0:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4001e3a4:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001e3a8:	22 80 00 0a 	be,a   4001e3d0 <rtems_rfs_file_open+0x1f0>    <== NOT EXECUTED
4001e3ac:	92 10 00 11 	mov  %l1, %o1                                  <== NOT EXECUTED
        printf ("rtems-rfs: file-open: block map open failed: %d: %s\n",
4001e3b0:	40 00 1b 3d 	call  400250a4 <strerror>                      <== NOT EXECUTED
4001e3b4:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001e3b8:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
4001e3bc:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
4001e3c0:	11 10 00 de 	sethi  %hi(0x40037800), %o0                    <== NOT EXECUTED
4001e3c4:	40 00 16 ee 	call  40023f7c <printf>                        <== NOT EXECUTED
4001e3c8:	90 12 21 b8 	or  %o0, 0x1b8, %o0	! 400379b8 <CSWTCH.2+0xdc8><== NOT EXECUTED
                rc, strerror (rc));                                   
      rtems_rfs_inode_close (fs, &shared->inode);                     
4001e3cc:	92 10 00 11 	mov  %l1, %o1                                  <== NOT EXECUTED
4001e3d0:	7f ff d0 86 	call  400125e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
4001e3d4:	90 10 00 10 	mov  %l0, %o0                                  <== NOT EXECUTED
4001e3d8:	30 bf ff d4 	b,a   4001e328 <rtems_rfs_file_open+0x148>     <== 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);                       
4001e3dc:	92 07 20 04 	add  %i4, 4, %o1                               <== NOT EXECUTED
4001e3e0:	7f ff f8 16 	call  4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001e3e4:	90 10 00 10 	mov  %l0, %o0                                  <== NOT EXECUTED
    shared = malloc (sizeof (rtems_rfs_file_shared));                 
    if (!shared)                                                      
    {                                                                 
      rtems_rfs_buffer_handle_close (fs, &handle->buffer);            
      free (handle);                                                  
      return ENOMEM;                                                  
4001e3e8:	b0 10 20 0c 	mov  0xc, %i0                                  <== NOT EXECUTED
     */                                                               
    shared = malloc (sizeof (rtems_rfs_file_shared));                 
    if (!shared)                                                      
    {                                                                 
      rtems_rfs_buffer_handle_close (fs, &handle->buffer);            
      free (handle);                                                  
4001e3ec:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
4001e3f0:	c0 2f 20 04 	clrb  [ %i4 + 4 ]                              <== NOT EXECUTED
  handle->bnum  = 0;                                                  
4001e3f4:	c0 27 20 08 	clr  [ %i4 + 8 ]                               <== NOT EXECUTED
4001e3f8:	7f ff a6 d4 	call  40007f48 <free>                          <== NOT EXECUTED
4001e3fc:	c0 27 20 0c 	clr  [ %i4 + 0xc ]                             <== NOT EXECUTED
      return ENOMEM;                                                  
4001e400:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001e404:	81 e8 00 00 	restore                                        <== NOT EXECUTED
      rtems_rfs_buffer_handle_close (fs, &handle->buffer);            
      free (handle);                                                  
      return rc;                                                      
    }                                                                 
                                                                      
    shared->references = 1;                                           
4001e408:	84 10 20 01 	mov  1, %g2                                    
4001e40c:	c4 27 60 08 	st  %g2, [ %i5 + 8 ]                           
 * @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);             
4001e410:	f0 08 60 0c 	ldub  [ %g1 + 0xc ], %i0                       
4001e414:	c8 08 60 0d 	ldub  [ %g1 + 0xd ], %g4                       
4001e418:	c6 08 60 0f 	ldub  [ %g1 + 0xf ], %g3                       
4001e41c:	c4 08 60 0e 	ldub  [ %g1 + 0xe ], %g2                       
4001e420:	b1 2e 20 18 	sll  %i0, 0x18, %i0                            
4001e424:	89 29 20 10 	sll  %g4, 0x10, %g4                            
4001e428:	85 28 a0 08 	sll  %g2, 8, %g2                               
4001e42c:	88 16 00 04 	or  %i0, %g4, %g4                              
4001e430:	86 11 00 03 	or  %g4, %g3, %g3                              
4001e434:	84 10 c0 02 	or  %g3, %g2, %g2                              
    shared->size.count = rtems_rfs_inode_get_block_count (&shared->inode);
4001e438:	c4 27 60 84 	st  %g2, [ %i5 + 0x84 ]                        
    shared->size.offset = rtems_rfs_inode_get_block_offset (&shared->inode);
4001e43c:	c6 08 60 0b 	ldub  [ %g1 + 0xb ], %g3                       
 * @return uint32_t The block offset.                                 
 */                                                                   
static inline uint16_t                                                
rtems_rfs_inode_get_block_offset (rtems_rfs_inode_handle* handle)     
{                                                                     
  return rtems_rfs_read_u16 (&handle->node->block_offset);            
4001e440:	c4 08 60 0a 	ldub  [ %g1 + 0xa ], %g2                       
4001e444:	90 04 20 74 	add  %l0, 0x74, %o0                            
4001e448:	85 28 a0 08 	sll  %g2, 8, %g2                               
4001e44c:	84 10 c0 02 	or  %g3, %g2, %g2                              
4001e450:	c4 27 60 88 	st  %g2, [ %i5 + 0x88 ]                        
 * @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);                   
4001e454:	f0 08 60 10 	ldub  [ %g1 + 0x10 ], %i0                      
4001e458:	c8 08 60 11 	ldub  [ %g1 + 0x11 ], %g4                      
4001e45c:	c6 08 60 13 	ldub  [ %g1 + 0x13 ], %g3                      
4001e460:	c4 08 60 12 	ldub  [ %g1 + 0x12 ], %g2                      
4001e464:	b1 2e 20 18 	sll  %i0, 0x18, %i0                            
4001e468:	89 29 20 10 	sll  %g4, 0x10, %g4                            
4001e46c:	85 28 a0 08 	sll  %g2, 8, %g2                               
4001e470:	88 16 00 04 	or  %i0, %g4, %g4                              
4001e474:	86 11 00 03 	or  %g4, %g3, %g3                              
4001e478:	84 10 c0 02 	or  %g3, %g2, %g2                              
    shared->atime = rtems_rfs_inode_get_atime (&shared->inode);       
4001e47c:	c4 27 60 8c 	st  %g2, [ %i5 + 0x8c ]                        
 * @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);                   
4001e480:	f0 08 60 14 	ldub  [ %g1 + 0x14 ], %i0                      
4001e484:	c8 08 60 15 	ldub  [ %g1 + 0x15 ], %g4                      
4001e488:	c6 08 60 17 	ldub  [ %g1 + 0x17 ], %g3                      
4001e48c:	c4 08 60 16 	ldub  [ %g1 + 0x16 ], %g2                      
4001e490:	b1 2e 20 18 	sll  %i0, 0x18, %i0                            
4001e494:	89 29 20 10 	sll  %g4, 0x10, %g4                            
4001e498:	85 28 a0 08 	sll  %g2, 8, %g2                               
4001e49c:	88 16 00 04 	or  %i0, %g4, %g4                              
4001e4a0:	86 11 00 03 	or  %g4, %g3, %g3                              
4001e4a4:	84 10 c0 02 	or  %g3, %g2, %g2                              
    shared->mtime = rtems_rfs_inode_get_mtime (&shared->inode);       
4001e4a8:	c4 27 60 90 	st  %g2, [ %i5 + 0x90 ]                        
 * @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);                   
4001e4ac:	c8 08 60 18 	ldub  [ %g1 + 0x18 ], %g4                      
4001e4b0:	c6 08 60 19 	ldub  [ %g1 + 0x19 ], %g3                      
4001e4b4:	c4 08 60 1b 	ldub  [ %g1 + 0x1b ], %g2                      
4001e4b8:	c2 08 60 1a 	ldub  [ %g1 + 0x1a ], %g1                      
4001e4bc:	89 29 20 18 	sll  %g4, 0x18, %g4                            
4001e4c0:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
4001e4c4:	83 28 60 08 	sll  %g1, 8, %g1                               
4001e4c8:	86 11 00 03 	or  %g4, %g3, %g3                              
4001e4cc:	84 10 c0 02 	or  %g3, %g2, %g2                              
4001e4d0:	82 10 80 01 	or  %g2, %g1, %g1                              
4001e4d4:	92 10 00 1d 	mov  %i5, %o1                                  
    shared->ctime = rtems_rfs_inode_get_ctime (&shared->inode);       
4001e4d8:	c2 27 60 94 	st  %g1, [ %i5 + 0x94 ]                        
4001e4dc:	7f ff bc d4 	call  4000d82c <_Chain_Append>                 
4001e4e0:	e0 27 60 98 	st  %l0, [ %i5 + 0x98 ]                        
    shared->fs = fs;                                                  
                                                                      
    rtems_chain_append (&fs->file_shares, &shared->link);             
                                                                      
    rtems_rfs_inode_unload (fs, &shared->inode, false);               
4001e4e4:	92 10 00 11 	mov  %l1, %o1                                  
4001e4e8:	94 10 20 00 	clr  %o2                                       
4001e4ec:	7f ff cf fe 	call  400124e4 <rtems_rfs_inode_unload>        
4001e4f0:	90 10 00 10 	mov  %l0, %o0                                  
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))                  
4001e4f4:	90 10 20 08 	mov  8, %o0                                    
4001e4f8:	7f ff d6 6b 	call  40013ea4 <rtems_rfs_trace>               
4001e4fc:	92 10 20 00 	clr  %o1                                       
4001e500:	80 8a 20 ff 	btst  0xff, %o0                                
4001e504:	22 bf ff 64 	be,a   4001e294 <rtems_rfs_file_open+0xb4>     <== ALWAYS TAKEN
4001e508:	f4 27 00 00 	st  %i2, [ %i4 ]                               
      printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
4001e50c:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
4001e510:	11 10 00 de 	sethi  %hi(0x40037800), %o0                    <== NOT EXECUTED
4001e514:	40 00 16 9a 	call  40023f7c <printf>                        <== NOT EXECUTED
4001e518:	90 12 21 f0 	or  %o0, 0x1f0, %o0	! 400379f0 <CSWTCH.2+0xe00><== NOT EXECUTED
  }                                                                   
                                                                      
  handle->flags  = oflag;                                             
4001e51c:	10 bf ff 5e 	b  4001e294 <rtems_rfs_file_open+0xb4>         <== NOT EXECUTED
4001e520:	f4 27 00 00 	st  %i2, [ %i4 ]                               <== NOT EXECUTED
                                                                      

4001ed58 <rtems_rfs_file_seek>: int rtems_rfs_file_seek (rtems_rfs_file_handle* handle, rtems_rfs_pos pos, rtems_rfs_pos* new_pos) {
4001ed58:	9d e3 bf 98 	save  %sp, -104, %sp                           
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                      
4001ed5c:	90 10 20 20 	mov  0x20, %o0                                 
4001ed60:	92 10 20 00 	clr  %o1                                       
4001ed64:	7f ff d4 50 	call  40013ea4 <rtems_rfs_trace>               
4001ed68:	ba 10 00 18 	mov  %i0, %i5                                  
4001ed6c:	80 8a 20 ff 	btst  0xff, %o0                                
4001ed70:	32 80 00 2b 	bne,a   4001ee1c <rtems_rfs_file_seek+0xc4>    <== NEVER TAKEN
4001ed74:	92 10 00 19 	mov  %i1, %o1                                  <== 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),
4001ed78:	d2 07 60 1c 	ld  [ %i5 + 0x1c ], %o1                        
4001ed7c:	d0 02 60 98 	ld  [ %o1 + 0x98 ], %o0                        
4001ed80:	7f ff f2 0e 	call  4001b5b8 <rtems_rfs_block_get_size>      
4001ed84:	92 02 60 84 	add  %o1, 0x84, %o1                            
4001ed88:	80 a6 40 08 	cmp  %i1, %o0                                  
4001ed8c:	18 80 00 1b 	bgu  4001edf8 <rtems_rfs_file_seek+0xa0>       <== NEVER TAKEN
4001ed90:	01 00 00 00 	nop                                            
4001ed94:	02 80 00 17 	be  4001edf0 <rtems_rfs_file_seek+0x98>        <== ALWAYS TAKEN
4001ed98:	80 a6 80 09 	cmp  %i2, %o1                                  
                                            handle->shared))          
  {                                                                   
    rtems_rfs_file_set_bpos (handle, pos);                            
4001ed9c:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        <== NOT EXECUTED
4001eda0:	b8 07 60 10 	add  %i5, 0x10, %i4                            
4001eda4:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
4001eda8:	92 10 00 19 	mov  %i1, %o1                                  
4001edac:	94 10 00 1a 	mov  %i2, %o2                                  
4001edb0:	7f ff f1 d3 	call  4001b4fc <rtems_rfs_block_get_bpos>      
4001edb4:	96 10 00 1c 	mov  %i4, %o3                                  
    /*                                                                
     * 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))          
4001edb8:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
4001edbc:	80 a0 60 00 	cmp  %g1, 0                                    
4001edc0:	02 80 00 13 	be  4001ee0c <rtems_rfs_file_seek+0xb4>        
4001edc4:	94 10 00 1c 	mov  %i4, %o2                                  
    {                                                                 
      rtems_rfs_buffer_block block;                                   
      int                    rc;                                      
                                                                      
      rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),      
4001edc8:	d2 07 60 1c 	ld  [ %i5 + 0x1c ], %o1                        
4001edcc:	d0 02 60 98 	ld  [ %o1 + 0x98 ], %o0                        
4001edd0:	96 07 bf fc 	add  %fp, -4, %o3                              
4001edd4:	7f ff f2 e4 	call  4001b964 <rtems_rfs_block_map_find>      
4001edd8:	92 02 60 34 	add  %o1, 0x34, %o1                            
                                     rtems_rfs_file_map (handle),     
                                     rtems_rfs_file_bpos (handle),    
                                     &block);                         
      if (rc > 0)                                                     
4001eddc:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001ede0:	24 80 00 15 	ble,a   4001ee34 <rtems_rfs_file_seek+0xdc>    <== ALWAYS TAKEN
4001ede4:	c4 07 60 08 	ld  [ %i5 + 8 ], %g2                           
      return rc;                                                      
  }                                                                   
                                                                      
  *new_pos = pos;                                                     
  return 0;                                                           
}                                                                     
4001ede8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001edec:	81 e8 00 00 	restore                                        <== 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),
4001edf0:	28 bf ff ec 	bleu,a   4001eda0 <rtems_rfs_file_seek+0x48>   
4001edf4:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
  {                                                                   
    /*                                                                
     * 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);                      
4001edf8:	7f ff ff cd 	call  4001ed2c <rtems_rfs_file_io_release>     
4001edfc:	90 10 00 1d 	mov  %i5, %o0                                  
    if (rc > 0)                                                       
4001ee00:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001ee04:	14 80 00 16 	bg  4001ee5c <rtems_rfs_file_seek+0x104>       <== NEVER TAKEN
4001ee08:	01 00 00 00 	nop                                            
      return rc;                                                      
  }                                                                   
                                                                      
  *new_pos = pos;                                                     
4001ee0c:	f2 26 c0 00 	st  %i1, [ %i3 ]                               
4001ee10:	f4 26 e0 04 	st  %i2, [ %i3 + 4 ]                           
  return 0;                                                           
}                                                                     
4001ee14:	81 c7 e0 08 	ret                                            
4001ee18:	91 e8 20 00 	restore  %g0, 0, %o0                           
rtems_rfs_file_seek (rtems_rfs_file_handle* handle,                   
                     rtems_rfs_pos          pos,                      
                     rtems_rfs_pos*         new_pos)                  
{                                                                     
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                      
    printf ("rtems-rfs: file-seek: new=%" PRIu64 "\n", pos);          
4001ee1c:	11 10 00 df 	sethi  %hi(0x40037c00), %o0                    <== NOT EXECUTED
4001ee20:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
4001ee24:	40 00 14 56 	call  40023f7c <printf>                        <== NOT EXECUTED
4001ee28:	90 12 20 58 	or  %o0, 0x58, %o0                             <== 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),
4001ee2c:	10 bf ff d4 	b  4001ed7c <rtems_rfs_file_seek+0x24>         <== NOT EXECUTED
4001ee30:	d2 07 60 1c 	ld  [ %i5 + 0x1c ], %o1                        <== NOT EXECUTED
                                     rtems_rfs_file_map (handle),     
                                     rtems_rfs_file_bpos (handle),    
                                     &block);                         
      if (rc > 0)                                                     
        return rc;                                                    
      if (rtems_rfs_buffer_bnum (&handle->buffer) != block)           
4001ee34:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4001ee38:	80 a0 80 01 	cmp  %g2, %g1                                  
4001ee3c:	02 bf ff f4 	be  4001ee0c <rtems_rfs_file_seek+0xb4>        <== ALWAYS TAKEN
4001ee40:	92 07 60 04 	add  %i5, 4, %o1                               
      {                                                               
        rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
4001ee44:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        <== NOT EXECUTED
4001ee48:	7f ff f5 7c 	call  4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001ee4c:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        <== NOT EXECUTED
                                              rtems_rfs_file_buffer (handle));
        if (rc > 0)                                                   
4001ee50:	b0 92 20 00 	orcc  %o0, 0, %i0                              <== NOT EXECUTED
4001ee54:	24 bf ff ef 	ble,a   4001ee10 <rtems_rfs_file_seek+0xb8>    <== NOT EXECUTED
4001ee58:	f2 26 c0 00 	st  %i1, [ %i3 ]                               <== NOT EXECUTED
      return rc;                                                      
  }                                                                   
                                                                      
  *new_pos = pos;                                                     
  return 0;                                                           
}                                                                     
4001ee5c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001ee60:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4001ee64 <rtems_rfs_file_set_size>: int rtems_rfs_file_set_size (rtems_rfs_file_handle* handle, rtems_rfs_pos new_size) {
4001ee64:	9d e3 bf 90 	save  %sp, -112, %sp                           
  rtems_rfs_block_map* map  = rtems_rfs_file_map (handle);            
4001ee68:	f6 06 20 1c 	ld  [ %i0 + 0x1c ], %i3                        
  rtems_rfs_pos        size;                                          
  int                  rc;                                            
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                      
4001ee6c:	90 10 20 20 	mov  0x20, %o0                                 
4001ee70:	92 10 20 00 	clr  %o1                                       
4001ee74:	7f ff d4 0c 	call  40013ea4 <rtems_rfs_trace>               
4001ee78:	b8 10 00 19 	mov  %i1, %i4                                  
}                                                                     
                                                                      
int                                                                   
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,               
                         rtems_rfs_pos          new_size)             
{                                                                     
4001ee7c:	ba 10 00 1a 	mov  %i2, %i5                                  
  rtems_rfs_block_map* map  = rtems_rfs_file_map (handle);            
  rtems_rfs_pos        size;                                          
  int                  rc;                                            
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                      
4001ee80:	80 8a 20 ff 	btst  0xff, %o0                                
4001ee84:	12 80 00 92 	bne  4001f0cc <rtems_rfs_file_set_size+0x268>  <== NEVER TAKEN
4001ee88:	b2 06 e0 34 	add  %i3, 0x34, %i1                            
    printf ("rtems-rfs: file-set-size: size=%" PRIu64 "\n", new_size);
                                                                      
  size = rtems_rfs_file_size (handle);                                
4001ee8c:	d2 06 20 1c 	ld  [ %i0 + 0x1c ], %o1                        
4001ee90:	d0 02 60 98 	ld  [ %o1 + 0x98 ], %o0                        
4001ee94:	7f ff f1 c9 	call  4001b5b8 <rtems_rfs_block_get_size>      
4001ee98:	92 02 60 84 	add  %o1, 0x84, %o1                            
  /*                                                                  
   * 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)                                               
4001ee9c:	80 a7 00 08 	cmp  %i4, %o0                                  
4001eea0:	02 80 00 98 	be  4001f100 <rtems_rfs_file_set_size+0x29c>   <== ALWAYS TAKEN
4001eea4:	80 a7 40 09 	cmp  %i5, %o1                                  
  {                                                                   
    /*                                                                
     * Short cut for the common truncate on open call.                
     */                                                               
    if (new_size == 0)                                                
4001eea8:	80 97 00 1d 	orcc  %i4, %i5, %g0                            <== NOT EXECUTED
4001eeac:	22 80 00 9a 	be,a   4001f114 <rtems_rfs_file_set_size+0x2b0><== NOT EXECUTED
4001eeb0:	c2 06 20 1c 	ld  [ %i0 + 0x1c ], %g1                        <== NOT EXECUTED
      if (rc > 0)                                                     
        return rc;                                                    
    }                                                                 
    else                                                              
    {                                                                 
      if (size < new_size)                                            
4001eeb4:	80 a7 00 08 	cmp  %i4, %o0                                  <== NOT EXECUTED
4001eeb8:	08 80 00 57 	bleu  4001f014 <rtems_rfs_file_set_size+0x1b0> <== ALWAYS TAKEN
4001eebc:	01 00 00 00 	nop                                            
        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));
4001eec0:	e8 06 20 1c 	ld  [ %i0 + 0x1c ], %l4                        <== NOT EXECUTED
         */                                                           
        rtems_rfs_pos count;                                          
        uint32_t      length;                                         
        bool          read_block;                                     
                                                                      
        count = new_size - size;                                      
4001eec4:	ba a7 40 09 	subcc  %i5, %o1, %i5                           
        length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
4001eec8:	c2 05 20 98 	ld  [ %l4 + 0x98 ], %g1                        
         */                                                           
        rtems_rfs_pos count;                                          
        uint32_t      length;                                         
        bool          read_block;                                     
                                                                      
        count = new_size - size;                                      
4001eecc:	b8 67 00 08 	subx  %i4, %o0, %i4                            
        length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
4001eed0:	a6 10 00 14 	mov  %l4, %l3                                  
4001eed4:	f4 00 60 08 	ld  [ %g1 + 8 ], %i2                           
        read_block = false;                                           
                                                                      
        while (count)                                                 
4001eed8:	a4 10 20 00 	clr  %l2                                       
4001eedc:	a2 10 20 01 	mov  1, %l1                                    
4001eee0:	80 97 00 1d 	orcc  %i4, %i5, %g0                            
4001eee4:	12 80 00 2a 	bne  4001ef8c <rtems_rfs_file_set_size+0x128>  <== ALWAYS TAKEN
4001eee8:	a0 06 20 04 	add  %i0, 4, %l0                               
4001eeec:	10 80 00 92 	b  4001f134 <rtems_rfs_file_set_size+0x2d0>    <== NOT EXECUTED
4001eef0:	f4 06 e0 3c 	ld  [ %i3 + 0x3c ], %i2                        <== NOT EXECUTED
                                           map, 1, &block);           
            if (rc > 0)                                               
              return rc;                                              
          }                                                           
                                                                      
          if (count < (length - bpos.boff))                           
4001eef4:	80 a0 80 1d 	cmp  %g2, %i5                                  
4001eef8:	28 80 00 45 	bleu,a   4001f00c <rtems_rfs_file_set_size+0x1a8>
4001eefc:	c0 26 e0 40 	clr  [ %i3 + 0x40 ]                            
          {                                                           
            length = count + bpos.boff;                               
4001ef00:	b4 00 40 1d 	add  %g1, %i5, %i2                             
4001ef04:	e2 2e e0 34 	stb  %l1, [ %i3 + 0x34 ]                       
 */                                                                   
static inline void                                                    
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,        
                                     rtems_rfs_block_off  offset)     
{                                                                     
  map->size.offset = offset;                                          
4001ef08:	f4 26 e0 40 	st  %i2, [ %i3 + 0x40 ]                        
            read_block = true;                                        
4001ef0c:	a4 10 20 01 	mov  1, %l2                                    
          }                                                           
                                                                      
          /*                                                          
           * Only read the block if the length is not the block size. 
           */                                                         
          rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
4001ef10:	c2 06 20 1c 	ld  [ %i0 + 0x1c ], %g1                        
4001ef14:	d4 07 bf f0 	ld  [ %fp + -16 ], %o2                         
4001ef18:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
4001ef1c:	92 10 00 10 	mov  %l0, %o1                                  
4001ef20:	7f ff f5 c0 	call  4001c620 <rtems_rfs_buffer_handle_request>
4001ef24:	96 0c a0 01 	and  %l2, 1, %o3                               
                                                rtems_rfs_file_buffer (handle),
                                                block, read_block);   
          if (rc > 0)                                                 
4001ef28:	82 92 20 00 	orcc  %o0, 0, %g1                              
4001ef2c:	14 80 00 66 	bg  4001f0c4 <rtems_rfs_file_set_size+0x260>   <== NEVER TAKEN
4001ef30:	92 10 20 00 	clr  %o1                                       
            return rc;                                                
                                                                      
          dst = rtems_rfs_buffer_data (&handle->buffer);              
4001ef34:	c4 06 20 0c 	ld  [ %i0 + 0xc ], %g2                         
          memset (dst + bpos.boff, 0, length - bpos.boff);            
4001ef38:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
4001ef3c:	d0 00 a0 1c 	ld  [ %g2 + 0x1c ], %o0                        
4001ef40:	94 26 80 01 	sub  %i2, %g1, %o2                             
4001ef44:	40 00 13 90 	call  40023d84 <memset>                        
4001ef48:	90 02 00 01 	add  %o0, %g1, %o0                             
                                                                      
          rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
                                                                      
          rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
4001ef4c:	c2 06 20 1c 	ld  [ %i0 + 0x1c ], %g1                        
            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));
4001ef50:	e2 2e 20 04 	stb  %l1, [ %i0 + 4 ]                          
                                                                      
          rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
4001ef54:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
4001ef58:	7f ff f5 38 	call  4001c438 <rtems_rfs_buffer_handle_release>
4001ef5c:	92 10 00 10 	mov  %l0, %o1                                  
                                                rtems_rfs_file_buffer (handle));
          if (rc > 0)                                                 
4001ef60:	82 92 20 00 	orcc  %o0, 0, %g1                              
4001ef64:	14 80 00 58 	bg  4001f0c4 <rtems_rfs_file_set_size+0x260>   <== NEVER TAKEN
4001ef68:	01 00 00 00 	nop                                            
            return rc;                                                
                                                                      
          count -= length - bpos.boff;                                
4001ef6c:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
4001ef70:	82 26 80 01 	sub  %i2, %g1, %g1                             
4001ef74:	ba a7 40 01 	subcc  %i5, %g1, %i5                           
4001ef78:	b8 67 20 00 	subx  %i4, 0, %i4                              
                                                                      
        count = new_size - size;                                      
        length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
        read_block = false;                                           
                                                                      
        while (count)                                                 
4001ef7c:	80 97 00 1d 	orcc  %i4, %i5, %g0                            
4001ef80:	22 80 00 6c 	be,a   4001f130 <rtems_rfs_file_set_size+0x2cc>
4001ef84:	e8 06 20 1c 	ld  [ %i0 + 0x1c ], %l4                        
4001ef88:	e6 06 20 1c 	ld  [ %i0 + 0x1c ], %l3                        
          /*                                                          
           * 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);
4001ef8c:	c2 06 e0 40 	ld  [ %i3 + 0x40 ], %g1                        
4001ef90:	c4 06 e0 3c 	ld  [ %i3 + 0x3c ], %g2                        
4001ef94:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]                          
4001ef98:	c4 27 bf f4 	st  %g2, [ %fp + -12 ]                         
4001ef9c:	80 a0 60 00 	cmp  %g1, 0                                    
4001efa0:	02 80 00 04 	be  4001efb0 <rtems_rfs_file_set_size+0x14c>   
4001efa4:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
4001efa8:	84 00 bf ff 	add  %g2, -1, %g2                              
4001efac:	c4 27 bf f4 	st  %g2, [ %fp + -12 ]                         
          rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),  
4001efb0:	d0 04 e0 98 	ld  [ %l3 + 0x98 ], %o0                        
4001efb4:	92 10 00 19 	mov  %i1, %o1                                  
4001efb8:	94 07 bf f4 	add  %fp, -12, %o2                             
4001efbc:	7f ff f2 6a 	call  4001b964 <rtems_rfs_block_map_find>      
4001efc0:	96 07 bf f0 	add  %fp, -16, %o3                             
                                         map, &bpos, &block);         
          if (rc > 0)                                                 
4001efc4:	82 92 20 00 	orcc  %o0, 0, %g1                              
4001efc8:	04 80 00 0c 	ble  4001eff8 <rtems_rfs_file_set_size+0x194>  
4001efcc:	80 a0 60 06 	cmp  %g1, 6                                    
          {                                                           
            /*                                                        
             * Have we reached the EOF ?                              
             */                                                       
            if (rc != ENXIO)                                          
4001efd0:	12 80 00 3d 	bne  4001f0c4 <rtems_rfs_file_set_size+0x260>  <== NEVER TAKEN
4001efd4:	92 10 00 19 	mov  %i1, %o1                                  
              return rc;                                              
                                                                      
            rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
4001efd8:	c2 06 20 1c 	ld  [ %i0 + 0x1c ], %g1                        
4001efdc:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
4001efe0:	94 10 20 01 	mov  1, %o2                                    
4001efe4:	7f ff f2 e4 	call  4001bb74 <rtems_rfs_block_map_grow>      
4001efe8:	96 07 bf f0 	add  %fp, -16, %o3                             
                                           map, 1, &block);           
            if (rc > 0)                                               
4001efec:	82 92 20 00 	orcc  %o0, 0, %g1                              
4001eff0:	14 80 00 35 	bg  4001f0c4 <rtems_rfs_file_set_size+0x260>   <== NEVER TAKEN
4001eff4:	01 00 00 00 	nop                                            
              return rc;                                              
          }                                                           
                                                                      
          if (count < (length - bpos.boff))                           
4001eff8:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
4001effc:	80 a7 20 00 	cmp  %i4, 0                                    
4001f000:	02 bf ff bd 	be  4001eef4 <rtems_rfs_file_set_size+0x90>    <== ALWAYS TAKEN
4001f004:	84 26 80 01 	sub  %i2, %g1, %g2                             
4001f008:	c0 26 e0 40 	clr  [ %i3 + 0x40 ]                            <== NOT EXECUTED
  map->dirty = true;                                                  
4001f00c:	10 bf ff c1 	b  4001ef10 <rtems_rfs_file_set_size+0xac>     
4001f010:	e2 2e e0 34 	stb  %l1, [ %i3 + 0x34 ]                       
      if (rc > 0)                                                     
        return rc;                                                    
    }                                                                 
    else                                                              
    {                                                                 
      if (size < new_size)                                            
4001f014:	02 80 00 54 	be  4001f164 <rtems_rfs_file_set_size+0x300>   <== ALWAYS TAKEN
4001f018:	80 a7 40 09 	cmp  %i5, %o1                                  
        uint32_t           offset;                                    
                                                                      
        blocks =                                                      
          rtems_rfs_block_map_count (map) -                           
          (((new_size - 1) /                                          
            rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
4001f01c:	e6 06 20 1c 	ld  [ %i0 + 0x1c ], %l3                        <== NOT EXECUTED
         */                                                           
        rtems_rfs_block_no blocks;                                    
        uint32_t           offset;                                    
                                                                      
        blocks =                                                      
          rtems_rfs_block_map_count (map) -                           
4001f020:	f4 06 e0 3c 	ld  [ %i3 + 0x3c ], %i2                        
          (((new_size - 1) /                                          
            rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
4001f024:	e0 04 e0 98 	ld  [ %l3 + 0x98 ], %l0                        
        rtems_rfs_block_no blocks;                                    
        uint32_t           offset;                                    
                                                                      
        blocks =                                                      
          rtems_rfs_block_map_count (map) -                           
          (((new_size - 1) /                                          
4001f028:	92 87 7f ff 	addcc  %i5, -1, %o1                            
4001f02c:	f2 04 20 08 	ld  [ %l0 + 8 ], %i1                           
4001f030:	90 47 3f ff 	addx  %i4, -1, %o0                             
4001f034:	96 10 00 19 	mov  %i1, %o3                                  
4001f038:	40 00 48 24 	call  400310c8 <__udivdi3>                     
4001f03c:	94 10 20 00 	clr  %o2                                       
         * Shrink                                                     
         */                                                           
        rtems_rfs_block_no blocks;                                    
        uint32_t           offset;                                    
                                                                      
        blocks =                                                      
4001f040:	92 38 00 09 	xnor  %g0, %o1, %o1                            
          rtems_rfs_block_map_count (map) -                           
          (((new_size - 1) /                                          
            rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
                                                                      
        offset =                                                      
          new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
4001f044:	96 10 00 19 	mov  %i1, %o3                                  
4001f048:	94 10 20 00 	clr  %o2                                       
         * Shrink                                                     
         */                                                           
        rtems_rfs_block_no blocks;                                    
        uint32_t           offset;                                    
                                                                      
        blocks =                                                      
4001f04c:	b2 02 40 1a 	add  %o1, %i2, %i1                             
          rtems_rfs_block_map_count (map) -                           
          (((new_size - 1) /                                          
            rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
                                                                      
        offset =                                                      
          new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
4001f050:	90 10 00 1c 	mov  %i4, %o0                                  
4001f054:	40 00 48 f1 	call  40031418 <__umoddi3>                     
4001f058:	92 10 00 1d 	mov  %i5, %o1                                  
                                                                      
        if (blocks)                                                   
4001f05c:	80 a6 60 00 	cmp  %i1, 0                                    
4001f060:	12 80 00 4e 	bne  4001f198 <rtems_rfs_file_set_size+0x334>  
4001f064:	ba 10 00 09 	mov  %o1, %i5                                  
            return rc;                                                
        }                                                             
                                                                      
        rtems_rfs_block_map_set_size_offset (map, offset);            
                                                                      
        if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
4001f068:	c2 06 20 10 	ld  [ %i0 + 0x10 ], %g1                        
4001f06c:	84 10 20 01 	mov  1, %g2                                    
 */                                                                   
static inline void                                                    
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,        
                                     rtems_rfs_block_off  offset)     
{                                                                     
  map->size.offset = offset;                                          
4001f070:	fa 26 e0 40 	st  %i5, [ %i3 + 0x40 ]                        
4001f074:	80 a0 60 00 	cmp  %g1, 0                                    
4001f078:	02 80 00 3f 	be  4001f174 <rtems_rfs_file_set_size+0x310>   
4001f07c:	c4 2e e0 34 	stb  %g2, [ %i3 + 0x34 ]                       
4001f080:	80 a6 a0 00 	cmp  %i2, 0                                    
4001f084:	12 80 00 3d 	bne  4001f178 <rtems_rfs_file_set_size+0x314>  <== ALWAYS TAKEN
4001f088:	80 a0 40 1a 	cmp  %g1, %i2                                  
                                          rtems_rfs_block_map_size (map)))
          rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
4001f08c:	f4 26 20 10 	st  %i2, [ %i0 + 0x10 ]                        <== NOT EXECUTED
4001f090:	fa 26 20 14 	st  %i5, [ %i0 + 0x14 ]                        
4001f094:	80 a7 60 00 	cmp  %i5, 0                                    
4001f098:	02 80 00 3e 	be  4001f190 <rtems_rfs_file_set_size+0x32c>   <== NEVER TAKEN
4001f09c:	c0 26 20 18 	clr  [ %i0 + 0x18 ]                            
4001f0a0:	82 06 bf ff 	add  %i2, -1, %g1                              
4001f0a4:	a8 10 00 13 	mov  %l3, %l4                                  
4001f0a8:	c2 26 20 10 	st  %g1, [ %i0 + 0x10 ]                        
    }                                                                 
                                                                      
    handle->shared->size.count  = rtems_rfs_block_map_count (map);    
    handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
                                                                      
    if (rtems_rfs_file_update_mtime (handle))                         
4001f0ac:	c2 06 00 00 	ld  [ %i0 ], %g1                               
          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);    
4001f0b0:	f4 25 20 84 	st  %i2, [ %l4 + 0x84 ]                        
    handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
                                                                      
    if (rtems_rfs_file_update_mtime (handle))                         
4001f0b4:	80 88 60 02 	btst  2, %g1                                   
4001f0b8:	02 80 00 25 	be  4001f14c <rtems_rfs_file_set_size+0x2e8>   <== ALWAYS TAKEN
4001f0bc:	fa 25 20 88 	st  %i5, [ %l4 + 0x88 ]                        
      handle->shared->mtime = time (NULL);                            
  }                                                                   
                                                                      
  return 0;                                                           
4001f0c0:	82 10 20 00 	clr  %g1                                       
}                                                                     
4001f0c4:	81 c7 e0 08 	ret                                            
4001f0c8:	91 e8 00 01 	restore  %g0, %g1, %o0                         
  rtems_rfs_block_map* map  = rtems_rfs_file_map (handle);            
  rtems_rfs_pos        size;                                          
  int                  rc;                                            
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                      
    printf ("rtems-rfs: file-set-size: size=%" PRIu64 "\n", new_size);
4001f0cc:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
4001f0d0:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
4001f0d4:	11 10 00 df 	sethi  %hi(0x40037c00), %o0                    <== NOT EXECUTED
4001f0d8:	40 00 13 a9 	call  40023f7c <printf>                        <== NOT EXECUTED
4001f0dc:	90 12 20 78 	or  %o0, 0x78, %o0	! 40037c78 <CSWTCH.2+0x1088><== NOT EXECUTED
                                                                      
  size = rtems_rfs_file_size (handle);                                
4001f0e0:	d2 06 20 1c 	ld  [ %i0 + 0x1c ], %o1                        <== NOT EXECUTED
4001f0e4:	d0 02 60 98 	ld  [ %o1 + 0x98 ], %o0                        <== NOT EXECUTED
4001f0e8:	7f ff f1 34 	call  4001b5b8 <rtems_rfs_block_get_size>      <== NOT EXECUTED
4001f0ec:	92 02 60 84 	add  %o1, 0x84, %o1                            <== 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)                                               
4001f0f0:	80 a7 00 08 	cmp  %i4, %o0                                  <== NOT EXECUTED
4001f0f4:	12 bf ff 6e 	bne  4001eeac <rtems_rfs_file_set_size+0x48>   <== NOT EXECUTED
4001f0f8:	80 97 00 1d 	orcc  %i4, %i5, %g0                            <== NOT EXECUTED
4001f0fc:	80 a7 40 09 	cmp  %i5, %o1                                  <== NOT EXECUTED
4001f100:	02 bf ff f0 	be  4001f0c0 <rtems_rfs_file_set_size+0x25c>   
4001f104:	80 97 00 1d 	orcc  %i4, %i5, %g0                            
  {                                                                   
    /*                                                                
     * Short cut for the common truncate on open call.                
     */                                                               
    if (new_size == 0)                                                
4001f108:	12 bf ff 6c 	bne  4001eeb8 <rtems_rfs_file_set_size+0x54>   
4001f10c:	80 a7 00 08 	cmp  %i4, %o0                                  
    {                                                                 
      rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map);
4001f110:	c2 06 20 1c 	ld  [ %i0 + 0x1c ], %g1                        
4001f114:	92 10 00 19 	mov  %i1, %o1                                  
4001f118:	7f ff f4 55 	call  4001c26c <rtems_rfs_block_map_free_all>  
4001f11c:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
      if (rc > 0)                                                     
4001f120:	82 92 20 00 	orcc  %o0, 0, %g1                              
4001f124:	14 bf ff e8 	bg  4001f0c4 <rtems_rfs_file_set_size+0x260>   <== NEVER TAKEN
4001f128:	01 00 00 00 	nop                                            
4001f12c:	e8 06 20 1c 	ld  [ %i0 + 0x1c ], %l4                        
4001f130:	f4 06 e0 3c 	ld  [ %i3 + 0x3c ], %i2                        
4001f134:	fa 06 e0 40 	ld  [ %i3 + 0x40 ], %i5                        
    }                                                                 
                                                                      
    handle->shared->size.count  = rtems_rfs_block_map_count (map);    
    handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
                                                                      
    if (rtems_rfs_file_update_mtime (handle))                         
4001f138:	c2 06 00 00 	ld  [ %i0 ], %g1                               
          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);    
4001f13c:	f4 25 20 84 	st  %i2, [ %l4 + 0x84 ]                        
    handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
                                                                      
    if (rtems_rfs_file_update_mtime (handle))                         
4001f140:	80 88 60 02 	btst  2, %g1                                   
4001f144:	12 bf ff df 	bne  4001f0c0 <rtems_rfs_file_set_size+0x25c>  <== NEVER TAKEN
4001f148:	fa 25 20 88 	st  %i5, [ %l4 + 0x88 ]                        
      handle->shared->mtime = time (NULL);                            
4001f14c:	40 00 23 d0 	call  4002808c <time>                          
4001f150:	90 10 20 00 	clr  %o0                                       
  }                                                                   
                                                                      
  return 0;                                                           
4001f154:	82 10 20 00 	clr  %g1                                       
                                                                      
    handle->shared->size.count  = rtems_rfs_block_map_count (map);    
    handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
                                                                      
    if (rtems_rfs_file_update_mtime (handle))                         
      handle->shared->mtime = time (NULL);                            
4001f158:	d0 25 20 90 	st  %o0, [ %l4 + 0x90 ]                        
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
4001f15c:	81 c7 e0 08 	ret                                            
4001f160:	91 e8 00 01 	restore  %g0, %g1, %o0                         
      if (rc > 0)                                                     
        return rc;                                                    
    }                                                                 
    else                                                              
    {                                                                 
      if (size < new_size)                                            
4001f164:	28 bf ff af 	bleu,a   4001f020 <rtems_rfs_file_set_size+0x1bc>
4001f168:	e6 06 20 1c 	ld  [ %i0 + 0x1c ], %l3                        
        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));
4001f16c:	10 bf ff 56 	b  4001eec4 <rtems_rfs_file_set_size+0x60>     
4001f170:	e8 06 20 1c 	ld  [ %i0 + 0x1c ], %l4                        
            return rc;                                                
        }                                                             
                                                                      
        rtems_rfs_block_map_set_size_offset (map, offset);            
                                                                      
        if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
4001f174:	80 a0 40 1a 	cmp  %g1, %i2                                  
4001f178:	3a bf ff c6 	bcc,a   4001f090 <rtems_rfs_file_set_size+0x22c><== NEVER TAKEN
4001f17c:	f4 26 20 10 	st  %i2, [ %i0 + 0x10 ]                        <== NOT EXECUTED
4001f180:	84 06 bf ff 	add  %i2, -1, %g2                              
4001f184:	80 a0 40 02 	cmp  %g1, %g2                                  
4001f188:	22 80 00 0e 	be,a   4001f1c0 <rtems_rfs_file_set_size+0x35c><== ALWAYS TAKEN
4001f18c:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
4001f190:	10 bf ff c7 	b  4001f0ac <rtems_rfs_file_set_size+0x248>    <== NOT EXECUTED
4001f194:	a8 10 00 13 	mov  %l3, %l4                                  <== NOT EXECUTED
          new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
                                                                      
        if (blocks)                                                   
        {                                                             
          int rc;                                                     
          rc = rtems_rfs_block_map_shrink (rtems_rfs_file_fs (handle),
4001f198:	90 10 00 10 	mov  %l0, %o0                                  
4001f19c:	92 04 e0 34 	add  %l3, 0x34, %o1                            
4001f1a0:	7f ff f3 6b 	call  4001bf4c <rtems_rfs_block_map_shrink>    
4001f1a4:	94 10 00 19 	mov  %i1, %o2                                  
                                           rtems_rfs_file_map (handle),
                                           blocks);                   
          if (rc > 0)                                                 
4001f1a8:	82 92 20 00 	orcc  %o0, 0, %g1                              
4001f1ac:	14 bf ff c6 	bg  4001f0c4 <rtems_rfs_file_set_size+0x260>   <== NEVER TAKEN
4001f1b0:	01 00 00 00 	nop                                            
4001f1b4:	f4 06 e0 3c 	ld  [ %i3 + 0x3c ], %i2                        
4001f1b8:	10 bf ff ac 	b  4001f068 <rtems_rfs_file_set_size+0x204>    
4001f1bc:	e6 06 20 1c 	ld  [ %i0 + 0x1c ], %l3                        
            return rc;                                                
        }                                                             
                                                                      
        rtems_rfs_block_map_set_size_offset (map, offset);            
                                                                      
        if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
4001f1c0:	80 a7 40 01 	cmp  %i5, %g1                                  
4001f1c4:	2a bf ff b3 	bcs,a   4001f090 <rtems_rfs_file_set_size+0x22c>
4001f1c8:	f4 26 20 10 	st  %i2, [ %i0 + 0x10 ]                        
4001f1cc:	10 bf ff b8 	b  4001f0ac <rtems_rfs_file_set_size+0x248>    
4001f1d0:	a8 10 00 13 	mov  %l3, %l4                                  
                                                                      

40010c78 <rtems_rfs_format>: return rc; } int rtems_rfs_format (const char* name, const rtems_rfs_format_config* config) {
40010c78:	9d e3 be c8 	save  %sp, -312, %sp                           
  rtems_rfs_file_system fs;                                           
  int                   group;                                        
  int                   rc;                                           
                                                                      
  if (config->verbose)                                                
40010c7c:	c2 0e 60 15 	ldub  [ %i1 + 0x15 ], %g1                      
40010c80:	80 a0 60 00 	cmp  %g1, 0                                    
40010c84:	32 80 00 88 	bne,a   40010ea4 <rtems_rfs_format+0x22c>      <== NEVER TAKEN
40010c88:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
    printf ("rtems-rfs: format: %s\n", name);                         
                                                                      
  memset (&fs, 0, sizeof (rtems_rfs_file_system));                    
40010c8c:	92 10 20 00 	clr  %o1                                       
40010c90:	94 10 20 84 	mov  0x84, %o2                                 
40010c94:	40 00 4c 3c 	call  40023d84 <memset>                        
40010c98:	90 07 bf 7c 	add  %fp, -132, %o0                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
40010c9c:	82 07 bf c4 	add  %fp, -60, %g1                             
40010ca0:	c2 27 bf c0 	st  %g1, [ %fp + -64 ]                         
  head->previous = NULL;                                              
  tail->previous = head;                                              
40010ca4:	82 07 bf c0 	add  %fp, -64, %g1                             
40010ca8:	c2 27 bf c8 	st  %g1, [ %fp + -56 ]                         
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
40010cac:	82 07 bf d4 	add  %fp, -44, %g1                             
40010cb0:	c2 27 bf d0 	st  %g1, [ %fp + -48 ]                         
  head->previous = NULL;                                              
  tail->previous = head;                                              
40010cb4:	82 07 bf d0 	add  %fp, -48, %g1                             
40010cb8:	c2 27 bf d8 	st  %g1, [ %fp + -40 ]                         
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
40010cbc:	82 07 bf e4 	add  %fp, -28, %g1                             
40010cc0:	c2 27 bf e0 	st  %g1, [ %fp + -32 ]                         
  head->previous = NULL;                                              
  tail->previous = head;                                              
40010cc4:	82 07 bf e0 	add  %fp, -32, %g1                             
40010cc8:	c2 27 bf e8 	st  %g1, [ %fp + -24 ]                         
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
40010ccc:	82 07 bf f4 	add  %fp, -12, %g1                             
40010cd0:	c2 27 bf f0 	st  %g1, [ %fp + -16 ]                         
  head->previous = NULL;                                              
  tail->previous = head;                                              
40010cd4:	82 07 bf f0 	add  %fp, -16, %g1                             
40010cd8:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]                          
  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;                
40010cdc:	82 10 20 05 	mov  5, %g1                                    
40010ce0:	c2 27 bf bc 	st  %g1, [ %fp + -68 ]                         
                                                                      
  fs.release_count = 0;                                               
  fs.release_modified_count = 0;                                      
                                                                      
  fs.flags = RTEMS_RFS_FS_NO_LOCAL_CACHE;                             
40010ce4:	82 10 20 02 	mov  2, %g1                                    
                                                                      
  /*                                                                  
   * Open the buffer interface.                                       
   */                                                                 
  rc = rtems_rfs_buffer_open (name, &fs);                             
40010ce8:	90 10 00 18 	mov  %i0, %o0                                  
  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;                             
40010cec:	c2 27 bf 7c 	st  %g1, [ %fp + -132 ]                        
                                                                      
  /*                                                                  
   * Open the buffer interface.                                       
   */                                                                 
  rc = rtems_rfs_buffer_open (name, &fs);                             
40010cf0:	40 00 2f 04 	call  4001c900 <rtems_rfs_buffer_open>         
40010cf4:	92 07 bf 7c 	add  %fp, -132, %o1                            
  if (rc > 0)                                                         
40010cf8:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40010cfc:	14 80 02 bd 	bg  400117f0 <rtems_rfs_format+0xb78>          <== NEVER TAKEN
40010d00:	c2 07 bf 8c 	ld  [ %fp + -116 ], %g1                        
  }                                                                   
                                                                      
  /*                                                                  
   * Check the media.                                                 
   */                                                                 
  if (rtems_rfs_fs_media_block_size (&fs) == 0)                       
40010d04:	f8 00 60 20 	ld  [ %g1 + 0x20 ], %i4                        
40010d08:	80 a7 20 00 	cmp  %i4, 0                                    
40010d0c:	02 80 02 c2 	be  40011814 <rtems_rfs_format+0xb9c>          <== NEVER TAKEN
40010d10:	92 10 20 00 	clr  %o1                                       
                                                                      
static bool                                                           
rtems_rfs_check_config (rtems_rfs_file_system*         fs,            
                        const rtems_rfs_format_config* config)        
{                                                                     
  fs->block_size = config->block_size;                                
40010d14:	fa 06 40 00 	ld  [ %i1 ], %i5                               
  if (!fs->block_size)                                                
40010d18:	80 a7 60 00 	cmp  %i5, 0                                    
40010d1c:	02 80 00 d1 	be  40011060 <rtems_rfs_format+0x3e8>          
40010d20:	fa 27 bf 84 	st  %i5, [ %fp + -124 ]                        
                                                                      
    if (fs->block_size > (4 * 1024))                                  
      fs->block_size = (4 * 1024);                                    
  }                                                                   
                                                                      
  if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)     
40010d24:	90 10 00 1d 	mov  %i5, %o0                                  
40010d28:	40 00 7e 2b 	call  400305d4 <.urem>                         
40010d2c:	92 10 00 1c 	mov  %i4, %o1                                  
40010d30:	80 a2 20 00 	cmp  %o0, 0                                    
40010d34:	32 80 00 ef 	bne,a   400110f0 <rtems_rfs_format+0x478>      <== NEVER TAKEN
40010d38:	92 10 00 1d 	mov  %i5, %o1                                  <== 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;                            
40010d3c:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
  {                                                                   
    /*                                                                
     * 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);  
40010d40:	bb 2f 60 03 	sll  %i5, 3, %i5                               
            fs->block_size, rtems_rfs_fs_media_block_size (fs));      
    return false;                                                     
  }                                                                   
                                                                      
  fs->group_blocks = config->group_blocks;                            
  if (!fs->group_blocks)                                              
40010d44:	80 a0 60 00 	cmp  %g1, 0                                    
40010d48:	12 80 00 50 	bne  40010e88 <rtems_rfs_format+0x210>         <== NEVER TAKEN
40010d4c:	c2 27 bf a4 	st  %g1, [ %fp + -92 ]                         
  {                                                                   
    /*                                                                
     * 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);  
40010d50:	fa 27 bf a4 	st  %i5, [ %fp + -92 ]                         
  {                                                                   
    printf ("group block count is higher than bits in block\n");      
    return false;                                                     
  }                                                                   
                                                                      
  fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;         
40010d54:	40 00 39 3b 	call  4001f240 <rtems_rfs_fs_media_size>       
40010d58:	90 07 bf 7c 	add  %fp, -132, %o0                            
40010d5c:	fa 07 bf 84 	ld  [ %fp + -124 ], %i5                        
40010d60:	94 10 20 00 	clr  %o2                                       
40010d64:	40 00 80 d9 	call  400310c8 <__udivdi3>                     
40010d68:	96 10 00 1d 	mov  %i5, %o3                                  
40010d6c:	d2 27 bf 80 	st  %o1, [ %fp + -128 ]                        
40010d70:	b8 10 00 09 	mov  %o1, %i4                                  
 * 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));  
40010d74:	b5 2f 60 03 	sll  %i5, 3, %i2                               
 * "quotient = dividend / divisor"                                    
 */                                                                   
int                                                                   
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)          
{                                                                     
  if (dividend == 0)                                                  
40010d78:	80 a2 60 00 	cmp  %o1, 0                                    
40010d7c:	02 80 00 06 	be  40010d94 <rtems_rfs_format+0x11c>          <== NEVER TAKEN
40010d80:	a0 10 20 01 	mov  1, %l0                                    
    return 1;                                                         
  return ((dividend - 1) / divisor) + 1;                              
40010d84:	90 02 7f ff 	add  %o1, -1, %o0                              
40010d88:	7f ff c6 46 	call  400026a0 <.udiv>                         
40010d8c:	92 10 00 1a 	mov  %i2, %o1                                  
40010d90:	a0 02 20 01 	add  %o0, 1, %l0                               
   * 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;                            
40010d94:	f6 06 60 08 	ld  [ %i1 + 8 ], %i3                           
  if (!fs->group_inodes)                                              
40010d98:	80 a6 e0 00 	cmp  %i3, 0                                    
40010d9c:	02 80 01 38 	be  4001127c <rtems_rfs_format+0x604>          <== ALWAYS TAKEN
40010da0:	e0 27 bf a0 	st  %l0, [ %fp + -96 ]                         
40010da4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40010da8:	7f ff c6 3e 	call  400026a0 <.udiv>                         <== NOT EXECUTED
40010dac:	92 10 20 38 	mov  0x38, %o1                                 <== NOT EXECUTED
40010db0:	b8 10 00 08 	mov  %o0, %i4                                  <== 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;
40010db4:	d0 27 bf ac 	st  %o0, [ %fp + -84 ]                         <== NOT EXECUTED
int                                                                   
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)          
{                                                                     
  if (dividend == 0)                                                  
    return 1;                                                         
  return ((dividend - 1) / divisor) + 1;                              
40010db8:	90 06 ff ff 	add  %i3, -1, %o0                              <== NOT EXECUTED
40010dbc:	7f ff c6 39 	call  400026a0 <.udiv>                         
40010dc0:	92 10 00 1c 	mov  %i4, %o1                                  
40010dc4:	90 02 20 01 	inc  %o0                                       
   * 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,                         
                            fs->inodes_per_block) * fs->inodes_per_block;
40010dc8:	7f ff c5 fc 	call  400025b8 <.umul>                         
40010dcc:	92 10 00 1c 	mov  %i4, %o1                                  
                                                                      
  if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
40010dd0:	80 a6 80 08 	cmp  %i2, %o0                                  
40010dd4:	0a 80 01 25 	bcs  40011268 <rtems_rfs_format+0x5f0>         <== NEVER TAKEN
40010dd8:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1                        
    fs->group_inodes = rtems_rfs_bitmap_numof_bits (fs->block_size);  
                                                                      
  fs->max_name_length = config->max_name_length;                      
  if (!fs->max_name_length)                                           
40010ddc:	80 a0 60 00 	cmp  %g1, 0                                    
40010de0:	12 80 01 25 	bne  40011274 <rtems_rfs_format+0x5fc>         <== NEVER TAKEN
40010de4:	d0 27 bf a8 	st  %o0, [ %fp + -88 ]                         
  {                                                                   
    fs->max_name_length = 512;                                        
40010de8:	82 10 22 00 	mov  0x200, %g1                                
40010dec:	c2 27 bf 98 	st  %g1, [ %fp + -104 ]                        
   * Check the configuration data.                                    
   */                                                                 
  if (!rtems_rfs_check_config (&fs, config))                          
    return -1;                                                        
                                                                      
  if (config->verbose)                                                
40010df0:	c2 0e 60 15 	ldub  [ %i1 + 0x15 ], %g1                      
40010df4:	80 a0 60 00 	cmp  %g1, 0                                    
40010df8:	12 80 00 c5 	bne  4001110c <rtems_rfs_format+0x494>         <== NEVER TAKEN
40010dfc:	01 00 00 00 	nop                                            
    printf ("rtems-rfs: format: groups = %u\n", fs.group_count);      
    printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
    printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
  }                                                                   
                                                                      
  rc = rtems_rfs_buffer_setblksize (&fs, rtems_rfs_fs_block_size (&fs));
40010e00:	92 10 00 1d 	mov  %i5, %o1                                  
40010e04:	40 00 2f 72 	call  4001cbcc <rtems_rfs_buffer_setblksize>   
40010e08:	90 07 bf 7c 	add  %fp, -132, %o0                            
  if (rc > 0)                                                         
40010e0c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40010e10:	14 80 02 33 	bg  400116dc <rtems_rfs_format+0xa64>          <== NEVER TAKEN
40010e14:	92 07 bf 30 	add  %fp, -208, %o1                            
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
40010e18:	c0 2f bf 30 	clrb  [ %fp + -208 ]                           
  handle->bnum  = 0;                                                  
40010e1c:	c0 27 bf 34 	clr  [ %fp + -204 ]                            
  handle->buffer = NULL;                                              
40010e20:	c0 27 bf 38 	clr  [ %fp + -200 ]                            
    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);       
40010e24:	90 07 bf 7c 	add  %fp, -132, %o0                            
40010e28:	94 10 20 00 	clr  %o2                                       
40010e2c:	40 00 2d fd 	call  4001c620 <rtems_rfs_buffer_handle_request>
40010e30:	96 10 20 00 	clr  %o3                                       
  if (rc > 0)                                                         
40010e34:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40010e38:	04 80 00 20 	ble  40010eb8 <rtems_rfs_format+0x240>         <== ALWAYS TAKEN
40010e3c:	92 07 bf 30 	add  %fp, -208, %o1                            
 */                                                                   
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);                       
40010e40:	40 00 2d 7e 	call  4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40010e44:	90 07 bf 7c 	add  %fp, -132, %o0                            <== NOT EXECUTED
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &handle);                      
    printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",  
40010e48:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
40010e4c:	c0 2f bf 30 	clrb  [ %fp + -208 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
40010e50:	c0 27 bf 34 	clr  [ %fp + -204 ]                            <== NOT EXECUTED
40010e54:	40 00 50 94 	call  400250a4 <strerror>                      <== NOT EXECUTED
40010e58:	c0 27 bf 38 	clr  [ %fp + -200 ]                            <== NOT EXECUTED
40010e5c:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
40010e60:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40010e64:	11 10 00 d5 	sethi  %hi(0x40035400), %o0                    <== NOT EXECUTED
40010e68:	40 00 4c 45 	call  40023f7c <printf>                        <== NOT EXECUTED
40010e6c:	90 12 21 f0 	or  %o0, 0x1f0, %o0	! 400355f0 <_CPU_Trap_slot_template+0x308><== NOT EXECUTED
    return -1;                                                        
  }                                                                   
                                                                      
  if (!rtems_rfs_write_superblock (&fs))                              
  {                                                                   
    printf ("rtems-rfs: format: superblock write failed\n");          
40010e70:	11 10 00 d6 	sethi  %hi(0x40035800), %o0                    <== NOT EXECUTED
    return -1;                                                        
40010e74:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
    return -1;                                                        
  }                                                                   
                                                                      
  if (!rtems_rfs_write_superblock (&fs))                              
  {                                                                   
    printf ("rtems-rfs: format: superblock write failed\n");          
40010e78:	40 00 4c d9 	call  400241dc <puts>                          <== NOT EXECUTED
40010e7c:	90 12 23 20 	or  %o0, 0x320, %o0                            <== NOT EXECUTED
40010e80:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40010e84:	81 e8 00 00 	restore                                        <== 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))
40010e88:	80 a0 40 1d 	cmp  %g1, %i5                                  <== NOT EXECUTED
40010e8c:	08 bf ff b2 	bleu  40010d54 <rtems_rfs_format+0xdc>         <== NOT EXECUTED
40010e90:	11 10 00 d4 	sethi  %hi(0x40035000), %o0                    <== NOT EXECUTED
  {                                                                   
    printf ("group block count is higher than bits in block\n");      
40010e94:	40 00 4c d2 	call  400241dc <puts>                          <== NOT EXECUTED
40010e98:	90 12 23 a8 	or  %o0, 0x3a8, %o0	! 400353a8 <_CPU_Trap_slot_template+0xc0><== NOT EXECUTED
  }                                                                   
                                                                      
  if (!rtems_rfs_write_superblock (&fs))                              
  {                                                                   
    printf ("rtems-rfs: format: superblock write failed\n");          
    return -1;                                                        
40010e9c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40010ea0:	91 e8 3f ff 	restore  %g0, -1, %o0                          <== NOT EXECUTED
  rtems_rfs_file_system fs;                                           
  int                   group;                                        
  int                   rc;                                           
                                                                      
  if (config->verbose)                                                
    printf ("rtems-rfs: format: %s\n", name);                         
40010ea4:	11 10 00 d4 	sethi  %hi(0x40035000), %o0                    <== NOT EXECUTED
40010ea8:	40 00 4c 35 	call  40023f7c <printf>                        <== NOT EXECUTED
40010eac:	90 12 22 f8 	or  %o0, 0x2f8, %o0	! 400352f8 <_CPU_Trap_slot_template+0x10><== NOT EXECUTED
                                                                      
  memset (&fs, 0, sizeof (rtems_rfs_file_system));                    
40010eb0:	10 bf ff 78 	b  40010c90 <rtems_rfs_format+0x18>            <== NOT EXECUTED
40010eb4:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
    printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",  
            rc, strerror (rc));                                       
    return false;                                                     
  }                                                                   
                                                                      
  sb = rtems_rfs_buffer_data (&handle);                               
40010eb8:	c2 07 bf 38 	ld  [ %fp + -200 ], %g1                        
                                                                      
#define write_sb(_o, _d) rtems_rfs_write_u32(sb + (_o), _d)           
                                                                      
  memset (sb, 0xff, rtems_rfs_fs_block_size (fs));                    
40010ebc:	d4 07 bf 84 	ld  [ %fp + -124 ], %o2                        
    printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",  
            rc, strerror (rc));                                       
    return false;                                                     
  }                                                                   
                                                                      
  sb = rtems_rfs_buffer_data (&handle);                               
40010ec0:	fa 00 60 1c 	ld  [ %g1 + 0x1c ], %i5                        
                                                                      
#define write_sb(_o, _d) rtems_rfs_write_u32(sb + (_o), _d)           
                                                                      
  memset (sb, 0xff, rtems_rfs_fs_block_size (fs));                    
40010ec4:	92 10 20 ff 	mov  0xff, %o1                                 
40010ec8:	40 00 4b af 	call  40023d84 <memset>                        
40010ecc:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);           
40010ed0:	82 10 20 28 	mov  0x28, %g1                                 
40010ed4:	c2 2f 40 00 	stb  %g1, [ %i5 ]                              
40010ed8:	82 10 20 09 	mov  9, %g1                                    
  write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);          
40010edc:	c0 2f 60 04 	clrb  [ %i5 + 4 ]                              
                                                                      
#define write_sb(_o, _d) rtems_rfs_write_u32(sb + (_o), _d)           
                                                                      
  memset (sb, 0xff, rtems_rfs_fs_block_size (fs));                    
                                                                      
  write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);           
40010ee0:	c2 2f 60 01 	stb  %g1, [ %i5 + 1 ]                          
  write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);          
40010ee4:	c0 2f 60 05 	clrb  [ %i5 + 5 ]                              
40010ee8:	c0 2f 60 06 	clrb  [ %i5 + 6 ]                              
40010eec:	c0 2f 60 07 	clrb  [ %i5 + 7 ]                              
                                                                      
#define write_sb(_o, _d) rtems_rfs_write_u32(sb + (_o), _d)           
                                                                      
  memset (sb, 0xff, rtems_rfs_fs_block_size (fs));                    
                                                                      
  write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);           
40010ef0:	84 10 20 01 	mov  1, %g2                                    
40010ef4:	82 10 20 20 	mov  0x20, %g1                                 
40010ef8:	c4 2f 60 03 	stb  %g2, [ %i5 + 3 ]                          
40010efc:	c2 2f 60 02 	stb  %g1, [ %i5 + 2 ]                          
  write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);          
  write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));    
  write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
40010f00:	c6 0f bf 84 	ldub  [ %fp + -124 ], %g3                      
                                                                      
  memset (sb, 0xff, rtems_rfs_fs_block_size (fs));                    
                                                                      
  write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);           
  write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);          
  write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));    
40010f04:	c2 07 bf 80 	ld  [ %fp + -128 ], %g1                        
  write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
40010f08:	c6 2f 60 08 	stb  %g3, [ %i5 + 8 ]                          
40010f0c:	c6 17 bf 84 	lduh  [ %fp + -124 ], %g3                      
                                                                      
  memset (sb, 0xff, rtems_rfs_fs_block_size (fs));                    
                                                                      
  write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);           
  write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);          
  write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));    
40010f10:	c2 2f 60 0f 	stb  %g1, [ %i5 + 0xf ]                        
  write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
40010f14:	c6 2f 60 09 	stb  %g3, [ %i5 + 9 ]                          
40010f18:	c8 07 bf 84 	ld  [ %fp + -124 ], %g4                        
                                                                      
  memset (sb, 0xff, rtems_rfs_fs_block_size (fs));                    
                                                                      
  write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);           
  write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);          
  write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));    
40010f1c:	87 30 60 18 	srl  %g1, 0x18, %g3                            
  write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
40010f20:	89 31 20 08 	srl  %g4, 8, %g4                               
                                                                      
  memset (sb, 0xff, rtems_rfs_fs_block_size (fs));                    
                                                                      
  write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);           
  write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);          
  write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));    
40010f24:	c6 2f 60 0c 	stb  %g3, [ %i5 + 0xc ]                        
  write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
40010f28:	c8 2f 60 0a 	stb  %g4, [ %i5 + 0xa ]                        
40010f2c:	c6 07 bf 84 	ld  [ %fp + -124 ], %g3                        
  write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);      
  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);                 
40010f30:	90 07 bf 7c 	add  %fp, -132, %o0                            
  memset (sb, 0xff, rtems_rfs_fs_block_size (fs));                    
                                                                      
  write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);           
  write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);          
  write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));    
  write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
40010f34:	c6 2f 60 0b 	stb  %g3, [ %i5 + 0xb ]                        
                                                                      
  memset (sb, 0xff, rtems_rfs_fs_block_size (fs));                    
                                                                      
  write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);           
  write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);          
  write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));    
40010f38:	87 30 60 10 	srl  %g1, 0x10, %g3                            
40010f3c:	83 30 60 08 	srl  %g1, 8, %g1                               
40010f40:	c6 2f 60 0d 	stb  %g3, [ %i5 + 0xd ]                        
40010f44:	c2 2f 60 0e 	stb  %g1, [ %i5 + 0xe ]                        
  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);          
40010f48:	c2 0f bf 94 	ldub  [ %fp + -108 ], %g1                      
  write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);      
  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);                 
40010f4c:	92 07 bf 30 	add  %fp, -208, %o1                            
                                                                      
  write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);           
  write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);          
  write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));    
  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);          
40010f50:	c2 2f 60 10 	stb  %g1, [ %i5 + 0x10 ]                       
40010f54:	c2 17 bf 94 	lduh  [ %fp + -108 ], %g1                      
40010f58:	c2 2f 60 11 	stb  %g1, [ %i5 + 0x11 ]                       
40010f5c:	c2 07 bf 94 	ld  [ %fp + -108 ], %g1                        
40010f60:	83 30 60 08 	srl  %g1, 8, %g1                               
40010f64:	c2 2f 60 12 	stb  %g1, [ %i5 + 0x12 ]                       
40010f68:	c2 07 bf 94 	ld  [ %fp + -108 ], %g1                        
40010f6c:	c2 2f 60 13 	stb  %g1, [ %i5 + 0x13 ]                       
  write_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH, fs->max_name_length);
40010f70:	c2 0f bf 98 	ldub  [ %fp + -104 ], %g1                      
40010f74:	c2 2f 60 14 	stb  %g1, [ %i5 + 0x14 ]                       
40010f78:	c2 17 bf 98 	lduh  [ %fp + -104 ], %g1                      
40010f7c:	c2 2f 60 15 	stb  %g1, [ %i5 + 0x15 ]                       
40010f80:	c2 07 bf 98 	ld  [ %fp + -104 ], %g1                        
40010f84:	83 30 60 08 	srl  %g1, 8, %g1                               
40010f88:	c2 2f 60 16 	stb  %g1, [ %i5 + 0x16 ]                       
40010f8c:	c2 07 bf 98 	ld  [ %fp + -104 ], %g1                        
40010f90:	c2 2f 60 17 	stb  %g1, [ %i5 + 0x17 ]                       
  write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count);             
40010f94:	c2 0f bf a0 	ldub  [ %fp + -96 ], %g1                       
40010f98:	c2 2f 60 18 	stb  %g1, [ %i5 + 0x18 ]                       
40010f9c:	c2 17 bf a0 	lduh  [ %fp + -96 ], %g1                       
40010fa0:	c2 2f 60 19 	stb  %g1, [ %i5 + 0x19 ]                       
40010fa4:	c2 07 bf a0 	ld  [ %fp + -96 ], %g1                         
40010fa8:	83 30 60 08 	srl  %g1, 8, %g1                               
40010fac:	c2 2f 60 1a 	stb  %g1, [ %i5 + 0x1a ]                       
40010fb0:	c2 07 bf a0 	ld  [ %fp + -96 ], %g1                         
40010fb4:	c2 2f 60 1b 	stb  %g1, [ %i5 + 0x1b ]                       
  write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks);      
40010fb8:	c2 0f bf a4 	ldub  [ %fp + -92 ], %g1                       
40010fbc:	c2 2f 60 1c 	stb  %g1, [ %i5 + 0x1c ]                       
40010fc0:	c2 17 bf a4 	lduh  [ %fp + -92 ], %g1                       
40010fc4:	c2 2f 60 1d 	stb  %g1, [ %i5 + 0x1d ]                       
40010fc8:	c2 07 bf a4 	ld  [ %fp + -92 ], %g1                         
40010fcc:	83 30 60 08 	srl  %g1, 8, %g1                               
40010fd0:	c2 2f 60 1e 	stb  %g1, [ %i5 + 0x1e ]                       
40010fd4:	c2 07 bf a4 	ld  [ %fp + -92 ], %g1                         
40010fd8:	c2 2f 60 1f 	stb  %g1, [ %i5 + 0x1f ]                       
  write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);      
40010fdc:	c2 0f bf a8 	ldub  [ %fp + -88 ], %g1                       
40010fe0:	c2 2f 60 20 	stb  %g1, [ %i5 + 0x20 ]                       
40010fe4:	c2 17 bf a8 	lduh  [ %fp + -88 ], %g1                       
40010fe8:	c2 2f 60 21 	stb  %g1, [ %i5 + 0x21 ]                       
40010fec:	c2 07 bf a8 	ld  [ %fp + -88 ], %g1                         
40010ff0:	83 30 60 08 	srl  %g1, 8, %g1                               
40010ff4:	c2 2f 60 22 	stb  %g1, [ %i5 + 0x22 ]                       
40010ff8:	c2 07 bf a8 	ld  [ %fp + -88 ], %g1                         
  write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);    
40010ffc:	c0 2f 60 24 	clrb  [ %i5 + 0x24 ]                           
  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);      
40011000:	c2 2f 60 23 	stb  %g1, [ %i5 + 0x23 ]                       
  write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);    
40011004:	c0 2f 60 25 	clrb  [ %i5 + 0x25 ]                           
40011008:	c0 2f 60 26 	clrb  [ %i5 + 0x26 ]                           
4001100c:	82 10 20 38 	mov  0x38, %g1                                 
40011010:	c2 2f 60 27 	stb  %g1, [ %i5 + 0x27 ]                       
                                                                      
  rtems_rfs_buffer_mark_dirty (&handle);                              
                                                                      
  rc = rtems_rfs_buffer_handle_release (fs, &handle);                 
40011014:	40 00 2d 09 	call  4001c438 <rtems_rfs_buffer_handle_release>
40011018:	c4 2f bf 30 	stb  %g2, [ %fp + -208 ]                       
  if (rc > 0)                                                         
4001101c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40011020:	04 80 00 e3 	ble  400113ac <rtems_rfs_format+0x734>         <== ALWAYS TAKEN
40011024:	92 07 bf 30 	add  %fp, -208, %o1                            
 */                                                                   
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);                       
40011028:	40 00 2d 04 	call  4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001102c:	90 07 bf 7c 	add  %fp, -132, %o0                            <== NOT EXECUTED
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &handle);                      
    printf ("rtems-rfs: write-superblock: buffer release failed: %d: %s\n",
40011030:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
40011034:	c0 2f bf 30 	clrb  [ %fp + -208 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
40011038:	c0 27 bf 34 	clr  [ %fp + -204 ]                            <== NOT EXECUTED
4001103c:	40 00 50 1a 	call  400250a4 <strerror>                      <== NOT EXECUTED
40011040:	c0 27 bf 38 	clr  [ %fp + -200 ]                            <== NOT EXECUTED
40011044:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
40011048:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
4001104c:	11 10 00 d5 	sethi  %hi(0x40035400), %o0                    <== NOT EXECUTED
40011050:	40 00 4b cb 	call  40023f7c <printf>                        <== NOT EXECUTED
40011054:	90 12 22 28 	or  %o0, 0x228, %o0	! 40035628 <_CPU_Trap_slot_template+0x340><== NOT EXECUTED
    return -1;                                                        
  }                                                                   
                                                                      
  if (!rtems_rfs_write_superblock (&fs))                              
  {                                                                   
    printf ("rtems-rfs: format: superblock write failed\n");          
40011058:	10 bf ff 87 	b  40010e74 <rtems_rfs_format+0x1fc>           <== NOT EXECUTED
4001105c:	11 10 00 d6 	sethi  %hi(0x40035800), %o0                    <== NOT EXECUTED
                        const rtems_rfs_format_config* config)        
{                                                                     
  fs->block_size = config->block_size;                                
  if (!fs->block_size)                                                
  {                                                                   
    uint64_t total_size = rtems_rfs_fs_media_size (fs);               
40011060:	40 00 38 78 	call  4001f240 <rtems_rfs_fs_media_size>       
40011064:	90 07 bf 7c 	add  %fp, -132, %o0                            
                                                                      
    if (total_size >= GIGS (1))                                       
40011068:	80 a2 20 00 	cmp  %o0, 0                                    
4001106c:	22 80 00 9f 	be,a   400112e8 <rtems_rfs_format+0x670>       <== ALWAYS TAKEN
40011070:	03 00 03 ff 	sethi  %hi(0xffc00), %g1                       
    {                                                                 
      uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);             
40011074:	b4 10 20 00 	clr  %i2                                       <== NOT EXECUTED
40011078:	37 00 04 00 	sethi  %hi(0x100000), %i3                      <== NOT EXECUTED
      int      b;                                                     
      for (b = 31; b > 0; b--)                                        
4001107c:	82 10 20 1f 	mov  0x1f, %g1                                 <== NOT EXECUTED
  {                                                                   
    uint64_t total_size = rtems_rfs_fs_media_size (fs);               
                                                                      
    if (total_size >= GIGS (1))                                       
    {                                                                 
      uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);             
40011080:	ba 82 40 1b 	addcc  %o1, %i3, %i5                           <== NOT EXECUTED
      int      b;                                                     
      for (b = 31; b > 0; b--)                                        
        if ((gigs & (1 << b)) != 0)                                   
40011084:	86 10 20 01 	mov  1, %g3                                    <== NOT EXECUTED
  {                                                                   
    uint64_t total_size = rtems_rfs_fs_media_size (fs);               
                                                                      
    if (total_size >= GIGS (1))                                       
    {                                                                 
      uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);             
40011088:	b8 42 00 1a 	addx  %o0, %i2, %i4                            <== NOT EXECUTED
4001108c:	85 37 60 14 	srl  %i5, 0x14, %g2                            <== NOT EXECUTED
40011090:	89 2f 20 0c 	sll  %i4, 0xc, %g4                             <== NOT EXECUTED
40011094:	10 80 00 04 	b  400110a4 <rtems_rfs_format+0x42c>           <== NOT EXECUTED
40011098:	84 11 00 02 	or  %g4, %g2, %g2                              <== NOT EXECUTED
      int      b;                                                     
      for (b = 31; b > 0; b--)                                        
4001109c:	02 80 00 06 	be  400110b4 <rtems_rfs_format+0x43c>          <== NOT EXECUTED
400110a0:	ba 10 20 01 	mov  1, %i5                                    <== NOT EXECUTED
        if ((gigs & (1 << b)) != 0)                                   
400110a4:	bb 28 c0 01 	sll  %g3, %g1, %i5                             <== NOT EXECUTED
400110a8:	80 8f 40 02 	btst  %i5, %g2                                 <== NOT EXECUTED
400110ac:	02 bf ff fc 	be  4001109c <rtems_rfs_format+0x424>          <== NOT EXECUTED
400110b0:	82 80 7f ff 	addcc  %g1, -1, %g1                            <== NOT EXECUTED
          break;                                                      
      fs->block_size = 1 << b;                                        
    }                                                                 
                                                                      
    if (fs->block_size < 512)                                         
400110b4:	80 a7 61 ff 	cmp  %i5, 0x1ff                                <== NOT EXECUTED
400110b8:	18 80 00 94 	bgu  40011308 <rtems_rfs_format+0x690>         <== NOT EXECUTED
400110bc:	fa 27 bf 84 	st  %i5, [ %fp + -124 ]                        <== NOT EXECUTED
400110c0:	c2 07 bf 8c 	ld  [ %fp + -116 ], %g1                        <== NOT EXECUTED
      fs->block_size = 512;                                           
400110c4:	ba 10 22 00 	mov  0x200, %i5                                
400110c8:	f8 00 60 20 	ld  [ %g1 + 0x20 ], %i4                        
400110cc:	82 10 22 00 	mov  0x200, %g1                                
                                                                      
    if (fs->block_size > (4 * 1024))                                  
      fs->block_size = (4 * 1024);                                    
  }                                                                   
                                                                      
  if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)     
400110d0:	90 10 00 1d 	mov  %i5, %o0                                  
          break;                                                      
      fs->block_size = 1 << b;                                        
    }                                                                 
                                                                      
    if (fs->block_size < 512)                                         
      fs->block_size = 512;                                           
400110d4:	c2 27 bf 84 	st  %g1, [ %fp + -124 ]                        
                                                                      
    if (fs->block_size > (4 * 1024))                                  
      fs->block_size = (4 * 1024);                                    
  }                                                                   
                                                                      
  if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)     
400110d8:	40 00 7d 3f 	call  400305d4 <.urem>                         
400110dc:	92 10 00 1c 	mov  %i4, %o1                                  
400110e0:	80 a2 20 00 	cmp  %o0, 0                                    
400110e4:	22 bf ff 17 	be,a   40010d40 <rtems_rfs_format+0xc8>        <== ALWAYS TAKEN
400110e8:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
  {                                                                   
    printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
400110ec:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
400110f0:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
400110f4:	11 10 00 d4 	sethi  %hi(0x40035000), %o0                    <== NOT EXECUTED
  }                                                                   
                                                                      
  if (!rtems_rfs_write_superblock (&fs))                              
  {                                                                   
    printf ("rtems-rfs: format: superblock write failed\n");          
    return -1;                                                        
400110f8:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
      fs->block_size = (4 * 1024);                                    
  }                                                                   
                                                                      
  if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)     
  {                                                                   
    printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
400110fc:	40 00 4b a0 	call  40023f7c <printf>                        <== NOT EXECUTED
40011100:	90 12 23 68 	or  %o0, 0x368, %o0                            <== NOT EXECUTED
40011104:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40011108:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  if (!rtems_rfs_check_config (&fs, config))                          
    return -1;                                                        
                                                                      
  if (config->verbose)                                                
  {                                                                   
    printf ("rtems-rfs: format: media size = %" PRIu64 "\n",          
4001110c:	40 00 38 4d 	call  4001f240 <rtems_rfs_fs_media_size>       <== NOT EXECUTED
40011110:	90 07 bf 7c 	add  %fp, -132, %o0                            <== NOT EXECUTED
40011114:	94 10 00 09 	mov  %o1, %o2                                  <== NOT EXECUTED
40011118:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
4001111c:	11 10 00 d4 	sethi  %hi(0x40035000), %o0                    <== NOT EXECUTED
40011120:	40 00 4b 97 	call  40023f7c <printf>                        <== NOT EXECUTED
40011124:	90 12 23 d8 	or  %o0, 0x3d8, %o0	! 400353d8 <_CPU_Trap_slot_template+0xf0><== NOT EXECUTED
            rtems_rfs_fs_media_size (&fs));                           
    printf ("rtems-rfs: format: media blocks = %" PRIu32 "\n",        
            rtems_rfs_fs_media_blocks (&fs));                         
40011128:	c2 07 bf 8c 	ld  [ %fp + -116 ], %g1                        <== NOT EXECUTED
                                                                      
  if (config->verbose)                                                
  {                                                                   
    printf ("rtems-rfs: format: media size = %" PRIu64 "\n",          
            rtems_rfs_fs_media_size (&fs));                           
    printf ("rtems-rfs: format: media blocks = %" PRIu32 "\n",        
4001112c:	11 10 00 d5 	sethi  %hi(0x40035400), %o0                    <== NOT EXECUTED
40011130:	d2 00 60 1c 	ld  [ %g1 + 0x1c ], %o1                        <== NOT EXECUTED
40011134:	40 00 4b 92 	call  40023f7c <printf>                        <== NOT EXECUTED
40011138:	90 12 20 00 	mov  %o0, %o0                                  <== NOT EXECUTED
            rtems_rfs_fs_media_blocks (&fs));                         
    printf ("rtems-rfs: format: media block size = %" PRIu32 "\n",    
            rtems_rfs_fs_media_block_size (&fs));                     
4001113c:	c2 07 bf 8c 	ld  [ %fp + -116 ], %g1                        <== NOT EXECUTED
  {                                                                   
    printf ("rtems-rfs: format: media size = %" PRIu64 "\n",          
            rtems_rfs_fs_media_size (&fs));                           
    printf ("rtems-rfs: format: media blocks = %" PRIu32 "\n",        
            rtems_rfs_fs_media_blocks (&fs));                         
    printf ("rtems-rfs: format: media block size = %" PRIu32 "\n",    
40011140:	11 10 00 d5 	sethi  %hi(0x40035400), %o0                    <== NOT EXECUTED
40011144:	d2 00 60 20 	ld  [ %g1 + 0x20 ], %o1                        <== NOT EXECUTED
40011148:	40 00 4b 8d 	call  40023f7c <printf>                        <== NOT EXECUTED
4001114c:	90 12 20 28 	or  %o0, 0x28, %o0                             <== NOT EXECUTED
            rtems_rfs_fs_media_block_size (&fs));                     
    printf ("rtems-rfs: format: size = %" PRIu64 "\n",                
40011150:	40 00 38 33 	call  4001f21c <rtems_rfs_fs_size>             <== NOT EXECUTED
40011154:	90 07 bf 7c 	add  %fp, -132, %o0                            <== NOT EXECUTED
40011158:	94 10 00 09 	mov  %o1, %o2                                  <== NOT EXECUTED
4001115c:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40011160:	11 10 00 d5 	sethi  %hi(0x40035400), %o0                    <== NOT EXECUTED
40011164:	40 00 4b 86 	call  40023f7c <printf>                        <== NOT EXECUTED
40011168:	90 12 20 58 	or  %o0, 0x58, %o0	! 40035458 <_CPU_Trap_slot_template+0x170><== NOT EXECUTED
            rtems_rfs_fs_size (&fs));                                 
    printf ("rtems-rfs: format: blocks = %zu\n",                      
4001116c:	d2 07 bf 80 	ld  [ %fp + -128 ], %o1                        <== NOT EXECUTED
40011170:	11 10 00 d5 	sethi  %hi(0x40035400), %o0                    <== NOT EXECUTED
40011174:	40 00 4b 82 	call  40023f7c <printf>                        <== NOT EXECUTED
40011178:	90 12 20 78 	or  %o0, 0x78, %o0	! 40035478 <_CPU_Trap_slot_template+0x190><== NOT EXECUTED
            rtems_rfs_fs_blocks (&fs));                               
    printf ("rtems-rfs: format: block size = %zu\n",                  
4001117c:	d2 07 bf 84 	ld  [ %fp + -124 ], %o1                        <== NOT EXECUTED
40011180:	11 10 00 d5 	sethi  %hi(0x40035400), %o0                    <== NOT EXECUTED
40011184:	40 00 4b 7e 	call  40023f7c <printf>                        <== NOT EXECUTED
40011188:	90 12 20 a0 	or  %o0, 0xa0, %o0	! 400354a0 <_CPU_Trap_slot_template+0x1b8><== 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));  
4001118c:	d2 07 bf 84 	ld  [ %fp + -124 ], %o1                        <== NOT EXECUTED
            rtems_rfs_fs_size (&fs));                                 
    printf ("rtems-rfs: format: blocks = %zu\n",                      
            rtems_rfs_fs_blocks (&fs));                               
    printf ("rtems-rfs: format: block size = %zu\n",                  
            rtems_rfs_fs_block_size (&fs));                           
    printf ("rtems-rfs: format: bits per block = %u\n",               
40011190:	11 10 00 d5 	sethi  %hi(0x40035400), %o0                    <== NOT EXECUTED
40011194:	93 2a 60 03 	sll  %o1, 3, %o1                               <== NOT EXECUTED
40011198:	40 00 4b 79 	call  40023f7c <printf>                        <== NOT EXECUTED
4001119c:	90 12 20 c8 	or  %o0, 0xc8, %o0                             <== NOT EXECUTED
            rtems_rfs_bits_per_block (&fs));                          
    printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
400111a0:	92 10 20 38 	mov  0x38, %o1                                 <== NOT EXECUTED
400111a4:	11 10 00 d5 	sethi  %hi(0x40035400), %o0                    <== NOT EXECUTED
400111a8:	40 00 4b 75 	call  40023f7c <printf>                        <== NOT EXECUTED
400111ac:	90 12 20 f0 	or  %o0, 0xf0, %o0	! 400354f0 <_CPU_Trap_slot_template+0x208><== NOT EXECUTED
    printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",            
400111b0:	d2 07 bf a0 	ld  [ %fp + -96 ], %o1                         <== NOT EXECUTED
            fs.group_inodes * fs.group_count,                         
400111b4:	fa 07 bf a8 	ld  [ %fp + -88 ], %i5                         <== NOT EXECUTED
    printf ("rtems-rfs: format: block size = %zu\n",                  
            rtems_rfs_fs_block_size (&fs));                           
    printf ("rtems-rfs: format: bits per block = %u\n",               
            rtems_rfs_bits_per_block (&fs));                          
    printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
    printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",            
400111b8:	7f ff c5 00 	call  400025b8 <.umul>                         <== NOT EXECUTED
400111bc:	90 10 00 1d 	mov  %i5, %o0                                  <== 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,
400111c0:	83 2f 60 03 	sll  %i5, 3, %g1                               <== NOT EXECUTED
    printf ("rtems-rfs: format: block size = %zu\n",                  
            rtems_rfs_fs_block_size (&fs));                           
    printf ("rtems-rfs: format: bits per block = %u\n",               
            rtems_rfs_bits_per_block (&fs));                          
    printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
    printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",            
400111c4:	b6 10 00 08 	mov  %o0, %i3                                  <== 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,
400111c8:	bb 2f 60 06 	sll  %i5, 6, %i5                               <== NOT EXECUTED
                                  rtems_rfs_fs_block_size (fs));      
400111cc:	f8 07 bf 84 	ld  [ %fp + -124 ], %i4                        <== NOT EXECUTED
 * "quotient = dividend / divisor"                                    
 */                                                                   
int                                                                   
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)          
{                                                                     
  if (dividend == 0)                                                  
400111d0:	ba a7 40 01 	subcc  %i5, %g1, %i5                           <== NOT EXECUTED
400111d4:	12 80 00 55 	bne  40011328 <rtems_rfs_format+0x6b0>         <== NOT EXECUTED
400111d8:	90 10 27 d0 	mov  0x7d0, %o0                                <== 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))
400111dc:	c2 07 bf 80 	ld  [ %fp + -128 ], %g1                        <== 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));  
400111e0:	b9 2f 20 03 	sll  %i4, 3, %i4                               <== 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))
400111e4:	92 00 7f ff 	add  %g1, -1, %o1                              <== NOT EXECUTED
400111e8:	80 a7 00 09 	cmp  %i4, %o1                                  <== NOT EXECUTED
400111ec:	28 80 00 02 	bleu,a   400111f4 <rtems_rfs_format+0x57c>     <== NOT EXECUTED
400111f0:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
    bits_per_block = rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE;
  return ((blocks + 1) * 100 * 10) / bits_per_block;                  
400111f4:	7f ff c5 2d 	call  400026a8 <.div>                          <== NOT EXECUTED
400111f8:	01 00 00 00 	nop                                            <== NOT EXECUTED
    printf ("rtems-rfs: format: block size = %zu\n",                  
            rtems_rfs_fs_block_size (&fs));                           
    printf ("rtems-rfs: format: bits per block = %u\n",               
            rtems_rfs_bits_per_block (&fs));                          
    printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
    printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",            
400111fc:	92 10 20 0a 	mov  0xa, %o1	! a <PROM_START+0xa>             <== NOT EXECUTED
40011200:	7f ff c5 2a 	call  400026a8 <.div>                          <== NOT EXECUTED
40011204:	b8 10 00 08 	mov  %o0, %i4                                  <== NOT EXECUTED
40011208:	92 10 20 0a 	mov  0xa, %o1                                  <== NOT EXECUTED
4001120c:	ba 10 00 08 	mov  %o0, %i5                                  <== NOT EXECUTED
40011210:	40 00 7c f3 	call  400305dc <.rem>                          <== NOT EXECUTED
40011214:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
40011218:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
4001121c:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
40011220:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
40011224:	11 10 00 d5 	sethi  %hi(0x40035400), %o0                    <== NOT EXECUTED
40011228:	40 00 4b 55 	call  40023f7c <printf>                        <== NOT EXECUTED
4001122c:	90 12 21 18 	or  %o0, 0x118, %o0	! 40035518 <_CPU_Trap_slot_template+0x230><== 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);      
40011230:	d2 07 bf a0 	ld  [ %fp + -96 ], %o1                         <== NOT EXECUTED
40011234:	11 10 00 d5 	sethi  %hi(0x40035400), %o0                    <== NOT EXECUTED
40011238:	40 00 4b 51 	call  40023f7c <printf>                        <== NOT EXECUTED
4001123c:	90 12 21 48 	or  %o0, 0x148, %o0	! 40035548 <_CPU_Trap_slot_template+0x260><== NOT EXECUTED
    printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
40011240:	d2 07 bf a4 	ld  [ %fp + -92 ], %o1                         <== NOT EXECUTED
40011244:	11 10 00 d5 	sethi  %hi(0x40035400), %o0                    <== NOT EXECUTED
40011248:	40 00 4b 4d 	call  40023f7c <printf>                        <== NOT EXECUTED
4001124c:	90 12 21 68 	or  %o0, 0x168, %o0	! 40035568 <_CPU_Trap_slot_template+0x280><== NOT EXECUTED
    printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
40011250:	d2 07 bf a8 	ld  [ %fp + -88 ], %o1                         <== NOT EXECUTED
40011254:	11 10 00 d5 	sethi  %hi(0x40035400), %o0                    <== NOT EXECUTED
40011258:	40 00 4b 49 	call  40023f7c <printf>                        <== NOT EXECUTED
4001125c:	90 12 21 90 	or  %o0, 0x190, %o0	! 40035590 <_CPU_Trap_slot_template+0x2a8><== NOT EXECUTED
40011260:	10 bf fe e8 	b  40010e00 <rtems_rfs_format+0x188>           <== NOT EXECUTED
40011264:	fa 07 bf 84 	ld  [ %fp + -124 ], %i5                        <== NOT EXECUTED
                                                                      
  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;                      
  if (!fs->max_name_length)                                           
40011268:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4001126c:	02 bf fe df 	be  40010de8 <rtems_rfs_format+0x170>          <== NOT EXECUTED
40011270:	f4 27 bf a8 	st  %i2, [ %fp + -88 ]                         <== 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;                      
40011274:	10 bf fe df 	b  40010df0 <rtems_rfs_format+0x178>           <== NOT EXECUTED
40011278:	c2 27 bf 98 	st  %g1, [ %fp + -104 ]                        <== 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)                                       
4001127c:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
40011280:	80 a0 60 00 	cmp  %g1, 0                                    
40011284:	02 80 00 03 	be  40011290 <rtems_rfs_format+0x618>          <== ALWAYS TAKEN
40011288:	90 10 20 01 	mov  1, %o0                                    
4001128c:	90 10 00 01 	mov  %g1, %o0                                  <== NOT EXECUTED
rtems_rfs_inodes_from_percent (rtems_rfs_file_system* fs,             
                               int                    percentage)     
{                                                                     
  int blocks;                                                         
  blocks = ((rtems_rfs_fs_blocks (fs) -                               
             RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;          
40011290:	7f ff c4 ca 	call  400025b8 <.umul>                         
40011294:	92 07 3f ff 	add  %i4, -1, %o1                              
40011298:	92 10 20 64 	mov  0x64, %o1                                 
4001129c:	7f ff c5 01 	call  400026a0 <.udiv>                         
400112a0:	b6 10 20 01 	mov  1, %i3                                    
 * "quotient = dividend / divisor"                                    
 */                                                                   
int                                                                   
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)          
{                                                                     
  if (dividend == 0)                                                  
400112a4:	80 a2 20 00 	cmp  %o0, 0                                    
400112a8:	32 80 00 30 	bne,a   40011368 <rtems_rfs_format+0x6f0>      
400112ac:	92 10 00 10 	mov  %l0, %o1                                  
{                                                                     
  int blocks;                                                         
  blocks = ((rtems_rfs_fs_blocks (fs) -                               
             RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;          
  blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);          
  return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
400112b0:	92 10 20 38 	mov  0x38, %o1                                 
400112b4:	7f ff c4 fb 	call  400026a0 <.udiv>                         
400112b8:	90 10 00 1d 	mov  %i5, %o0                                  
400112bc:	b8 10 00 08 	mov  %o0, %i4                                  
400112c0:	90 10 00 1b 	mov  %i3, %o0                                  
400112c4:	7f ff c4 bd 	call  400025b8 <.umul>                         
400112c8:	92 10 00 1c 	mov  %i4, %o1                                  
  }                                                                   
                                                                      
  /*                                                                  
   * 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;
400112cc:	f8 27 bf ac 	st  %i4, [ %fp + -84 ]                         
{                                                                     
  int blocks;                                                         
  blocks = ((rtems_rfs_fs_blocks (fs) -                               
             RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;          
  blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);          
  return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
400112d0:	b6 10 00 08 	mov  %o0, %i3                                  
 * "quotient = dividend / divisor"                                    
 */                                                                   
int                                                                   
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)          
{                                                                     
  if (dividend == 0)                                                  
400112d4:	80 a6 e0 00 	cmp  %i3, 0                                    
400112d8:	02 bf fe bc 	be  40010dc8 <rtems_rfs_format+0x150>          <== NEVER TAKEN
400112dc:	90 10 20 01 	mov  1, %o0                                    
    return 1;                                                         
  return ((dividend - 1) / divisor) + 1;                              
400112e0:	10 bf fe b7 	b  40010dbc <rtems_rfs_format+0x144>           
400112e4:	90 06 ff ff 	add  %i3, -1, %o0                              
  fs->block_size = config->block_size;                                
  if (!fs->block_size)                                                
  {                                                                   
    uint64_t total_size = rtems_rfs_fs_media_size (fs);               
                                                                      
    if (total_size >= GIGS (1))                                       
400112e8:	82 10 63 ff 	or  %g1, 0x3ff, %g1                            
400112ec:	80 a2 40 01 	cmp  %o1, %g1                                  
400112f0:	18 bf ff 62 	bgu  40011078 <rtems_rfs_format+0x400>         <== NEVER TAKEN
400112f4:	b4 10 20 00 	clr  %i2                                       
400112f8:	fa 07 bf 84 	ld  [ %fp + -124 ], %i5                        
        if ((gigs & (1 << b)) != 0)                                   
          break;                                                      
      fs->block_size = 1 << b;                                        
    }                                                                 
                                                                      
    if (fs->block_size < 512)                                         
400112fc:	80 a7 61 ff 	cmp  %i5, 0x1ff                                
40011300:	08 bf ff 71 	bleu  400110c4 <rtems_rfs_format+0x44c>        <== ALWAYS TAKEN
40011304:	c2 07 bf 8c 	ld  [ %fp + -116 ], %g1                        
      fs->block_size = 512;                                           
                                                                      
    if (fs->block_size > (4 * 1024))                                  
40011308:	03 00 00 04 	sethi  %hi(0x1000), %g1                        <== NOT EXECUTED
4001130c:	80 a7 40 01 	cmp  %i5, %g1                                  <== NOT EXECUTED
40011310:	08 80 02 06 	bleu  40011b28 <rtems_rfs_format+0xeb0>        <== NOT EXECUTED
40011314:	c4 07 bf 8c 	ld  [ %fp + -116 ], %g2                        <== NOT EXECUTED
      fs->block_size = (4 * 1024);                                    
40011318:	c2 27 bf 84 	st  %g1, [ %fp + -124 ]                        <== NOT EXECUTED
4001131c:	f8 00 a0 20 	ld  [ %g2 + 0x20 ], %i4                        <== NOT EXECUTED
40011320:	10 bf fe 81 	b  40010d24 <rtems_rfs_format+0xac>            <== NOT EXECUTED
40011324:	ba 10 00 01 	mov  %g1, %i5                                  <== NOT EXECUTED
int                                                                   
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)          
{                                                                     
  if (dividend == 0)                                                  
    return 1;                                                         
  return ((dividend - 1) / divisor) + 1;                              
40011328:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
4001132c:	7f ff c4 dd 	call  400026a0 <.udiv>                         <== NOT EXECUTED
40011330:	90 07 7f ff 	add  %i5, -1, %o0                              <== NOT EXECUTED
40011334:	90 02 20 02 	add  %o0, 2, %o0                               <== NOT EXECUTED
40011338:	83 2a 20 02 	sll  %o0, 2, %g1                               <== NOT EXECUTED
4001133c:	85 2a 20 07 	sll  %o0, 7, %g2                               <== NOT EXECUTED
40011340:	84 20 80 01 	sub  %g2, %g1, %g2                             <== 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))
40011344:	c2 07 bf 80 	ld  [ %fp + -128 ], %g1                        <== NOT EXECUTED
40011348:	84 00 80 08 	add  %g2, %o0, %g2                             <== 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));  
4001134c:	b9 2f 20 03 	sll  %i4, 3, %i4                               <== 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))
40011350:	92 00 7f ff 	add  %g1, -1, %o1                              <== NOT EXECUTED
40011354:	80 a7 00 09 	cmp  %i4, %o1                                  <== NOT EXECUTED
40011358:	18 bf ff a7 	bgu  400111f4 <rtems_rfs_format+0x57c>         <== NOT EXECUTED
4001135c:	91 28 a0 03 	sll  %g2, 3, %o0                               <== 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));  
40011360:	10 bf ff a5 	b  400111f4 <rtems_rfs_format+0x57c>           <== NOT EXECUTED
40011364:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
int                                                                   
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)          
{                                                                     
  if (dividend == 0)                                                  
    return 1;                                                         
  return ((dividend - 1) / divisor) + 1;                              
40011368:	7f ff c4 ce 	call  400026a0 <.udiv>                         
4001136c:	90 02 3f ff 	add  %o0, -1, %o0                              
{                                                                     
  int blocks;                                                         
  blocks = ((rtems_rfs_fs_blocks (fs) -                               
             RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;          
  blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);          
  return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
40011370:	92 10 20 38 	mov  0x38, %o1                                 
int                                                                   
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)          
{                                                                     
  if (dividend == 0)                                                  
    return 1;                                                         
  return ((dividend - 1) / divisor) + 1;                              
40011374:	b6 02 20 01 	add  %o0, 1, %i3                               
{                                                                     
  int blocks;                                                         
  blocks = ((rtems_rfs_fs_blocks (fs) -                               
             RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;          
  blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);          
  return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
40011378:	7f ff c4 ca 	call  400026a0 <.udiv>                         
4001137c:	90 10 00 1d 	mov  %i5, %o0                                  
40011380:	b8 10 00 08 	mov  %o0, %i4                                  
40011384:	90 10 00 1b 	mov  %i3, %o0                                  
40011388:	7f ff c4 8c 	call  400025b8 <.umul>                         
4001138c:	92 10 00 1c 	mov  %i4, %o1                                  
  }                                                                   
                                                                      
  /*                                                                  
   * 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;
40011390:	f8 27 bf ac 	st  %i4, [ %fp + -84 ]                         
{                                                                     
  int blocks;                                                         
  blocks = ((rtems_rfs_fs_blocks (fs) -                               
             RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;          
  blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);          
  return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
40011394:	b6 10 00 08 	mov  %o0, %i3                                  
 * "quotient = dividend / divisor"                                    
 */                                                                   
int                                                                   
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)          
{                                                                     
  if (dividend == 0)                                                  
40011398:	80 a6 e0 00 	cmp  %i3, 0                                    
4001139c:	02 bf fe 8b 	be  40010dc8 <rtems_rfs_format+0x150>          <== NEVER TAKEN
400113a0:	90 10 20 01 	mov  1, %o0                                    
    return 1;                                                         
  return ((dividend - 1) / divisor) + 1;                              
400113a4:	10 bf fe 86 	b  40010dbc <rtems_rfs_format+0x144>           
400113a8:	90 06 ff ff 	add  %i3, -1, %o0                              
 */                                                                   
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);                       
400113ac:	90 07 bf 7c 	add  %fp, -132, %o0                            
400113b0:	40 00 2c 22 	call  4001c438 <rtems_rfs_buffer_handle_release>
400113b4:	92 07 bf 30 	add  %fp, -208, %o1                            
  {                                                                   
    printf ("rtems-rfs: format: superblock write failed\n");          
    return -1;                                                        
  }                                                                   
                                                                      
  for (group = 0; group < fs.group_count; group++)                    
400113b8:	c2 07 bf a0 	ld  [ %fp + -96 ], %g1                         
400113bc:	80 a0 60 00 	cmp  %g1, 0                                    
400113c0:	04 80 01 36 	ble  40011898 <rtems_rfs_format+0xc20>         <== NEVER TAKEN
400113c4:	c2 07 bf 80 	ld  [ %fp + -128 ], %g1                        
    if (!rtems_rfs_write_group (&fs, group,                           
400113c8:	e2 0e 60 14 	ldub  [ %i1 + 0x14 ], %l1                      
400113cc:	c4 0e 60 15 	ldub  [ %i1 + 0x15 ], %g2                      
  int                      b;                                         
  int                      rc;                                        
                                                                      
  group_base = rtems_rfs_fs_block (fs, group, 0);                     
                                                                      
  if (group_base > rtems_rfs_fs_blocks (fs))                          
400113d0:	80 a0 60 00 	cmp  %g1, 0                                    
400113d4:	02 80 01 2f 	be  40011890 <rtems_rfs_format+0xc18>          <== NEVER TAKEN
400113d8:	f8 07 bf a4 	ld  [ %fp + -92 ], %i4                         
   */                                                                 
  if ((group_base + group_size) > rtems_rfs_fs_blocks (fs))           
    group_size = rtems_rfs_fs_blocks (fs) - group_base;               
                                                                      
  if (verbose)                                                        
    printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
400113dc:	27 10 00 d5 	sethi  %hi(0x40035400), %l3                    
            rc, strerror (rc));                                       
    return false;                                                     
  }                                                                   
                                                                      
  if (verbose)                                                        
    printf (", blocks");                                              
400113e0:	25 10 00 d5 	sethi  %hi(0x40035400), %l2                    
  }                                                                   
                                                                      
  rtems_rfs_buffer_mark_dirty (&handle);                              
                                                                      
  if (verbose)                                                        
    printf (", inodes");                                              
400113e4:	2b 10 00 d5 	sethi  %hi(0x40035400), %l5                    
  int                      b;                                         
  int                      rc;                                        
                                                                      
  group_base = rtems_rfs_fs_block (fs, group, 0);                     
                                                                      
  if (group_base > rtems_rfs_fs_blocks (fs))                          
400113e8:	b6 10 20 01 	mov  1, %i3                                    
400113ec:	a0 10 20 00 	clr  %l0                                       
400113f0:	b4 10 20 00 	clr  %i2                                       
   */                                                                 
  if ((group_base + group_size) > rtems_rfs_fs_blocks (fs))           
    group_size = rtems_rfs_fs_blocks (fs) - group_base;               
                                                                      
  if (verbose)                                                        
    printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
400113f4:	a6 14 e2 a8 	or  %l3, 0x2a8, %l3                            
            rc, strerror (rc));                                       
    return false;                                                     
  }                                                                   
                                                                      
  if (verbose)                                                        
    printf (", blocks");                                              
400113f8:	a4 14 a2 e0 	or  %l2, 0x2e0, %l2                            
    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);                              
400113fc:	a8 10 20 01 	mov  1, %l4                                    
                                                                      
  if (verbose)                                                        
    printf (", inodes");                                              
40011400:	aa 15 63 d0 	or  %l5, 0x3d0, %l5                            
  /*                                                                  
   * 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))           
40011404:	86 06 c0 1c 	add  %i3, %i4, %g3                             
40011408:	80 a0 c0 01 	cmp  %g3, %g1                                  
4001140c:	38 80 00 02 	bgu,a   40011414 <rtems_rfs_format+0x79c>      <== ALWAYS TAKEN
40011410:	b8 20 40 1b 	sub  %g1, %i3, %i4                             
    group_size = rtems_rfs_fs_blocks (fs) - group_base;               
                                                                      
  if (verbose)                                                        
40011414:	ac 88 a0 ff 	andcc  %g2, 0xff, %l6                          
40011418:	12 80 00 3b 	bne  40011504 <rtems_rfs_format+0x88c>         <== NEVER TAKEN
4001141c:	90 10 00 13 	mov  %l3, %o0                                  
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
40011420:	c0 2f bf 30 	clrb  [ %fp + -208 ]                           
  handle->bnum  = 0;                                                  
40011424:	c0 27 bf 34 	clr  [ %fp + -204 ]                            
  handle->buffer = NULL;                                              
40011428:	c0 27 bf 38 	clr  [ %fp + -200 ]                            
    printf (", blocks");                                              
                                                                      
  /*                                                                  
   * Open the block bitmap using the new buffer.                      
   */                                                                 
  rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,       
4001142c:	90 07 bf 3c 	add  %fp, -196, %o0                            
40011430:	92 07 bf 7c 	add  %fp, -132, %o1                            
40011434:	94 07 bf 30 	add  %fp, -208, %o2                            
40011438:	96 10 00 1c 	mov  %i4, %o3                                  
4001143c:	40 00 27 66 	call  4001b1d4 <rtems_rfs_bitmap_open>         
40011440:	98 10 00 1b 	mov  %i3, %o4                                  
                              group_base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
  if (rc > 0)                                                         
40011444:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40011448:	04 80 00 12 	ble  40011490 <rtems_rfs_format+0x818>         <== ALWAYS TAKEN
4001144c:	92 07 bf 30 	add  %fp, -208, %o1                            
 */                                                                   
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);                       
40011450:	40 00 2b fa 	call  4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40011454:	90 07 bf 7c 	add  %fp, -132, %o0                            <== NOT EXECUTED
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &handle);                      
    printf ("\nrtems-rfs: write-group: group %3d: open block bitmap failed: %d: %s\n",
40011458:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
4001145c:	c0 2f bf 30 	clrb  [ %fp + -208 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
40011460:	c0 27 bf 34 	clr  [ %fp + -204 ]                            <== NOT EXECUTED
40011464:	40 00 4f 10 	call  400250a4 <strerror>                      <== NOT EXECUTED
40011468:	c0 27 bf 38 	clr  [ %fp + -200 ]                            <== NOT EXECUTED
4001146c:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
40011470:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
40011474:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
40011478:	11 10 00 d5 	sethi  %hi(0x40035400), %o0                    <== NOT EXECUTED
  }                                                                   
                                                                      
  if (!rtems_rfs_write_superblock (&fs))                              
  {                                                                   
    printf ("rtems-rfs: format: superblock write failed\n");          
    return -1;                                                        
4001147c:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
  rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,       
                              group_base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &handle);                      
    printf ("\nrtems-rfs: write-group: group %3d: open block bitmap failed: %d: %s\n",
40011480:	40 00 4a bf 	call  40023f7c <printf>                        <== NOT EXECUTED
40011484:	90 12 22 f0 	or  %o0, 0x2f0, %o0                            <== NOT EXECUTED
40011488:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001148c:	81 e8 00 00 	restore                                        <== 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));
40011490:	c2 07 bf 38 	ld  [ %fp + -200 ], %g1                        
40011494:	d4 07 bf 84 	ld  [ %fp + -124 ], %o2                        
40011498:	d0 00 60 1c 	ld  [ %g1 + 0x1c ], %o0                        
4001149c:	40 00 4a 3a 	call  40023d84 <memset>                        
400114a0:	92 10 20 ff 	mov  0xff, %o1                                 
                                                                      
  /*                                                                  
   * Clear the bitmap.                                                
   */                                                                 
  rc = rtems_rfs_bitmap_map_clear_all (&bitmap);                      
400114a4:	40 00 26 a4 	call  4001af34 <rtems_rfs_bitmap_map_clear_all>
400114a8:	90 07 bf 3c 	add  %fp, -196, %o0                            
  if (rc > 0)                                                         
400114ac:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400114b0:	04 80 00 20 	ble  40011530 <rtems_rfs_format+0x8b8>         <== ALWAYS TAKEN
400114b4:	92 10 20 00 	clr  %o1                                       
  {                                                                   
    rtems_rfs_bitmap_close (&bitmap);                                 
400114b8:	40 00 27 58 	call  4001b218 <rtems_rfs_bitmap_close>        <== NOT EXECUTED
400114bc:	90 07 bf 3c 	add  %fp, -196, %o0                            <== 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);                       
400114c0:	92 07 bf 30 	add  %fp, -208, %o1                            <== NOT EXECUTED
400114c4:	40 00 2b dd 	call  4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
400114c8:	90 07 bf 7c 	add  %fp, -132, %o0                            <== NOT EXECUTED
    rtems_rfs_buffer_handle_close (fs, &handle);                      
    printf ("\nrtems-rfs: write-group: group %3d: block bitmap clear all failed: %d: %s\n",
400114cc:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
400114d0:	c0 2f bf 30 	clrb  [ %fp + -208 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
400114d4:	c0 27 bf 34 	clr  [ %fp + -204 ]                            <== NOT EXECUTED
400114d8:	40 00 4e f3 	call  400250a4 <strerror>                      <== NOT EXECUTED
400114dc:	c0 27 bf 38 	clr  [ %fp + -200 ]                            <== NOT EXECUTED
400114e0:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
400114e4:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
400114e8:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
400114ec:	11 10 00 d5 	sethi  %hi(0x40035400), %o0                    <== NOT EXECUTED
  }                                                                   
                                                                      
  if (!rtems_rfs_write_superblock (&fs))                              
  {                                                                   
    printf ("rtems-rfs: format: superblock write failed\n");          
    return -1;                                                        
400114f0:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
  rc = rtems_rfs_bitmap_map_clear_all (&bitmap);                      
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_bitmap_close (&bitmap);                                 
    rtems_rfs_buffer_handle_close (fs, &handle);                      
    printf ("\nrtems-rfs: write-group: group %3d: block bitmap clear all failed: %d: %s\n",
400114f4:	40 00 4a a2 	call  40023f7c <printf>                        <== NOT EXECUTED
400114f8:	90 12 23 38 	or  %o0, 0x338, %o0                            <== NOT EXECUTED
400114fc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40011500:	81 e8 00 00 	restore                                        <== NOT EXECUTED
   */                                                                 
  if ((group_base + group_size) > rtems_rfs_fs_blocks (fs))           
    group_size = rtems_rfs_fs_blocks (fs) - group_base;               
                                                                      
  if (verbose)                                                        
    printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
40011504:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
40011508:	94 10 00 1b 	mov  %i3, %o2                                  <== NOT EXECUTED
4001150c:	40 00 4a 9c 	call  40023f7c <printf>                        <== NOT EXECUTED
40011510:	96 10 00 1c 	mov  %i4, %o3                                  <== NOT EXECUTED
            rc, strerror (rc));                                       
    return false;                                                     
  }                                                                   
                                                                      
  if (verbose)                                                        
    printf (", blocks");                                              
40011514:	90 10 00 12 	mov  %l2, %o0                                  <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
40011518:	c0 2f bf 30 	clrb  [ %fp + -208 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
4001151c:	c0 27 bf 34 	clr  [ %fp + -204 ]                            <== NOT EXECUTED
40011520:	40 00 4a 97 	call  40023f7c <printf>                        <== NOT EXECUTED
40011524:	c0 27 bf 38 	clr  [ %fp + -200 ]                            <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Open the block bitmap using the new buffer.                      
   */                                                                 
  rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,       
40011528:	10 bf ff c2 	b  40011430 <rtems_rfs_format+0x7b8>           <== NOT EXECUTED
4001152c:	90 07 bf 3c 	add  %fp, -196, %o0                            <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * Forced allocation of the block bitmap.                           
   */                                                                 
  rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
40011530:	40 00 25 fa 	call  4001ad18 <rtems_rfs_bitmap_map_set>      
40011534:	90 07 bf 3c 	add  %fp, -196, %o0                            
                                                                      
  /*                                                                  
   * Forced allocation of the inode bitmap.                           
   */                                                                 
  rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
40011538:	92 10 20 01 	mov  1, %o1                                    
4001153c:	40 00 25 f7 	call  4001ad18 <rtems_rfs_bitmap_map_set>      
40011540:	90 07 bf 3c 	add  %fp, -196, %o0                            
                                                                      
  /*                                                                  
   * Determine the number of inodes blocks in the group.              
   */                                                                 
  blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
40011544:	d0 07 bf a8 	ld  [ %fp + -88 ], %o0                         
 * "quotient = dividend / divisor"                                    
 */                                                                   
int                                                                   
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)          
{                                                                     
  if (dividend == 0)                                                  
40011548:	80 a2 20 00 	cmp  %o0, 0                                    
4001154c:	12 80 00 2b 	bne  400115f8 <rtems_rfs_format+0x980>         <== ALWAYS TAKEN
40011550:	d2 07 bf ac 	ld  [ %fp + -84 ], %o1                         
    return 1;                                                         
40011554:	ae 10 20 01 	mov  1, %l7                                    <== NOT EXECUTED
40011558:	ba 10 20 00 	clr  %i5                                       <== 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);
4001155c:	92 07 60 02 	add  %i5, 2, %o1                               
40011560:	40 00 25 ee 	call  4001ad18 <rtems_rfs_bitmap_map_set>      
40011564:	90 07 bf 3c 	add  %fp, -196, %o0                            
  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++)                                        
40011568:	ba 07 60 01 	inc  %i5                                       
4001156c:	80 a7 40 17 	cmp  %i5, %l7                                  
40011570:	06 bf ff fc 	bl  40011560 <rtems_rfs_format+0x8e8>          
40011574:	92 07 60 02 	add  %i5, 2, %o1                               
    rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
                                                                      
  /*                                                                  
   * Close the block bitmap.                                          
   */                                                                 
  rc = rtems_rfs_bitmap_close (&bitmap);                              
40011578:	40 00 27 28 	call  4001b218 <rtems_rfs_bitmap_close>        
4001157c:	90 07 bf 3c 	add  %fp, -196, %o0                            
  if (rc > 0)                                                         
40011580:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40011584:	14 80 00 24 	bg  40011614 <rtems_rfs_format+0x99c>          <== NEVER TAKEN
40011588:	80 a5 a0 00 	cmp  %l6, 0                                    
    return false;                                                     
  }                                                                   
                                                                      
  rtems_rfs_buffer_mark_dirty (&handle);                              
                                                                      
  if (verbose)                                                        
4001158c:	12 80 00 50 	bne  400116cc <rtems_rfs_format+0xa54>         <== NEVER TAKEN
40011590:	e8 2f bf 30 	stb  %l4, [ %fp + -208 ]                       
    printf (", inodes");                                              
                                                                      
  /*                                                                  
   * Open the inode bitmap using the old buffer. Should release any changes.
   */                                                                 
  rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,       
40011594:	90 07 bf 3c 	add  %fp, -196, %o0                            
40011598:	92 07 bf 7c 	add  %fp, -132, %o1                            
4001159c:	94 07 bf 30 	add  %fp, -208, %o2                            
400115a0:	96 10 00 1c 	mov  %i4, %o3                                  
400115a4:	40 00 27 0c 	call  4001b1d4 <rtems_rfs_bitmap_open>         
400115a8:	98 04 20 02 	add  %l0, 2, %o4                               
                              group_base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
  if (rc > 0)                                                         
400115ac:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400115b0:	04 80 00 2a 	ble  40011658 <rtems_rfs_format+0x9e0>         <== ALWAYS TAKEN
400115b4:	92 07 bf 30 	add  %fp, -208, %o1                            
 */                                                                   
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);                       
400115b8:	40 00 2b a0 	call  4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
400115bc:	90 07 bf 7c 	add  %fp, -132, %o0                            <== NOT EXECUTED
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &handle);                      
    printf ("\nrtems-rfs: write-group: group %3d: open inode bitmap failed: %d: %s\n",
400115c0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
400115c4:	c0 2f bf 30 	clrb  [ %fp + -208 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
400115c8:	c0 27 bf 34 	clr  [ %fp + -204 ]                            <== NOT EXECUTED
400115cc:	40 00 4e b6 	call  400250a4 <strerror>                      <== NOT EXECUTED
400115d0:	c0 27 bf 38 	clr  [ %fp + -200 ]                            <== NOT EXECUTED
400115d4:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
400115d8:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
400115dc:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
400115e0:	11 10 00 d5 	sethi  %hi(0x40035400), %o0                    <== NOT EXECUTED
  }                                                                   
                                                                      
  if (!rtems_rfs_write_superblock (&fs))                              
  {                                                                   
    printf ("rtems-rfs: format: superblock write failed\n");          
    return -1;                                                        
400115e4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
  rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,       
                              group_base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &handle);                      
    printf ("\nrtems-rfs: write-group: group %3d: open inode bitmap failed: %d: %s\n",
400115e8:	40 00 4a 65 	call  40023f7c <printf>                        <== NOT EXECUTED
400115ec:	90 12 23 e0 	or  %o0, 0x3e0, %o0                            <== NOT EXECUTED
400115f0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400115f4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
int                                                                   
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)          
{                                                                     
  if (dividend == 0)                                                  
    return 1;                                                         
  return ((dividend - 1) / divisor) + 1;                              
400115f8:	7f ff c4 2a 	call  400026a0 <.udiv>                         
400115fc:	90 02 3f ff 	add  %o0, -1, %o0                              
40011600:	ae 02 20 01 	add  %o0, 1, %l7                               
  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++)                                        
40011604:	80 a5 e0 00 	cmp  %l7, 0                                    
40011608:	14 bf ff d5 	bg  4001155c <rtems_rfs_format+0x8e4>          <== ALWAYS TAKEN
4001160c:	ba 10 20 00 	clr  %i5                                       
40011610:	30 bf ff da 	b,a   40011578 <rtems_rfs_format+0x900>        <== 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);                       
40011614:	92 07 bf 30 	add  %fp, -208, %o1                            <== NOT EXECUTED
40011618:	40 00 2b 88 	call  4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001161c:	90 07 bf 7c 	add  %fp, -132, %o0                            <== NOT EXECUTED
   */                                                                 
  rc = rtems_rfs_bitmap_close (&bitmap);                              
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &handle);                      
    printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
40011620:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
40011624:	c0 2f bf 30 	clrb  [ %fp + -208 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
40011628:	c0 27 bf 34 	clr  [ %fp + -204 ]                            <== NOT EXECUTED
4001162c:	40 00 4e 9e 	call  400250a4 <strerror>                      <== NOT EXECUTED
40011630:	c0 27 bf 38 	clr  [ %fp + -200 ]                            <== NOT EXECUTED
40011634:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
40011638:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
4001163c:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
40011640:	11 10 00 d5 	sethi  %hi(0x40035400), %o0                    <== NOT EXECUTED
  }                                                                   
                                                                      
  if (!rtems_rfs_write_superblock (&fs))                              
  {                                                                   
    printf ("rtems-rfs: format: superblock write failed\n");          
    return -1;                                                        
40011644:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
   */                                                                 
  rc = rtems_rfs_bitmap_close (&bitmap);                              
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &handle);                      
    printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
40011648:	40 00 4a 4d 	call  40023f7c <printf>                        <== NOT EXECUTED
4001164c:	90 12 23 88 	or  %o0, 0x388, %o0                            <== NOT EXECUTED
40011650:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40011654:	81 e8 00 00 	restore                                        <== 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));
40011658:	c2 07 bf 38 	ld  [ %fp + -200 ], %g1                        
4001165c:	d4 07 bf 84 	ld  [ %fp + -124 ], %o2                        
40011660:	d0 00 60 1c 	ld  [ %g1 + 0x1c ], %o0                        
40011664:	40 00 49 c8 	call  40023d84 <memset>                        
40011668:	92 10 20 00 	clr  %o1                                       
                                                                      
  /*                                                                  
   * Clear the inode bitmap.                                          
   */                                                                 
  rc = rtems_rfs_bitmap_map_clear_all (&bitmap);                      
4001166c:	40 00 26 32 	call  4001af34 <rtems_rfs_bitmap_map_clear_all>
40011670:	90 07 bf 3c 	add  %fp, -196, %o0                            
40011674:	ba 10 00 08 	mov  %o0, %i5                                  
  if (rc > 0)                                                         
40011678:	80 a7 60 00 	cmp  %i5, 0                                    
4001167c:	04 80 00 21 	ble  40011700 <rtems_rfs_format+0xa88>         <== ALWAYS TAKEN
40011680:	90 07 bf 3c 	add  %fp, -196, %o0                            
  {                                                                   
    rtems_rfs_bitmap_close (&bitmap);                                 
40011684:	40 00 26 e5 	call  4001b218 <rtems_rfs_bitmap_close>        <== NOT EXECUTED
40011688:	b0 10 3f ff 	mov  -1, %i0                                   <== 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);                       
4001168c:	92 07 bf 30 	add  %fp, -208, %o1                            <== NOT EXECUTED
40011690:	40 00 2b 6a 	call  4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40011694:	90 07 bf 7c 	add  %fp, -132, %o0                            <== NOT EXECUTED
    rtems_rfs_buffer_handle_close (fs, &handle);                      
    printf ("\nrtems-rfs: write-group: group %3d: inode bitmap" \     
40011698:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
4001169c:	c0 2f bf 30 	clrb  [ %fp + -208 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
400116a0:	c0 27 bf 34 	clr  [ %fp + -204 ]                            <== NOT EXECUTED
400116a4:	40 00 4e 80 	call  400250a4 <strerror>                      <== NOT EXECUTED
400116a8:	c0 27 bf 38 	clr  [ %fp + -200 ]                            <== NOT EXECUTED
400116ac:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
400116b0:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
400116b4:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
400116b8:	11 10 00 d6 	sethi  %hi(0x40035800), %o0                    <== NOT EXECUTED
400116bc:	40 00 4a 30 	call  40023f7c <printf>                        <== NOT EXECUTED
400116c0:	90 12 20 28 	or  %o0, 0x28, %o0	! 40035828 <_CPU_Trap_slot_template+0x540><== NOT EXECUTED
400116c4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400116c8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  rtems_rfs_buffer_mark_dirty (&handle);                              
                                                                      
  if (verbose)                                                        
    printf (", inodes");                                              
400116cc:	40 00 4a 2c 	call  40023f7c <printf>                        <== NOT EXECUTED
400116d0:	90 10 00 15 	mov  %l5, %o0                                  <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Open the inode bitmap using the old buffer. Should release any changes.
   */                                                                 
  rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,       
400116d4:	10 bf ff b1 	b  40011598 <rtems_rfs_format+0x920>           <== NOT EXECUTED
400116d8:	90 07 bf 3c 	add  %fp, -196, %o0                            <== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_buffer_setblksize (&fs, rtems_rfs_fs_block_size (&fs));
  if (rc > 0)                                                         
  {                                                                   
    printf ("rtems-rfs: format: setting block size failed: %d: %s\n", 
400116dc:	40 00 4e 72 	call  400250a4 <strerror>                      <== NOT EXECUTED
400116e0:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
400116e4:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
400116e8:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
400116ec:	11 10 00 d5 	sethi  %hi(0x40035400), %o0                    <== NOT EXECUTED
400116f0:	40 00 4a 23 	call  40023f7c <printf>                        <== NOT EXECUTED
400116f4:	90 12 21 b8 	or  %o0, 0x1b8, %o0	! 400355b8 <_CPU_Trap_slot_template+0x2d0><== NOT EXECUTED
400116f8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400116fc:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * Close the inode bitmap.                                          
   */                                                                 
  rc = rtems_rfs_bitmap_close (&bitmap);                              
40011700:	40 00 26 c6 	call  4001b218 <rtems_rfs_bitmap_close>        
40011704:	01 00 00 00 	nop                                            
  if (rc > 0)                                                         
40011708:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001170c:	14 80 00 2a 	bg  400117b4 <rtems_rfs_format+0xb3c>          <== NEVER TAKEN
40011710:	80 8c 60 ff 	btst  0xff, %l1                                
  rtems_rfs_buffer_mark_dirty (&handle);                              
                                                                      
  /*                                                                  
   * Initialise the inode tables if required to do so.                
   */                                                                 
  if (initialise_inodes)                                              
40011714:	02 80 00 46 	be  4001182c <rtems_rfs_format+0xbb4>          <== ALWAYS TAKEN
40011718:	e8 2f bf 30 	stb  %l4, [ %fp + -208 ]                       
  {                                                                   
    for (b = 0; b < blocks; b++)                                      
4001171c:	80 a5 e0 00 	cmp  %l7, 0                                    <== NOT EXECUTED
40011720:	04 80 00 43 	ble  4001182c <rtems_rfs_format+0xbb4>         <== NOT EXECUTED
40011724:	b6 06 e0 02 	add  %i3, 2, %i3                               <== NOT EXECUTED
                                                                      
  return rc;                                                          
}                                                                     
                                                                      
int                                                                   
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
40011728:	10 80 00 0a 	b  40011750 <rtems_rfs_format+0xad8>           <== NOT EXECUTED
4001172c:	ae 05 c0 1b 	add  %l7, %i3, %l7                             <== 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));
40011730:	c2 07 bf 38 	ld  [ %fp + -200 ], %g1                        <== NOT EXECUTED
40011734:	d4 07 bf 84 	ld  [ %fp + -124 ], %o2                        <== NOT EXECUTED
40011738:	d0 00 60 1c 	ld  [ %g1 + 0x1c ], %o0                        <== NOT EXECUTED
4001173c:	40 00 49 92 	call  40023d84 <memset>                        <== NOT EXECUTED
40011740:	b6 06 e0 01 	inc  %i3                                       <== NOT EXECUTED
  /*                                                                  
   * Initialise the inode tables if required to do so.                
   */                                                                 
  if (initialise_inodes)                                              
  {                                                                   
    for (b = 0; b < blocks; b++)                                      
40011744:	80 a6 c0 17 	cmp  %i3, %l7                                  <== NOT EXECUTED
40011748:	02 80 00 39 	be  4001182c <rtems_rfs_format+0xbb4>          <== NOT EXECUTED
4001174c:	e8 2f bf 30 	stb  %l4, [ %fp + -208 ]                       <== NOT EXECUTED
    {                                                                 
      rc = rtems_rfs_buffer_handle_request (fs, &handle,              
40011750:	92 07 bf 30 	add  %fp, -208, %o1                            <== NOT EXECUTED
40011754:	94 10 00 1b 	mov  %i3, %o2                                  <== NOT EXECUTED
40011758:	96 10 20 00 	clr  %o3                                       <== NOT EXECUTED
4001175c:	40 00 2b b1 	call  4001c620 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
40011760:	90 07 bf 7c 	add  %fp, -132, %o0                            <== 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));
40011764:	92 10 20 ff 	mov  0xff, %o1                                 <== NOT EXECUTED
    for (b = 0; b < blocks; b++)                                      
    {                                                                 
      rc = rtems_rfs_buffer_handle_request (fs, &handle,              
                                            group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
                                            false);                   
      if (rc > 0)                                                     
40011768:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4001176c:	04 bf ff f1 	ble  40011730 <rtems_rfs_format+0xab8>         <== NOT EXECUTED
40011770:	ba 10 00 08 	mov  %o0, %i5                                  <== 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);                       
40011774:	92 07 bf 30 	add  %fp, -208, %o1                            <== NOT EXECUTED
40011778:	40 00 2b 30 	call  4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001177c:	90 07 bf 7c 	add  %fp, -132, %o0                            <== NOT EXECUTED
      {                                                               
        rtems_rfs_buffer_handle_close (fs, &handle);                  
        printf ("\nrtems-rfs: write-group: group %3d: block %" PRId32 " request failed: %d: %s\n",
40011780:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
40011784:	c0 2f bf 30 	clrb  [ %fp + -208 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
40011788:	c0 27 bf 34 	clr  [ %fp + -204 ]                            <== NOT EXECUTED
4001178c:	40 00 4e 46 	call  400250a4 <strerror>                      <== NOT EXECUTED
40011790:	c0 27 bf 38 	clr  [ %fp + -200 ]                            <== NOT EXECUTED
40011794:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
40011798:	98 10 00 08 	mov  %o0, %o4                                  <== NOT EXECUTED
4001179c:	94 10 00 1b 	mov  %i3, %o2                                  <== NOT EXECUTED
400117a0:	11 10 00 d6 	sethi  %hi(0x40035800), %o0                    <== NOT EXECUTED
400117a4:	96 10 00 1d 	mov  %i5, %o3                                  <== NOT EXECUTED
400117a8:	40 00 49 f5 	call  40023f7c <printf>                        <== NOT EXECUTED
400117ac:	90 12 20 c0 	or  %o0, 0xc0, %o0                             <== NOT EXECUTED
400117b0:	30 bf fd bb 	b,a   40010e9c <rtems_rfs_format+0x224>        <== 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);                       
400117b4:	92 07 bf 30 	add  %fp, -208, %o1                            <== NOT EXECUTED
400117b8:	40 00 2b 20 	call  4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
400117bc:	90 07 bf 7c 	add  %fp, -132, %o0                            <== NOT EXECUTED
   */                                                                 
  rc = rtems_rfs_bitmap_close (&bitmap);                              
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &handle);                      
    printf ("\nrtems-rfs: write-group: group %3d: close inode" \      
400117c0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
400117c4:	c0 2f bf 30 	clrb  [ %fp + -208 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
400117c8:	c0 27 bf 34 	clr  [ %fp + -204 ]                            <== NOT EXECUTED
400117cc:	40 00 4e 36 	call  400250a4 <strerror>                      <== NOT EXECUTED
400117d0:	c0 27 bf 38 	clr  [ %fp + -200 ]                            <== NOT EXECUTED
400117d4:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
400117d8:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
400117dc:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
400117e0:	11 10 00 d6 	sethi  %hi(0x40035800), %o0                    <== NOT EXECUTED
400117e4:	40 00 49 e6 	call  40023f7c <printf>                        <== NOT EXECUTED
400117e8:	90 12 20 78 	or  %o0, 0x78, %o0	! 40035878 <_CPU_Trap_slot_template+0x590><== NOT EXECUTED
400117ec:	30 bf fd ac 	b,a   40010e9c <rtems_rfs_format+0x224>        <== NOT EXECUTED
   * Open the buffer interface.                                       
   */                                                                 
  rc = rtems_rfs_buffer_open (name, &fs);                             
  if (rc > 0)                                                         
  {                                                                   
    printf ("rtems-rfs: format: buffer open failed: %d: %s\n",        
400117f0:	40 00 4e 2d 	call  400250a4 <strerror>                      <== NOT EXECUTED
400117f4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
400117f8:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
400117fc:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40011800:	11 10 00 d4 	sethi  %hi(0x40035000), %o0                    <== NOT EXECUTED
40011804:	40 00 49 de 	call  40023f7c <printf>                        <== NOT EXECUTED
40011808:	90 12 23 10 	or  %o0, 0x310, %o0	! 40035310 <_CPU_Trap_slot_template+0x28><== NOT EXECUTED
4001180c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40011810:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  /*                                                                  
   * Check the media.                                                 
   */                                                                 
  if (rtems_rfs_fs_media_block_size (&fs) == 0)                       
  {                                                                   
    printf ("rtems-rfs: media block is invalid: %" PRIu32 "\n",       
40011814:	11 10 00 d4 	sethi  %hi(0x40035000), %o0                    <== NOT EXECUTED
            rtems_rfs_fs_media_block_size (&fs));                     
    return -1;                                                        
40011818:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
  /*                                                                  
   * Check the media.                                                 
   */                                                                 
  if (rtems_rfs_fs_media_block_size (&fs) == 0)                       
  {                                                                   
    printf ("rtems-rfs: media block is invalid: %" PRIu32 "\n",       
4001181c:	40 00 49 d8 	call  40023f7c <printf>                        <== NOT EXECUTED
40011820:	90 12 23 40 	or  %o0, 0x340, %o0                            <== NOT EXECUTED
40011824:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40011828:	81 e8 00 00 	restore                                        <== 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);                       
4001182c:	90 07 bf 7c 	add  %fp, -132, %o0                            
40011830:	40 00 2b 02 	call  4001c438 <rtems_rfs_buffer_handle_release>
40011834:	92 07 bf 30 	add  %fp, -208, %o1                            
  {                                                                   
    printf ("rtems-rfs: format: superblock write failed\n");          
    return -1;                                                        
  }                                                                   
                                                                      
  for (group = 0; group < fs.group_count; group++)                    
40011838:	c2 07 bf a0 	ld  [ %fp + -96 ], %g1                         
4001183c:	b4 06 a0 01 	inc  %i2                                       
40011840:	80 a0 40 1a 	cmp  %g1, %i2                                  
40011844:	04 80 00 15 	ble  40011898 <rtems_rfs_format+0xc20>         <== ALWAYS TAKEN
40011848:	f8 07 bf a4 	ld  [ %fp + -92 ], %i4                         
  size_t                   group_size;                                
  int                      blocks;                                    
  int                      b;                                         
  int                      rc;                                        
                                                                      
  group_base = rtems_rfs_fs_block (fs, group, 0);                     
4001184c:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
40011850:	7f ff c3 5a 	call  400025b8 <.umul>                         <== NOT EXECUTED
40011854:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
                                                                      
  if (group_base > rtems_rfs_fs_blocks (fs))                          
40011858:	c2 07 bf 80 	ld  [ %fp + -128 ], %g1                        <== NOT EXECUTED
  size_t                   group_size;                                
  int                      blocks;                                    
  int                      b;                                         
  int                      rc;                                        
                                                                      
  group_base = rtems_rfs_fs_block (fs, group, 0);                     
4001185c:	b6 02 20 01 	add  %o0, 1, %i3                               <== NOT EXECUTED
40011860:	a0 10 00 08 	mov  %o0, %l0                                  <== NOT EXECUTED
    printf ("rtems-rfs: format: superblock write failed\n");          
    return -1;                                                        
  }                                                                   
                                                                      
  for (group = 0; group < fs.group_count; group++)                    
    if (!rtems_rfs_write_group (&fs, group,                           
40011864:	e2 0e 60 14 	ldub  [ %i1 + 0x14 ], %l1                      <== NOT EXECUTED
  int                      b;                                         
  int                      rc;                                        
                                                                      
  group_base = rtems_rfs_fs_block (fs, group, 0);                     
                                                                      
  if (group_base > rtems_rfs_fs_blocks (fs))                          
40011868:	80 a6 c0 01 	cmp  %i3, %g1                                  <== NOT EXECUTED
4001186c:	08 bf fe e6 	bleu  40011404 <rtems_rfs_format+0x78c>        <== NOT EXECUTED
40011870:	c4 0e 60 15 	ldub  [ %i1 + 0x15 ], %g2                      <== NOT EXECUTED
  {                                                                   
    printf ("rtems-rfs: write-group: group %d base beyond disk limit\n",
40011874:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
40011878:	11 10 00 d5 	sethi  %hi(0x40035400), %o0                    <== NOT EXECUTED
  }                                                                   
                                                                      
  if (!rtems_rfs_write_superblock (&fs))                              
  {                                                                   
    printf ("rtems-rfs: format: superblock write failed\n");          
    return -1;                                                        
4001187c:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
                                                                      
  group_base = rtems_rfs_fs_block (fs, group, 0);                     
                                                                      
  if (group_base > rtems_rfs_fs_blocks (fs))                          
  {                                                                   
    printf ("rtems-rfs: write-group: group %d base beyond disk limit\n",
40011880:	40 00 49 bf 	call  40023f7c <printf>                        <== NOT EXECUTED
40011884:	90 12 22 68 	or  %o0, 0x268, %o0                            <== NOT EXECUTED
40011888:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001188c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  int                      b;                                         
  int                      rc;                                        
                                                                      
  group_base = rtems_rfs_fs_block (fs, group, 0);                     
                                                                      
  if (group_base > rtems_rfs_fs_blocks (fs))                          
40011890:	10 bf ff f9 	b  40011874 <rtems_rfs_format+0xbfc>           <== NOT EXECUTED
40011894:	b4 10 20 00 	clr  %i2                                       <== NOT EXECUTED
  for (group = 0; group < fs.group_count; group++)                    
    if (!rtems_rfs_write_group (&fs, group,                           
                                config->initialise_inodes, config->verbose))
      return -1;                                                      
                                                                      
  if (config->verbose)                                                
40011898:	c2 0e 60 15 	ldub  [ %i1 + 0x15 ], %g1                      
4001189c:	80 a0 60 00 	cmp  %g1, 0                                    
400118a0:	02 80 00 04 	be  400118b0 <rtems_rfs_format+0xc38>          <== ALWAYS TAKEN
400118a4:	01 00 00 00 	nop                                            
    printf ("\n");                                                    
400118a8:	40 00 4a 1f 	call  40024124 <putchar>                       <== NOT EXECUTED
400118ac:	90 10 20 0a 	mov  0xa, %o0	! a <PROM_START+0xa>             <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_buffer_close (&fs);                                  
400118b0:	40 00 2d 10 	call  4001ccf0 <rtems_rfs_buffer_close>        
400118b4:	90 07 bf 7c 	add  %fp, -132, %o0                            
  if (rc > 0)                                                         
400118b8:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400118bc:	14 80 00 43 	bg  400119c8 <rtems_rfs_format+0xd50>          <== NEVER TAKEN
400118c0:	92 10 20 00 	clr  %o1                                       
  int                    rc;                                          
                                                                      
  /*                                                                  
   * External API so returns -1.                                      
   */                                                                 
  rc = rtems_rfs_fs_open (name, NULL,                                 
400118c4:	90 10 00 18 	mov  %i0, %o0                                  
400118c8:	94 10 20 06 	mov  6, %o2                                    
400118cc:	96 10 20 00 	clr  %o3                                       
400118d0:	40 00 36 66 	call  4001f268 <rtems_rfs_fs_open>             
400118d4:	98 07 bf 28 	add  %fp, -216, %o4                            
                          RTEMS_RFS_FS_FORCE_OPEN | RTEMS_RFS_FS_NO_LOCAL_CACHE,
                          0, &fs);                                    
  if (rc < 0)                                                         
400118d8:	80 a2 20 00 	cmp  %o0, 0                                    
400118dc:	06 80 00 7b 	bl  40011ac8 <rtems_rfs_format+0xe50>          <== NEVER TAKEN
400118e0:	92 10 20 01 	mov  1, %o1                                    
    printf ("rtems-rfs: format: file system open failed: %d: %s\n",   
            errno, strerror (errno));                                 
    return -1;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_alloc (fs, RTEMS_RFS_ROOT_INO, &ino);          
400118e4:	d0 07 bf 28 	ld  [ %fp + -216 ], %o0                        
400118e8:	40 00 02 8c 	call  40012318 <rtems_rfs_inode_alloc>         
400118ec:	94 07 bf 2c 	add  %fp, -212, %o2                            
  if (rc > 0)                                                         
400118f0:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400118f4:	14 80 00 0c 	bg  40011924 <rtems_rfs_format+0xcac>          <== NEVER TAKEN
400118f8:	d2 07 bf 2c 	ld  [ %fp + -212 ], %o1                        
            rc, strerror (rc));                                       
    rtems_rfs_fs_close (fs);                                          
    return rc;                                                        
  }                                                                   
                                                                      
  if (ino != RTEMS_RFS_ROOT_INO)                                      
400118fc:	80 a2 60 01 	cmp  %o1, 1                                    
40011900:	02 80 00 1c 	be  40011970 <rtems_rfs_format+0xcf8>          <== ALWAYS TAKEN
40011904:	11 10 00 d6 	sethi  %hi(0x40035800), %o0                    
  {                                                                   
    printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
40011908:	40 00 49 9d 	call  40023f7c <printf>                        <== NOT EXECUTED
4001190c:	90 12 21 a8 	or  %o0, 0x1a8, %o0	! 400359a8 <_CPU_Trap_slot_template+0x6c0><== NOT EXECUTED
    rtems_rfs_fs_close (fs);                                          
40011910:	d0 07 bf 28 	ld  [ %fp + -216 ], %o0                        <== NOT EXECUTED
40011914:	40 00 38 81 	call  4001fb18 <rtems_rfs_fs_close>            <== NOT EXECUTED
40011918:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
            rc, strerror (rc));                                       
    return -1;                                                        
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
4001191c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40011920:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_alloc (fs, RTEMS_RFS_ROOT_INO, &ino);          
  if (rc > 0)                                                         
  {                                                                   
    printf ("rtems-rfs: format: inode allocation failed: %d: %s\n",   
40011924:	40 00 4d e0 	call  400250a4 <strerror>                      <== NOT EXECUTED
40011928:	01 00 00 00 	nop                                            <== NOT EXECUTED
4001192c:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
40011930:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40011934:	11 10 00 d6 	sethi  %hi(0x40035800), %o0                    <== NOT EXECUTED
40011938:	40 00 49 91 	call  40023f7c <printf>                        <== NOT EXECUTED
4001193c:	90 12 21 70 	or  %o0, 0x170, %o0	! 40035970 <_CPU_Trap_slot_template+0x688><== NOT EXECUTED
            rc, strerror (rc));                                       
    rtems_rfs_fs_close (fs);                                          
40011940:	40 00 38 76 	call  4001fb18 <rtems_rfs_fs_close>            <== NOT EXECUTED
40011944:	d0 07 bf 28 	ld  [ %fp + -216 ], %o0                        <== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_write_root_dir (name);                               
  if (rc > 0)                                                         
  {                                                                   
    printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",   
40011948:	40 00 4d d7 	call  400250a4 <strerror>                      <== NOT EXECUTED
4001194c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40011950:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
40011954:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
            rc, strerror (rc));                                       
    return -1;                                                        
40011958:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_write_root_dir (name);                               
  if (rc > 0)                                                         
  {                                                                   
    printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",   
4001195c:	11 10 00 d6 	sethi  %hi(0x40035800), %o0                    <== NOT EXECUTED
40011960:	40 00 49 87 	call  40023f7c <printf>                        <== NOT EXECUTED
40011964:	90 12 22 e8 	or  %o0, 0x2e8, %o0	! 40035ae8 <_CPU_Trap_slot_template+0x800><== NOT EXECUTED
40011968:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001196c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
    rtems_rfs_fs_close (fs);                                          
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
40011970:	d0 07 bf 28 	ld  [ %fp + -216 ], %o0                        
40011974:	92 10 20 01 	mov  1, %o1                                    
40011978:	94 07 bf 54 	add  %fp, -172, %o2                            
4001197c:	40 00 02 a3 	call  40012408 <rtems_rfs_inode_open>          
40011980:	96 10 20 01 	mov  1, %o3                                    
  if (rc > 0)                                                         
40011984:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40011988:	24 80 00 19 	ble,a   400119ec <rtems_rfs_format+0xd74>      <== ALWAYS TAKEN
4001198c:	90 07 bf 54 	add  %fp, -172, %o0                            
  {                                                                   
    printf ("rtems-rfs: format: inode open failed: %d: %s\n",         
40011990:	40 00 4d c5 	call  400250a4 <strerror>                      <== NOT EXECUTED
40011994:	01 00 00 00 	nop                                            <== NOT EXECUTED
40011998:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
4001199c:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
400119a0:	11 10 00 d6 	sethi  %hi(0x40035800), %o0                    <== NOT EXECUTED
400119a4:	40 00 49 76 	call  40023f7c <printf>                        <== NOT EXECUTED
400119a8:	90 12 21 e0 	or  %o0, 0x1e0, %o0	! 400359e0 <_CPU_Trap_slot_template+0x6f8><== NOT EXECUTED
            rc, strerror (rc));                                       
    rtems_rfs_group_bitmap_free (fs, true, ino);                      
400119ac:	d0 07 bf 28 	ld  [ %fp + -216 ], %o0                        <== NOT EXECUTED
400119b0:	d4 07 bf 2c 	ld  [ %fp + -212 ], %o2                        <== NOT EXECUTED
400119b4:	40 00 01 a7 	call  40012050 <rtems_rfs_group_bitmap_free>   <== NOT EXECUTED
400119b8:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
    rtems_rfs_fs_close (fs);                                          
400119bc:	40 00 38 57 	call  4001fb18 <rtems_rfs_fs_close>            <== NOT EXECUTED
400119c0:	d0 07 bf 28 	ld  [ %fp + -216 ], %o0                        <== NOT EXECUTED
400119c4:	30 bf ff e1 	b,a   40011948 <rtems_rfs_format+0xcd0>        <== NOT EXECUTED
    printf ("\n");                                                    
                                                                      
  rc = rtems_rfs_buffer_close (&fs);                                  
  if (rc > 0)                                                         
  {                                                                   
    printf ("rtems-rfs: format: buffer close failed: %d: %s\n",       
400119c8:	40 00 4d b7 	call  400250a4 <strerror>                      <== NOT EXECUTED
400119cc:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
400119d0:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
400119d4:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
400119d8:	11 10 00 d6 	sethi  %hi(0x40035800), %o0                    <== NOT EXECUTED
400119dc:	40 00 49 68 	call  40023f7c <printf>                        <== NOT EXECUTED
400119e0:	90 12 21 08 	or  %o0, 0x108, %o0	! 40035908 <_CPU_Trap_slot_template+0x620><== NOT EXECUTED
400119e4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400119e8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    rtems_rfs_group_bitmap_free (fs, true, ino);                      
    rtems_rfs_fs_close (fs);                                          
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_initialise (&inode, 0,                         
400119ec:	92 10 20 00 	clr  %o1                                       
400119f0:	96 10 20 00 	clr  %o3                                       
400119f4:	15 00 00 10 	sethi  %hi(0x4000), %o2                        
400119f8:	98 10 20 00 	clr  %o4                                       
400119fc:	40 00 03 7f 	call  400127f8 <rtems_rfs_inode_initialise>    
40011a00:	94 12 a1 c9 	or  %o2, 0x1c9, %o2                            
                                   (RTEMS_RFS_S_IFDIR | RTEMS_RFS_S_IRWXU |
                                    RTEMS_RFS_S_IXGRP | RTEMS_RFS_S_IXOTH),
                                   0, 0);                             
  if (rc > 0)                                                         
40011a04:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40011a08:	24 80 00 0a 	ble,a   40011a30 <rtems_rfs_format+0xdb8>      <== ALWAYS TAKEN
40011a0c:	d0 07 bf 28 	ld  [ %fp + -216 ], %o0                        
    printf ("rtems-rfs: format: inode initialise failed: %d: %s\n",   
40011a10:	40 00 4d a5 	call  400250a4 <strerror>                      <== NOT EXECUTED
40011a14:	01 00 00 00 	nop                                            <== NOT EXECUTED
40011a18:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
40011a1c:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40011a20:	11 10 00 d6 	sethi  %hi(0x40035800), %o0                    <== NOT EXECUTED
40011a24:	40 00 49 56 	call  40023f7c <printf>                        <== NOT EXECUTED
40011a28:	90 12 22 10 	or  %o0, 0x210, %o0	! 40035a10 <_CPU_Trap_slot_template+0x728><== NOT EXECUTED
            rc, strerror (rc));                                       
                                                                      
  rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, ino);             
40011a2c:	d0 07 bf 28 	ld  [ %fp + -216 ], %o0                        <== NOT EXECUTED
40011a30:	d8 07 bf 2c 	ld  [ %fp + -212 ], %o4                        
40011a34:	92 07 bf 54 	add  %fp, -172, %o1                            
40011a38:	96 10 20 01 	mov  1, %o3                                    
40011a3c:	15 10 00 cf 	sethi  %hi(0x40033c00), %o2                    
40011a40:	40 00 2e 39 	call  4001d324 <rtems_rfs_dir_add_entry>       
40011a44:	94 12 a0 10 	or  %o2, 0x10, %o2	! 40033c10 <flashdisk_ops+0x1c>
  if (rc > 0)                                                         
40011a48:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40011a4c:	24 80 00 0a 	ble,a   40011a74 <rtems_rfs_format+0xdfc>      <== ALWAYS TAKEN
40011a50:	d0 07 bf 28 	ld  [ %fp + -216 ], %o0                        
    printf ("rtems-rfs: format: directory add failed: %d: %s\n",      
40011a54:	40 00 4d 94 	call  400250a4 <strerror>                      <== NOT EXECUTED
40011a58:	01 00 00 00 	nop                                            <== NOT EXECUTED
40011a5c:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
40011a60:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40011a64:	11 10 00 d6 	sethi  %hi(0x40035800), %o0                    <== NOT EXECUTED
40011a68:	40 00 49 45 	call  40023f7c <printf>                        <== NOT EXECUTED
40011a6c:	90 12 22 48 	or  %o0, 0x248, %o0	! 40035a48 <_CPU_Trap_slot_template+0x760><== NOT EXECUTED
            rc, strerror (rc));                                       
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
40011a70:	d0 07 bf 28 	ld  [ %fp + -216 ], %o0                        <== NOT EXECUTED
40011a74:	40 00 02 dd 	call  400125e8 <rtems_rfs_inode_close>         
40011a78:	92 07 bf 54 	add  %fp, -172, %o1                            
  if (rc > 0)                                                         
40011a7c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40011a80:	04 80 00 09 	ble  40011aa4 <rtems_rfs_format+0xe2c>         <== ALWAYS TAKEN
40011a84:	01 00 00 00 	nop                                            
    printf ("rtems-rfs: format: inode close failed: %d: %s\n",        
40011a88:	40 00 4d 87 	call  400250a4 <strerror>                      <== NOT EXECUTED
40011a8c:	01 00 00 00 	nop                                            <== NOT EXECUTED
40011a90:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
40011a94:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40011a98:	11 10 00 d6 	sethi  %hi(0x40035800), %o0                    <== NOT EXECUTED
40011a9c:	40 00 49 38 	call  40023f7c <printf>                        <== NOT EXECUTED
40011aa0:	90 12 22 80 	or  %o0, 0x280, %o0	! 40035a80 <_CPU_Trap_slot_template+0x798><== NOT EXECUTED
            rc, strerror (rc));                                       
                                                                      
  rc = rtems_rfs_fs_close (fs);                                       
40011aa4:	40 00 38 1d 	call  4001fb18 <rtems_rfs_fs_close>            
40011aa8:	d0 07 bf 28 	ld  [ %fp + -216 ], %o0                        
  if (rc < 0)                                                         
40011aac:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40011ab0:	06 80 00 12 	bl  40011af8 <rtems_rfs_format+0xe80>          <== NEVER TAKEN
40011ab4:	80 a7 60 00 	cmp  %i5, 0                                    
            rc, strerror (rc));                                       
    return -1;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_write_root_dir (name);                               
  if (rc > 0)                                                         
40011ab8:	12 bf ff a4 	bne  40011948 <rtems_rfs_format+0xcd0>         <== NEVER TAKEN
40011abc:	b0 10 20 00 	clr  %i0                                       
            rc, strerror (rc));                                       
    return -1;                                                        
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
40011ac0:	81 c7 e0 08 	ret                                            
40011ac4:	81 e8 00 00 	restore                                        
                          RTEMS_RFS_FS_FORCE_OPEN | RTEMS_RFS_FS_NO_LOCAL_CACHE,
                          0, &fs);                                    
  if (rc < 0)                                                         
  {                                                                   
    printf ("rtems-rfs: format: file system open failed: %d: %s\n",   
            errno, strerror (errno));                                 
40011ac8:	40 00 43 9c 	call  40022938 <__errno>                       <== NOT EXECUTED
40011acc:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
40011ad0:	40 00 43 9a 	call  40022938 <__errno>                       <== NOT EXECUTED
40011ad4:	fa 02 00 00 	ld  [ %o0 ], %i5                               <== NOT EXECUTED
  rc = rtems_rfs_fs_open (name, NULL,                                 
                          RTEMS_RFS_FS_FORCE_OPEN | RTEMS_RFS_FS_NO_LOCAL_CACHE,
                          0, &fs);                                    
  if (rc < 0)                                                         
  {                                                                   
    printf ("rtems-rfs: format: file system open failed: %d: %s\n",   
40011ad8:	40 00 4d 73 	call  400250a4 <strerror>                      <== NOT EXECUTED
40011adc:	d0 02 00 00 	ld  [ %o0 ], %o0                               <== NOT EXECUTED
40011ae0:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
40011ae4:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40011ae8:	11 10 00 d6 	sethi  %hi(0x40035800), %o0                    <== NOT EXECUTED
40011aec:	40 00 49 24 	call  40023f7c <printf>                        <== NOT EXECUTED
40011af0:	90 12 21 38 	or  %o0, 0x138, %o0	! 40035938 <_CPU_Trap_slot_template+0x650><== NOT EXECUTED
40011af4:	30 bf ff f3 	b,a   40011ac0 <rtems_rfs_format+0xe48>        <== NOT EXECUTED
            rc, strerror (rc));                                       
                                                                      
  rc = rtems_rfs_fs_close (fs);                                       
  if (rc < 0)                                                         
    printf ("rtems-rfs: format: file system close failed: %d: %s\n",  
            errno, strerror (errno));                                 
40011af8:	40 00 43 90 	call  40022938 <__errno>                       <== NOT EXECUTED
40011afc:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
40011b00:	40 00 43 8e 	call  40022938 <__errno>                       <== NOT EXECUTED
40011b04:	fa 02 00 00 	ld  [ %o0 ], %i5                               <== NOT EXECUTED
    printf ("rtems-rfs: format: inode close failed: %d: %s\n",        
            rc, strerror (rc));                                       
                                                                      
  rc = rtems_rfs_fs_close (fs);                                       
  if (rc < 0)                                                         
    printf ("rtems-rfs: format: file system close failed: %d: %s\n",  
40011b08:	40 00 4d 67 	call  400250a4 <strerror>                      <== NOT EXECUTED
40011b0c:	d0 02 00 00 	ld  [ %o0 ], %o0                               <== NOT EXECUTED
40011b10:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
40011b14:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40011b18:	11 10 00 d6 	sethi  %hi(0x40035800), %o0                    <== NOT EXECUTED
40011b1c:	40 00 49 18 	call  40023f7c <printf>                        <== NOT EXECUTED
40011b20:	90 12 22 b0 	or  %o0, 0x2b0, %o0	! 40035ab0 <_CPU_Trap_slot_template+0x7c8><== NOT EXECUTED
40011b24:	30 bf ff e7 	b,a   40011ac0 <rtems_rfs_format+0xe48>        <== NOT EXECUTED
40011b28:	c2 07 bf 8c 	ld  [ %fp + -116 ], %g1                        <== NOT EXECUTED
40011b2c:	10 bf fc 7e 	b  40010d24 <rtems_rfs_format+0xac>            <== NOT EXECUTED
40011b30:	f8 00 60 20 	ld  [ %g1 + 0x20 ], %i4                        <== NOT EXECUTED
                                                                      

4001fb18 <rtems_rfs_fs_close>: return 0; } int rtems_rfs_fs_close (rtems_rfs_file_system* fs) {
4001fb18:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int group;                                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))                        
4001fb1c:	90 10 20 00 	clr  %o0                                       
4001fb20:	7f ff d0 e1 	call  40013ea4 <rtems_rfs_trace>               
4001fb24:	92 10 20 02 	mov  2, %o1                                    
4001fb28:	80 8a 20 ff 	btst  0xff, %o0                                
4001fb2c:	12 80 00 17 	bne  4001fb88 <rtems_rfs_fs_close+0x70>        <== NEVER TAKEN
4001fb30:	11 10 00 df 	sethi  %hi(0x40037c00), %o0                    
    printf ("rtems-rfs: close\n");                                    
                                                                      
  for (group = 0; group < fs->group_count; group++)                   
4001fb34:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
4001fb38:	b8 10 20 00 	clr  %i4                                       
4001fb3c:	80 a0 60 00 	cmp  %g1, 0                                    
4001fb40:	04 80 00 0b 	ble  4001fb6c <rtems_rfs_fs_close+0x54>        <== NEVER TAKEN
4001fb44:	ba 10 20 00 	clr  %i5                                       
    rtems_rfs_group_close (fs, &fs->groups[group]);                   
4001fb48:	d2 06 20 20 	ld  [ %i0 + 0x20 ], %o1                        
4001fb4c:	90 10 00 18 	mov  %i0, %o0                                  
4001fb50:	7f ff c8 86 	call  40011d68 <rtems_rfs_group_close>         
4001fb54:	92 02 40 1c 	add  %o1, %i4, %o1                             
  int group;                                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))                        
    printf ("rtems-rfs: close\n");                                    
                                                                      
  for (group = 0; group < fs->group_count; group++)                   
4001fb58:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
4001fb5c:	ba 07 60 01 	inc  %i5                                       
4001fb60:	80 a0 40 1d 	cmp  %g1, %i5                                  
4001fb64:	14 bf ff f9 	bg  4001fb48 <rtems_rfs_fs_close+0x30>         <== NEVER TAKEN
4001fb68:	b8 07 20 50 	add  %i4, 0x50, %i4                            
    rtems_rfs_group_close (fs, &fs->groups[group]);                   
                                                                      
  rtems_rfs_buffer_close (fs);                                        
4001fb6c:	7f ff f4 61 	call  4001ccf0 <rtems_rfs_buffer_close>        
4001fb70:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
  free (fs);                                                          
4001fb74:	90 10 00 18 	mov  %i0, %o0                                  
4001fb78:	7f ff a0 f4 	call  40007f48 <free>                          
4001fb7c:	b0 10 20 00 	clr  %i0                                       
  return 0;                                                           
}                                                                     
4001fb80:	81 c7 e0 08 	ret                                            
4001fb84:	81 e8 00 00 	restore                                        
rtems_rfs_fs_close (rtems_rfs_file_system* fs)                        
{                                                                     
  int group;                                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))                        
    printf ("rtems-rfs: close\n");                                    
4001fb88:	40 00 11 95 	call  400241dc <puts>                          <== NOT EXECUTED
4001fb8c:	90 12 23 e0 	or  %o0, 0x3e0, %o0                            <== NOT EXECUTED
                                                                      
  for (group = 0; group < fs->group_count; group++)                   
4001fb90:	10 bf ff ea 	b  4001fb38 <rtems_rfs_fs_close+0x20>          <== NOT EXECUTED
4001fb94:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        <== NOT EXECUTED
                                                                      

4001f268 <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) {
4001f268:	9d e3 bf 68 	save  %sp, -152, %sp                           
#endif                                                                
  rtems_rfs_inode_handle inode;                                       
  uint16_t               mode;                                        
  int                    rc;                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                         
4001f26c:	90 10 20 00 	clr  %o0                                       
4001f270:	7f ff d3 0d 	call  40013ea4 <rtems_rfs_trace>               
4001f274:	92 10 20 01 	mov  1, %o1                                    
4001f278:	80 8a 20 ff 	btst  0xff, %o0                                
4001f27c:	12 80 00 82 	bne  4001f484 <rtems_rfs_fs_open+0x21c>        <== NEVER TAKEN
4001f280:	92 10 00 18 	mov  %i0, %o1                                  
    printf ("rtems-rfs: open: %s\n", name);                           
                                                                      
  *fs = malloc (sizeof (rtems_rfs_file_system));                      
4001f284:	7f ff a4 ce 	call  400085bc <malloc>                        
4001f288:	90 10 20 84 	mov  0x84, %o0                                 
  if (!*fs)                                                           
4001f28c:	80 a2 20 00 	cmp  %o0, 0                                    
4001f290:	02 80 01 68 	be  4001f830 <rtems_rfs_fs_open+0x5c8>         <== NEVER TAKEN
4001f294:	d0 27 00 00 	st  %o0, [ %i4 ]                               
      printf ("rtems-rfs: open: no memory for file system data\n");   
    errno = ENOMEM;                                                   
    return -1;                                                        
  }                                                                   
                                                                      
  memset (*fs, 0, sizeof (rtems_rfs_file_system));                    
4001f298:	92 10 20 00 	clr  %o1                                       
4001f29c:	40 00 12 ba 	call  40023d84 <memset>                        
4001f2a0:	94 10 20 84 	mov  0x84, %o2                                 
                                                                      
  (*fs)->user = user;                                                 
4001f2a4:	c2 07 00 00 	ld  [ %i4 ], %g1                               
#endif                                                                
                                                                      
  /*                                                                  
   * Open the buffer interface.                                       
   */                                                                 
  rc = rtems_rfs_buffer_open (name, *fs);                             
4001f2a8:	90 10 00 18 	mov  %i0, %o0                                  
    return -1;                                                        
  }                                                                   
                                                                      
  memset (*fs, 0, sizeof (rtems_rfs_file_system));                    
                                                                      
  (*fs)->user = user;                                                 
4001f2ac:	f2 20 60 80 	st  %i1, [ %g1 + 0x80 ]                        
  rtems_chain_initialize_empty (&(*fs)->buffers);                     
4001f2b0:	c2 07 00 00 	ld  [ %i4 ], %g1                               
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
4001f2b4:	c0 20 60 48 	clr  [ %g1 + 0x48 ]                            
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
4001f2b8:	86 00 60 44 	add  %g1, 0x44, %g3                            
4001f2bc:	84 00 60 48 	add  %g1, 0x48, %g2                            
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
  tail->previous = head;                                              
4001f2c0:	c6 20 60 4c 	st  %g3, [ %g1 + 0x4c ]                        
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
4001f2c4:	c4 20 60 44 	st  %g2, [ %g1 + 0x44 ]                        
  rtems_chain_initialize_empty (&(*fs)->release);                     
4001f2c8:	c2 07 00 00 	ld  [ %i4 ], %g1                               
  head->previous = NULL;                                              
4001f2cc:	c0 20 60 58 	clr  [ %g1 + 0x58 ]                            
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
4001f2d0:	86 00 60 54 	add  %g1, 0x54, %g3                            
4001f2d4:	84 00 60 58 	add  %g1, 0x58, %g2                            
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
  tail->previous = head;                                              
4001f2d8:	c6 20 60 5c 	st  %g3, [ %g1 + 0x5c ]                        
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
4001f2dc:	c4 20 60 54 	st  %g2, [ %g1 + 0x54 ]                        
  rtems_chain_initialize_empty (&(*fs)->release_modified);            
4001f2e0:	c2 07 00 00 	ld  [ %i4 ], %g1                               
  head->previous = NULL;                                              
4001f2e4:	c0 20 60 68 	clr  [ %g1 + 0x68 ]                            
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
4001f2e8:	86 00 60 64 	add  %g1, 0x64, %g3                            
4001f2ec:	84 00 60 68 	add  %g1, 0x68, %g2                            
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
  tail->previous = head;                                              
4001f2f0:	c6 20 60 6c 	st  %g3, [ %g1 + 0x6c ]                        
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
4001f2f4:	c4 20 60 64 	st  %g2, [ %g1 + 0x64 ]                        
  rtems_chain_initialize_empty (&(*fs)->file_shares);                 
4001f2f8:	c2 07 00 00 	ld  [ %i4 ], %g1                               
  head->previous = NULL;                                              
4001f2fc:	c0 20 60 78 	clr  [ %g1 + 0x78 ]                            
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
4001f300:	86 00 60 74 	add  %g1, 0x74, %g3                            
4001f304:	84 00 60 78 	add  %g1, 0x78, %g2                            
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
  tail->previous = head;                                              
4001f308:	c6 20 60 7c 	st  %g3, [ %g1 + 0x7c ]                        
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
4001f30c:	c4 20 60 74 	st  %g2, [ %g1 + 0x74 ]                        
                                                                      
  (*fs)->max_held_buffers = max_held_buffers;                         
4001f310:	d2 07 00 00 	ld  [ %i4 ], %o1                               
4001f314:	f6 22 60 40 	st  %i3, [ %o1 + 0x40 ]                        
  (*fs)->buffers_count = 0;                                           
4001f318:	c0 22 60 50 	clr  [ %o1 + 0x50 ]                            
  (*fs)->release_count = 0;                                           
4001f31c:	c0 22 60 60 	clr  [ %o1 + 0x60 ]                            
  (*fs)->release_modified_count = 0;                                  
4001f320:	c0 22 60 70 	clr  [ %o1 + 0x70 ]                            
#endif                                                                
                                                                      
  /*                                                                  
   * Open the buffer interface.                                       
   */                                                                 
  rc = rtems_rfs_buffer_open (name, *fs);                             
4001f324:	7f ff f5 77 	call  4001c900 <rtems_rfs_buffer_open>         
4001f328:	f4 22 40 00 	st  %i2, [ %o1 ]                               
  if (rc > 0)                                                         
4001f32c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001f330:	14 80 00 a9 	bg  4001f5d4 <rtems_rfs_fs_open+0x36c>         <== NEVER TAKEN
4001f334:	94 10 20 00 	clr  %o2                                       
              rc, strerror (rc));                                     
    errno = rc;                                                       
    return -1;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_fs_read_superblock (*fs);                            
4001f338:	f6 07 00 00 	ld  [ %i4 ], %i3                               
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
4001f33c:	c0 2f bf cc 	clrb  [ %fp + -52 ]                            
  handle->bnum  = 0;                                                  
4001f340:	c0 27 bf d0 	clr  [ %fp + -48 ]                             
  handle->buffer = NULL;                                              
4001f344:	c0 27 bf d4 	clr  [ %fp + -44 ]                             
      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);        
4001f348:	90 10 00 1b 	mov  %i3, %o0                                  
4001f34c:	92 07 bf cc 	add  %fp, -52, %o1                             
4001f350:	7f ff f4 b4 	call  4001c620 <rtems_rfs_buffer_handle_request>
4001f354:	96 10 20 01 	mov  1, %o3                                    
  if (rc > 0)                                                         
4001f358:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001f35c:	04 80 00 1d 	ble  4001f3d0 <rtems_rfs_fs_open+0x168>        <== ALWAYS TAKEN
4001f360:	90 10 20 00 	clr  %o0                                       
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
4001f364:	7f ff d2 d0 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001f368:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
4001f36c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001f370:	02 80 00 09 	be  4001f394 <rtems_rfs_fs_open+0x12c>         <== NOT EXECUTED
4001f374:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: read-superblock: request failed%d: %s\n",   
4001f378:	40 00 17 4b 	call  400250a4 <strerror>                      <== NOT EXECUTED
4001f37c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001f380:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
4001f384:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
4001f388:	11 10 00 df 	sethi  %hi(0x40037c00), %o0                    <== NOT EXECUTED
4001f38c:	40 00 12 fc 	call  40023f7c <printf>                        <== NOT EXECUTED
4001f390:	90 12 21 18 	or  %o0, 0x118, %o0	! 40037d18 <CSWTCH.2+0x1128><== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_fs_read_superblock (*fs);                            
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_buffer_close (*fs);                                     
4001f394:	7f ff f6 57 	call  4001ccf0 <rtems_rfs_buffer_close>        <== NOT EXECUTED
4001f398:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
    free (*fs);                                                       
4001f39c:	7f ff a2 eb 	call  40007f48 <free>                          <== NOT EXECUTED
4001f3a0:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
4001f3a4:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001f3a8:	7f ff d2 bf 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001f3ac:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
4001f3b0:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001f3b4:	12 80 00 2c 	bne  4001f464 <rtems_rfs_fs_open+0x1fc>        <== NOT EXECUTED
4001f3b8:	01 00 00 00 	nop                                            <== NOT EXECUTED
  {                                                                   
    rtems_rfs_buffer_close (*fs);                                     
    free (*fs);                                                       
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
      printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
    errno = rc;                                                       
4001f3bc:	40 00 0d 5f 	call  40022938 <__errno>                       <== NOT EXECUTED
4001f3c0:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <LEON_REG+0x7fffffff>  <== NOT EXECUTED
4001f3c4:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
4001f3c8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001f3cc:	81 e8 00 00 	restore                                        <== NOT EXECUTED
      printf ("rtems-rfs: read-superblock: request failed%d: %s\n",   
              rc, strerror (rc));                                     
    return rc;                                                        
  }                                                                   
                                                                      
  sb = rtems_rfs_buffer_data (&handle);                               
4001f3d0:	c2 07 bf d4 	ld  [ %fp + -44 ], %g1                         
4001f3d4:	fa 00 60 1c 	ld  [ %g1 + 0x1c ], %i5                        
                                                                      
#define read_sb(_o) rtems_rfs_read_u32 (sb + (_o))                    
                                                                      
  if (read_sb (RTEMS_RFS_SB_OFFSET_MAGIC) != RTEMS_RFS_SB_MAGIC)      
4001f3d8:	c2 0f 60 02 	ldub  [ %i5 + 2 ], %g1                         
4001f3dc:	c4 0f 40 00 	ldub  [ %i5 ], %g2                             
4001f3e0:	c8 0f 60 01 	ldub  [ %i5 + 1 ], %g4                         
4001f3e4:	c6 0f 60 03 	ldub  [ %i5 + 3 ], %g3                         
4001f3e8:	83 28 60 08 	sll  %g1, 8, %g1                               
4001f3ec:	85 28 a0 18 	sll  %g2, 0x18, %g2                            
4001f3f0:	89 29 20 10 	sll  %g4, 0x10, %g4                            
4001f3f4:	84 10 80 04 	or  %g2, %g4, %g2                              
4001f3f8:	84 10 80 03 	or  %g2, %g3, %g2                              
4001f3fc:	84 10 80 01 	or  %g2, %g1, %g2                              
4001f400:	03 0a 02 48 	sethi  %hi(0x28092000), %g1                    
4001f404:	82 10 60 01 	or  %g1, 1, %g1	! 28092001 <RAM_SIZE+0x27c92001>
4001f408:	80 a0 80 01 	cmp  %g2, %g1                                  
4001f40c:	22 80 00 29 	be,a   4001f4b0 <rtems_rfs_fs_open+0x248>      <== ALWAYS TAKEN
4001f410:	c6 0f 60 0d 	ldub  [ %i5 + 0xd ], %g3                       
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
4001f414:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001f418:	7f ff d2 a3 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001f41c:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
4001f420:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001f424:	32 80 00 1c 	bne,a   4001f494 <rtems_rfs_fs_open+0x22c>     <== NOT EXECUTED
4001f428:	11 10 00 df 	sethi  %hi(0x40037c00), %o0                    <== 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);                       
4001f42c:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
4001f430:	92 07 bf cc 	add  %fp, -52, %o1                             <== NOT EXECUTED
4001f434:	7f ff f4 01 	call  4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001f438:	ba 10 20 05 	mov  5, %i5                                    <== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_fs_read_superblock (*fs);                            
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_buffer_close (*fs);                                     
4001f43c:	7f ff f6 2d 	call  4001ccf0 <rtems_rfs_buffer_close>        <== NOT EXECUTED
4001f440:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
    free (*fs);                                                       
4001f444:	7f ff a2 c1 	call  40007f48 <free>                          <== NOT EXECUTED
4001f448:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
4001f44c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001f450:	7f ff d2 95 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001f454:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
4001f458:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001f45c:	02 bf ff d8 	be  4001f3bc <rtems_rfs_fs_open+0x154>         <== NOT EXECUTED
4001f460:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: open: reading superblock: %d: %s\n",        
4001f464:	40 00 17 10 	call  400250a4 <strerror>                      <== NOT EXECUTED
4001f468:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001f46c:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
4001f470:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
4001f474:	11 10 00 df 	sethi  %hi(0x40037c00), %o0                    <== NOT EXECUTED
4001f478:	40 00 12 c1 	call  40023f7c <printf>                        <== NOT EXECUTED
4001f47c:	90 12 23 20 	or  %o0, 0x320, %o0	! 40037f20 <CSWTCH.2+0x1330><== NOT EXECUTED
4001f480:	30 bf ff cf 	b,a   4001f3bc <rtems_rfs_fs_open+0x154>       <== NOT EXECUTED
  rtems_rfs_inode_handle inode;                                       
  uint16_t               mode;                                        
  int                    rc;                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                         
    printf ("rtems-rfs: open: %s\n", name);                           
4001f484:	11 10 00 df 	sethi  %hi(0x40037c00), %o0                    <== NOT EXECUTED
4001f488:	40 00 12 bd 	call  40023f7c <printf>                        <== NOT EXECUTED
4001f48c:	90 12 20 a0 	or  %o0, 0xa0, %o0	! 40037ca0 <CSWTCH.2+0x10b0><== NOT EXECUTED
4001f490:	30 bf ff 7d 	b,a   4001f284 <rtems_rfs_fs_open+0x1c>        <== NOT EXECUTED
#define read_sb(_o) rtems_rfs_read_u32 (sb + (_o))                    
                                                                      
  if (read_sb (RTEMS_RFS_SB_OFFSET_MAGIC) != RTEMS_RFS_SB_MAGIC)      
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
      printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
4001f494:	40 00 13 52 	call  400241dc <puts>                          <== NOT EXECUTED
4001f498:	90 12 21 50 	or  %o0, 0x150, %o0                            <== NOT EXECUTED
4001f49c:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
4001f4a0:	92 07 bf cc 	add  %fp, -52, %o1                             <== NOT EXECUTED
4001f4a4:	7f ff f3 e5 	call  4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001f4a8:	ba 10 20 05 	mov  5, %i5                                    <== NOT EXECUTED
4001f4ac:	30 bf ff e4 	b,a   4001f43c <rtems_rfs_fs_open+0x1d4>       <== NOT EXECUTED
    rtems_rfs_buffer_handle_close (fs, &handle);                      
    return EIO;                                                       
  }                                                                   
                                                                      
  fs->blocks     = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);              
4001f4b0:	c2 0f 60 0e 	ldub  [ %i5 + 0xe ], %g1                       
4001f4b4:	c4 0f 60 0f 	ldub  [ %i5 + 0xf ], %g2                       
4001f4b8:	d6 0f 60 0c 	ldub  [ %i5 + 0xc ], %o3                       
4001f4bc:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
4001f4c0:	83 28 60 08 	sll  %g1, 8, %g1                               
4001f4c4:	97 2a e0 18 	sll  %o3, 0x18, %o3                            
4001f4c8:	96 12 c0 03 	or  %o3, %g3, %o3                              
4001f4cc:	96 12 c0 02 	or  %o3, %g2, %o3                              
4001f4d0:	96 12 c0 01 	or  %o3, %g1, %o3                              
4001f4d4:	d6 26 e0 04 	st  %o3, [ %i3 + 4 ]                           
  fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);          
4001f4d8:	c6 0f 60 09 	ldub  [ %i5 + 9 ], %g3                         
4001f4dc:	c2 0f 60 0a 	ldub  [ %i5 + 0xa ], %g1                       
4001f4e0:	c4 0f 60 0b 	ldub  [ %i5 + 0xb ], %g2                       
4001f4e4:	f4 0f 60 08 	ldub  [ %i5 + 8 ], %i2                         
4001f4e8:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
4001f4ec:	83 28 60 08 	sll  %g1, 8, %g1                               
}                                                                     
                                                                      
uint64_t                                                              
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)                   
{                                                                     
  uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);  
4001f4f0:	f2 06 e0 10 	ld  [ %i3 + 0x10 ], %i1                        
uint64_t                                                              
rtems_rfs_fs_size (rtems_rfs_file_system* fs)                         
{                                                                     
  uint64_t blocks = rtems_rfs_fs_blocks (fs);                         
  uint64_t block_size = rtems_rfs_fs_block_size (fs);                 
  return blocks * block_size;                                         
4001f4f4:	94 10 20 00 	clr  %o2                                       
    rtems_rfs_buffer_handle_close (fs, &handle);                      
    return EIO;                                                       
  }                                                                   
                                                                      
  fs->blocks     = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);              
  fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);          
4001f4f8:	b5 2e a0 18 	sll  %i2, 0x18, %i2                            
uint64_t                                                              
rtems_rfs_fs_size (rtems_rfs_file_system* fs)                         
{                                                                     
  uint64_t blocks = rtems_rfs_fs_blocks (fs);                         
  uint64_t block_size = rtems_rfs_fs_block_size (fs);                 
  return blocks * block_size;                                         
4001f4fc:	90 10 20 00 	clr  %o0                                       
    rtems_rfs_buffer_handle_close (fs, &handle);                      
    return EIO;                                                       
  }                                                                   
                                                                      
  fs->blocks     = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);              
  fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);          
4001f500:	b4 16 80 03 	or  %i2, %g3, %i2                              
4001f504:	b4 16 80 02 	or  %i2, %g2, %i2                              
4001f508:	b4 16 80 01 	or  %i2, %g1, %i2                              
4001f50c:	f4 26 e0 08 	st  %i2, [ %i3 + 8 ]                           
uint64_t                                                              
rtems_rfs_fs_size (rtems_rfs_file_system* fs)                         
{                                                                     
  uint64_t blocks = rtems_rfs_fs_blocks (fs);                         
  uint64_t block_size = rtems_rfs_fs_block_size (fs);                 
  return blocks * block_size;                                         
4001f510:	40 00 44 dd 	call  40030884 <__muldi3>                      
4001f514:	92 10 00 1a 	mov  %i2, %o1                                  
uint64_t                                                              
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)                   
{                                                                     
  uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);  
  uint64_t media_block_size = (uint64_t) rtems_rfs_fs_media_block_size (fs);
  return media_blocks * media_block_size;                             
4001f518:	d6 06 60 1c 	ld  [ %i1 + 0x1c ], %o3                        
uint64_t                                                              
rtems_rfs_fs_size (rtems_rfs_file_system* fs)                         
{                                                                     
  uint64_t blocks = rtems_rfs_fs_blocks (fs);                         
  uint64_t block_size = rtems_rfs_fs_block_size (fs);                 
  return blocks * block_size;                                         
4001f51c:	a0 10 00 09 	mov  %o1, %l0                                  
uint64_t                                                              
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)                   
{                                                                     
  uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);  
  uint64_t media_block_size = (uint64_t) rtems_rfs_fs_media_block_size (fs);
  return media_blocks * media_block_size;                             
4001f520:	d2 06 60 20 	ld  [ %i1 + 0x20 ], %o1                        
uint64_t                                                              
rtems_rfs_fs_size (rtems_rfs_file_system* fs)                         
{                                                                     
  uint64_t blocks = rtems_rfs_fs_blocks (fs);                         
  uint64_t block_size = rtems_rfs_fs_block_size (fs);                 
  return blocks * block_size;                                         
4001f524:	b0 10 00 08 	mov  %o0, %i0                                  
uint64_t                                                              
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)                   
{                                                                     
  uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);  
  uint64_t media_block_size = (uint64_t) rtems_rfs_fs_media_block_size (fs);
  return media_blocks * media_block_size;                             
4001f528:	94 10 20 00 	clr  %o2                                       
4001f52c:	40 00 44 d6 	call  40030884 <__muldi3>                      
4001f530:	90 10 20 00 	clr  %o0                                       
  }                                                                   
                                                                      
  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))           
4001f534:	80 a6 00 08 	cmp  %i0, %o0                                  
4001f538:	38 80 00 3a 	bgu,a   4001f620 <rtems_rfs_fs_open+0x3b8>     <== NEVER TAKEN
4001f53c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001f540:	02 80 00 35 	be  4001f614 <rtems_rfs_fs_open+0x3ac>         <== ALWAYS TAKEN
4001f544:	80 a4 00 09 	cmp  %l0, %o1                                  
              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)
4001f548:	c2 0f 60 24 	ldub  [ %i5 + 0x24 ], %g1                      <== NOT EXECUTED
4001f54c:	c8 0f 60 25 	ldub  [ %i5 + 0x25 ], %g4                      
4001f550:	c6 0f 60 27 	ldub  [ %i5 + 0x27 ], %g3                      
4001f554:	c4 0f 60 26 	ldub  [ %i5 + 0x26 ], %g2                      
4001f558:	83 28 60 18 	sll  %g1, 0x18, %g1                            
4001f55c:	89 29 20 10 	sll  %g4, 0x10, %g4                            
4001f560:	85 28 a0 08 	sll  %g2, 8, %g2                               
4001f564:	82 10 40 04 	or  %g1, %g4, %g1                              
4001f568:	82 10 40 03 	or  %g1, %g3, %g1                              
4001f56c:	82 10 40 02 	or  %g1, %g2, %g1                              
4001f570:	80 a0 60 38 	cmp  %g1, 0x38                                 
4001f574:	22 80 00 35 	be,a   4001f648 <rtems_rfs_fs_open+0x3e0>      <== ALWAYS TAKEN
4001f578:	c6 0f 60 13 	ldub  [ %i5 + 0x13 ], %g3                      
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
4001f57c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001f580:	7f ff d2 49 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001f584:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
4001f588:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001f58c:	22 bf ff a9 	be,a   4001f430 <rtems_rfs_fs_open+0x1c8>      <== NOT EXECUTED
4001f590:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
      printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%" PRId32 " target:%" PRId32 "\n",
              read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
4001f594:	c6 0f 60 05 	ldub  [ %i5 + 5 ], %g3                         <== NOT EXECUTED
4001f598:	c2 0f 60 06 	ldub  [ %i5 + 6 ], %g1                         <== NOT EXECUTED
4001f59c:	d2 0f 60 04 	ldub  [ %i5 + 4 ], %o1                         <== NOT EXECUTED
4001f5a0:	c4 0f 60 07 	ldub  [ %i5 + 7 ], %g2                         <== NOT EXECUTED
4001f5a4:	87 28 e0 10 	sll  %g3, 0x10, %g3                            <== NOT EXECUTED
4001f5a8:	83 28 60 08 	sll  %g1, 8, %g1                               <== NOT EXECUTED
4001f5ac:	93 2a 60 18 	sll  %o1, 0x18, %o1                            <== NOT EXECUTED
  }                                                                   
                                                                      
  if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
      printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%" PRId32 " target:%" PRId32 "\n",
4001f5b0:	11 10 00 df 	sethi  %hi(0x40037c00), %o0                    <== NOT EXECUTED
              read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
4001f5b4:	92 12 40 03 	or  %o1, %g3, %o1                              <== NOT EXECUTED
  }                                                                   
                                                                      
  if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
      printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%" PRId32 " target:%" PRId32 "\n",
4001f5b8:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
              read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
4001f5bc:	92 12 40 02 	or  %o1, %g2, %o1                              <== NOT EXECUTED
  }                                                                   
                                                                      
  if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
      printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%" PRId32 " target:%" PRId32 "\n",
4001f5c0:	90 12 21 d0 	or  %o0, 0x1d0, %o0                            <== NOT EXECUTED
4001f5c4:	40 00 12 6e 	call  40023f7c <printf>                        <== NOT EXECUTED
4001f5c8:	92 12 40 01 	or  %o1, %g1, %o1                              <== NOT EXECUTED
4001f5cc:	10 bf ff 99 	b  4001f430 <rtems_rfs_fs_open+0x1c8>          <== NOT EXECUTED
4001f5d0:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
   * Open the buffer interface.                                       
   */                                                                 
  rc = rtems_rfs_buffer_open (name, *fs);                             
  if (rc > 0)                                                         
  {                                                                   
    free (*fs);                                                       
4001f5d4:	7f ff a2 5d 	call  40007f48 <free>                          <== NOT EXECUTED
4001f5d8:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
4001f5dc:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001f5e0:	7f ff d2 31 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001f5e4:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
4001f5e8:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001f5ec:	02 bf ff 74 	be  4001f3bc <rtems_rfs_fs_open+0x154>         <== NOT EXECUTED
4001f5f0:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: open: buffer open failed: %d: %s\n",        
4001f5f4:	40 00 16 ac 	call  400250a4 <strerror>                      <== NOT EXECUTED
4001f5f8:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001f5fc:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
4001f600:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
4001f604:	11 10 00 df 	sethi  %hi(0x40037c00), %o0                    <== NOT EXECUTED
4001f608:	40 00 12 5d 	call  40023f7c <printf>                        <== NOT EXECUTED
4001f60c:	90 12 20 e8 	or  %o0, 0xe8, %o0	! 40037ce8 <CSWTCH.2+0x10f8><== NOT EXECUTED
4001f610:	30 bf ff 6b 	b,a   4001f3bc <rtems_rfs_fs_open+0x154>       <== 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))           
4001f614:	28 bf ff ce 	bleu,a   4001f54c <rtems_rfs_fs_open+0x2e4>    <== ALWAYS TAKEN
4001f618:	c2 0f 60 24 	ldub  [ %i5 + 0x24 ], %g1                      
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
4001f61c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001f620:	7f ff d2 21 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001f624:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
4001f628:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001f62c:	22 bf ff 81 	be,a   4001f430 <rtems_rfs_fs_open+0x1c8>      <== NOT EXECUTED
4001f630:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
      printf ("rtems-rfs: read-superblock: invalid superblock block/size count\n");
4001f634:	11 10 00 df 	sethi  %hi(0x40037c00), %o0                    <== NOT EXECUTED
4001f638:	40 00 12 e9 	call  400241dc <puts>                          <== NOT EXECUTED
4001f63c:	90 12 21 90 	or  %o0, 0x190, %o0	! 40037d90 <CSWTCH.2+0x11a0><== NOT EXECUTED
4001f640:	10 bf ff 7c 	b  4001f430 <rtems_rfs_fs_open+0x1c8>          <== NOT EXECUTED
4001f644:	90 10 00 1b 	mov  %i3, %o0                                  <== 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);     
4001f648:	c2 0f 60 10 	ldub  [ %i5 + 0x10 ], %g1                      
4001f64c:	c8 0f 60 11 	ldub  [ %i5 + 0x11 ], %g4                      
4001f650:	c4 0f 60 12 	ldub  [ %i5 + 0x12 ], %g2                      
4001f654:	89 29 20 10 	sll  %g4, 0x10, %g4                            
4001f658:	85 28 a0 08 	sll  %g2, 8, %g2                               
4001f65c:	83 28 60 18 	sll  %g1, 0x18, %g1                            
4001f660:	82 10 40 04 	or  %g1, %g4, %g1                              
4001f664:	82 10 40 03 	or  %g1, %g3, %g1                              
4001f668:	82 10 40 02 	or  %g1, %g2, %g1                              
4001f66c:	c2 26 e0 18 	st  %g1, [ %i3 + 0x18 ]                        
  fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
4001f670:	c6 0f 60 17 	ldub  [ %i5 + 0x17 ], %g3                      
4001f674:	c2 0f 60 14 	ldub  [ %i5 + 0x14 ], %g1                      
4001f678:	c8 0f 60 15 	ldub  [ %i5 + 0x15 ], %g4                      
4001f67c:	c4 0f 60 16 	ldub  [ %i5 + 0x16 ], %g2                      
4001f680:	89 29 20 10 	sll  %g4, 0x10, %g4                            
4001f684:	85 28 a0 08 	sll  %g2, 8, %g2                               
4001f688:	83 28 60 18 	sll  %g1, 0x18, %g1                            
4001f68c:	82 10 40 04 	or  %g1, %g4, %g1                              
4001f690:	82 10 40 03 	or  %g1, %g3, %g1                              
4001f694:	82 10 40 02 	or  %g1, %g2, %g1                              
4001f698:	c2 26 e0 1c 	st  %g1, [ %i3 + 0x1c ]                        
  fs->group_count     = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);         
4001f69c:	c6 0f 60 19 	ldub  [ %i5 + 0x19 ], %g3                      
4001f6a0:	c2 0f 60 1a 	ldub  [ %i5 + 0x1a ], %g1                      
4001f6a4:	c4 0f 60 1b 	ldub  [ %i5 + 0x1b ], %g2                      
4001f6a8:	f0 0f 60 18 	ldub  [ %i5 + 0x18 ], %i0                      
4001f6ac:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
4001f6b0:	83 28 60 08 	sll  %g1, 8, %g1                               
4001f6b4:	b1 2e 20 18 	sll  %i0, 0x18, %i0                            
4001f6b8:	b0 16 00 03 	or  %i0, %g3, %i0                              
4001f6bc:	b0 16 00 02 	or  %i0, %g2, %i0                              
4001f6c0:	b0 16 00 01 	or  %i0, %g1, %i0                              
4001f6c4:	f0 26 e0 24 	st  %i0, [ %i3 + 0x24 ]                        
  fs->group_blocks    = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);   
4001f6c8:	c4 0f 60 1f 	ldub  [ %i5 + 0x1f ], %g2                      
4001f6cc:	f2 0f 60 1c 	ldub  [ %i5 + 0x1c ], %i1                      
4001f6d0:	c6 0f 60 1d 	ldub  [ %i5 + 0x1d ], %g3                      
4001f6d4:	c2 0f 60 1e 	ldub  [ %i5 + 0x1e ], %g1                      
4001f6d8:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
4001f6dc:	83 28 60 08 	sll  %g1, 8, %g1                               
4001f6e0:	b3 2e 60 18 	sll  %i1, 0x18, %i1                            
4001f6e4:	b2 16 40 03 	or  %i1, %g3, %i1                              
4001f6e8:	b2 16 40 02 	or  %i1, %g2, %i1                              
4001f6ec:	b2 16 40 01 	or  %i1, %g1, %i1                              
4001f6f0:	f2 26 e0 28 	st  %i1, [ %i3 + 0x28 ]                        
  fs->group_inodes    = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);   
4001f6f4:	c4 0f 60 21 	ldub  [ %i5 + 0x21 ], %g2                      
4001f6f8:	de 0f 60 20 	ldub  [ %i5 + 0x20 ], %o7                      
4001f6fc:	c6 0f 60 22 	ldub  [ %i5 + 0x22 ], %g3                      
4001f700:	c8 0f 60 23 	ldub  [ %i5 + 0x23 ], %g4                      
4001f704:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
                                                                      
  fs->blocks_per_block =                                              
    rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);    
4001f708:	83 36 a0 02 	srl  %i2, 2, %g1                               
                                                                      
  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);   
4001f70c:	bb 2b e0 18 	sll  %o7, 0x18, %i5                            
4001f710:	87 28 e0 08 	sll  %g3, 8, %g3                               
4001f714:	ba 17 40 02 	or  %i5, %g2, %i5                              
                                                                      
  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;                    
4001f718:	85 28 60 02 	sll  %g1, 2, %g2                               
4001f71c:	84 00 80 01 	add  %g2, %g1, %g2                             
                                                                      
  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);   
4001f720:	ba 17 40 04 	or  %i5, %g4, %i5                              
    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 =                                       
    fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
4001f724:	92 10 00 01 	mov  %g1, %o1                                  
                                                                      
  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);   
4001f728:	ba 17 40 03 	or  %i5, %g3, %i5                              
                                                                      
  fs->blocks_per_block =                                              
    rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);    
                                                                      
  fs->block_map_singly_blocks =                                       
4001f72c:	c4 26 e0 38 	st  %g2, [ %i3 + 0x38 ]                        
    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;
4001f730:	90 10 00 01 	mov  %g1, %o0                                  
  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);   
                                                                      
  fs->blocks_per_block =                                              
4001f734:	c2 26 e0 34 	st  %g1, [ %i3 + 0x34 ]                        
    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 =                                       
    fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
4001f738:	7f ff 8b a0 	call  400025b8 <.umul>                         
4001f73c:	fa 26 e0 2c 	st  %i5, [ %i3 + 0x2c ]                        
4001f740:	83 2a 20 02 	sll  %o0, 2, %g1                               
4001f744:	82 00 40 08 	add  %g1, %o0, %g1                             
                                                                      
  fs->inodes = fs->group_count * fs->group_inodes;                    
4001f748:	92 10 00 18 	mov  %i0, %o1                                  
  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 =                                       
4001f74c:	c2 26 e0 3c 	st  %g1, [ %i3 + 0x3c ]                        
    fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
                                                                      
  fs->inodes = fs->group_count * fs->group_inodes;                    
4001f750:	7f ff 8b 9a 	call  400025b8 <.umul>                         
4001f754:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;       
4001f758:	92 10 20 38 	mov  0x38, %o1                                 
  fs->block_map_singly_blocks =                                       
    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;                    
4001f75c:	d0 26 e0 14 	st  %o0, [ %i3 + 0x14 ]                        
                                                                      
  fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;       
4001f760:	7f ff 8b d0 	call  400026a0 <.udiv>                         
4001f764:	90 10 00 1a 	mov  %i2, %o0                                  
4001f768:	d0 26 e0 30 	st  %o0, [ %i3 + 0x30 ]                        
                                                                      
  if (fs->group_blocks >                                              
      rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))     
4001f76c:	b5 2e a0 03 	sll  %i2, 3, %i2                               
4001f770:	92 07 bf cc 	add  %fp, -52, %o1                             
                                                                      
  fs->inodes = fs->group_count * fs->group_inodes;                    
                                                                      
  fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;       
                                                                      
  if (fs->group_blocks >                                              
4001f774:	80 a6 40 1a 	cmp  %i1, %i2                                  
4001f778:	08 80 00 10 	bleu  4001f7b8 <rtems_rfs_fs_open+0x550>       <== ALWAYS TAKEN
4001f77c:	90 10 00 1b 	mov  %i3, %o0                                  
4001f780:	7f ff f3 2e 	call  4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001f784:	ba 10 20 05 	mov  5, %i5                                    <== NOT EXECUTED
      rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))     
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &handle);                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
4001f788:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001f78c:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
  handle->dirty = false;                                              
4001f790:	c0 2f bf cc 	clrb  [ %fp + -52 ]                            <== NOT EXECUTED
  handle->bnum  = 0;                                                  
4001f794:	c0 27 bf d0 	clr  [ %fp + -48 ]                             <== NOT EXECUTED
4001f798:	7f ff d1 c3 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001f79c:	c0 27 bf d4 	clr  [ %fp + -44 ]                             <== NOT EXECUTED
4001f7a0:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001f7a4:	02 bf fe fc 	be  4001f394 <rtems_rfs_fs_open+0x12c>         <== NOT EXECUTED
4001f7a8:	11 10 00 df 	sethi  %hi(0x40037c00), %o0                    <== NOT EXECUTED
      printf ("rtems-rfs: read-superblock: groups blocks larger than block bits\n");
4001f7ac:	40 00 12 8c 	call  400241dc <puts>                          <== NOT EXECUTED
4001f7b0:	90 12 22 18 	or  %o0, 0x218, %o0	! 40037e18 <CSWTCH.2+0x1228><== NOT EXECUTED
4001f7b4:	30 bf fe f8 	b,a   4001f394 <rtems_rfs_fs_open+0x12c>       <== 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);                       
4001f7b8:	7f ff f3 20 	call  4001c438 <rtems_rfs_buffer_handle_release>
4001f7bc:	01 00 00 00 	nop                                            
  rtems_rfs_buffer_handle_close (fs, &handle);                        
                                                                      
  /*                                                                  
   * Change the block size to the value in the superblock.            
   */                                                                 
  rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_block_size (fs));
4001f7c0:	d2 06 e0 08 	ld  [ %i3 + 8 ], %o1                           
  handle->dirty = false;                                              
4001f7c4:	c0 2f bf cc 	clrb  [ %fp + -52 ]                            
  handle->bnum  = 0;                                                  
4001f7c8:	c0 27 bf d0 	clr  [ %fp + -48 ]                             
  handle->buffer = NULL;                                              
4001f7cc:	c0 27 bf d4 	clr  [ %fp + -44 ]                             
4001f7d0:	7f ff f4 ff 	call  4001cbcc <rtems_rfs_buffer_setblksize>   
4001f7d4:	90 10 00 1b 	mov  %i3, %o0                                  
  if (rc > 0)                                                         
4001f7d8:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001f7dc:	04 80 00 23 	ble  4001f868 <rtems_rfs_fs_open+0x600>        <== ALWAYS TAKEN
4001f7e0:	92 07 bf cc 	add  %fp, -52, %o1                             
 */                                                                   
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);                       
4001f7e4:	7f ff f3 15 	call  4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001f7e8:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &handle);                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
4001f7ec:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001f7f0:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
  handle->dirty = false;                                              
4001f7f4:	c0 2f bf cc 	clrb  [ %fp + -52 ]                            <== NOT EXECUTED
  handle->bnum  = 0;                                                  
4001f7f8:	c0 27 bf d0 	clr  [ %fp + -48 ]                             <== NOT EXECUTED
4001f7fc:	7f ff d1 aa 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001f800:	c0 27 bf d4 	clr  [ %fp + -44 ]                             <== NOT EXECUTED
4001f804:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001f808:	02 bf fe e3 	be  4001f394 <rtems_rfs_fs_open+0x12c>         <== NOT EXECUTED
4001f80c:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
4001f810:	40 00 16 25 	call  400250a4 <strerror>                      <== NOT EXECUTED
4001f814:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001f818:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
4001f81c:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
4001f820:	11 10 00 df 	sethi  %hi(0x40037c00), %o0                    <== NOT EXECUTED
4001f824:	40 00 11 d6 	call  40023f7c <printf>                        <== NOT EXECUTED
4001f828:	90 12 22 60 	or  %o0, 0x260, %o0	! 40037e60 <CSWTCH.2+0x1270><== NOT EXECUTED
4001f82c:	30 bf fe da 	b,a   4001f394 <rtems_rfs_fs_open+0x12c>       <== NOT EXECUTED
    printf ("rtems-rfs: open: %s\n", name);                           
                                                                      
  *fs = malloc (sizeof (rtems_rfs_file_system));                      
  if (!*fs)                                                           
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
4001f830:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001f834:	7f ff d1 9c 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001f838:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
4001f83c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001f840:	02 80 00 04 	be  4001f850 <rtems_rfs_fs_open+0x5e8>         <== NOT EXECUTED
4001f844:	11 10 00 df 	sethi  %hi(0x40037c00), %o0                    <== NOT EXECUTED
      printf ("rtems-rfs: open: no memory for file system data\n");   
4001f848:	40 00 12 65 	call  400241dc <puts>                          <== NOT EXECUTED
4001f84c:	90 12 20 b8 	or  %o0, 0xb8, %o0	! 40037cb8 <CSWTCH.2+0x10c8><== NOT EXECUTED
    errno = ENOMEM;                                                   
4001f850:	40 00 0c 3a 	call  40022938 <__errno>                       <== NOT EXECUTED
4001f854:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4001f858:	82 10 20 0c 	mov  0xc, %g1                                  <== NOT EXECUTED
4001f85c:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4001f860:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001f864:	81 e8 00 00 	restore                                        <== 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));    
4001f868:	fa 06 e0 24 	ld  [ %i3 + 0x24 ], %i5                        
4001f86c:	92 10 20 50 	mov  0x50, %o1                                 
4001f870:	7f ff a1 53 	call  40007dbc <calloc>                        
4001f874:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  if (!fs->groups)                                                    
4001f878:	80 a2 20 00 	cmp  %o0, 0                                    
4001f87c:	02 80 00 97 	be  4001fad8 <rtems_rfs_fs_open+0x870>         <== NEVER TAKEN
4001f880:	d0 26 e0 20 	st  %o0, [ %i3 + 0x20 ]                        
  /*                                                                  
   * 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++)                   
4001f884:	b2 10 20 00 	clr  %i1                                       
4001f888:	80 a7 60 00 	cmp  %i5, 0                                    
4001f88c:	14 80 00 08 	bg  4001f8ac <rtems_rfs_fs_open+0x644>         <== ALWAYS TAKEN
4001f890:	b4 10 20 00 	clr  %i2                                       
              rc, strerror (rc));                                     
    errno = rc;                                                       
    return -1;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);  
4001f894:	10 80 00 35 	b  4001f968 <rtems_rfs_fs_open+0x700>          <== NOT EXECUTED
4001f898:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== 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++)                   
4001f89c:	b4 06 a0 01 	inc  %i2                                       
4001f8a0:	80 a6 80 01 	cmp  %i2, %g1                                  
4001f8a4:	16 80 00 30 	bge  4001f964 <rtems_rfs_fs_open+0x6fc>        <== ALWAYS TAKEN
4001f8a8:	b2 06 60 50 	add  %i1, 0x50, %i1                            
  {                                                                   
    rc = rtems_rfs_group_open (fs,                                    
                               rtems_rfs_fs_block (fs, group, 0),     
4001f8ac:	fa 06 e0 28 	ld  [ %i3 + 0x28 ], %i5                        
4001f8b0:	90 10 00 1a 	mov  %i2, %o0                                  
4001f8b4:	7f ff 8b 41 	call  400025b8 <.umul>                         
4001f8b8:	92 10 00 1d 	mov  %i5, %o1                                  
   * 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,                                    
4001f8bc:	d8 06 e0 20 	ld  [ %i3 + 0x20 ], %o4                        
4001f8c0:	d6 06 e0 2c 	ld  [ %i3 + 0x2c ], %o3                        
                               rtems_rfs_fs_block (fs, group, 0),     
4001f8c4:	92 02 20 01 	add  %o0, 1, %o1                               
   * 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,                                    
4001f8c8:	94 10 00 1d 	mov  %i5, %o2                                  
4001f8cc:	98 03 00 19 	add  %o4, %i1, %o4                             
4001f8d0:	7f ff c8 99 	call  40011b34 <rtems_rfs_group_open>          
4001f8d4:	90 10 00 1b 	mov  %i3, %o0                                  
                               rtems_rfs_fs_block (fs, group, 0),     
                               fs->group_blocks,                      
                               fs->group_inodes,                      
                               &fs->groups[group]);                   
    if (rc > 0)                                                       
4001f8d8:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001f8dc:	24 bf ff f0 	ble,a   4001f89c <rtems_rfs_fs_open+0x634>     <== ALWAYS TAKEN
4001f8e0:	c2 06 e0 24 	ld  [ %i3 + 0x24 ], %g1                        
    {                                                                 
      int g;                                                          
      for (g = 0; g < group; g++)                                     
4001f8e4:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
4001f8e8:	80 a6 a0 00 	cmp  %i2, 0                                    <== NOT EXECUTED
4001f8ec:	02 80 00 0a 	be  4001f914 <rtems_rfs_fs_open+0x6ac>         <== NOT EXECUTED
4001f8f0:	b2 10 20 00 	clr  %i1                                       <== NOT EXECUTED
        rtems_rfs_group_close (fs, &fs->groups[g]);                   
4001f8f4:	d2 06 e0 20 	ld  [ %i3 + 0x20 ], %o1                        <== NOT EXECUTED
4001f8f8:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
4001f8fc:	7f ff c9 1b 	call  40011d68 <rtems_rfs_group_close>         <== NOT EXECUTED
4001f900:	92 02 40 18 	add  %o1, %i0, %o1                             <== NOT EXECUTED
                               fs->group_inodes,                      
                               &fs->groups[group]);                   
    if (rc > 0)                                                       
    {                                                                 
      int g;                                                          
      for (g = 0; g < group; g++)                                     
4001f904:	b2 06 60 01 	inc  %i1                                       <== NOT EXECUTED
4001f908:	80 a6 40 1a 	cmp  %i1, %i2                                  <== NOT EXECUTED
4001f90c:	12 bf ff fa 	bne  4001f8f4 <rtems_rfs_fs_open+0x68c>        <== NOT EXECUTED
4001f910:	b0 06 20 50 	add  %i0, 0x50, %i0                            <== 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);                       
4001f914:	92 07 bf cc 	add  %fp, -52, %o1                             <== NOT EXECUTED
4001f918:	7f ff f2 c8 	call  4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001f91c:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
        rtems_rfs_group_close (fs, &fs->groups[g]);                   
      rtems_rfs_buffer_handle_close (fs, &handle);                    
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                     
4001f920:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001f924:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
  handle->dirty = false;                                              
4001f928:	c0 2f bf cc 	clrb  [ %fp + -52 ]                            <== NOT EXECUTED
  handle->bnum  = 0;                                                  
4001f92c:	c0 27 bf d0 	clr  [ %fp + -48 ]                             <== NOT EXECUTED
4001f930:	7f ff d1 5d 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001f934:	c0 27 bf d4 	clr  [ %fp + -44 ]                             <== NOT EXECUTED
4001f938:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001f93c:	02 bf fe 96 	be  4001f394 <rtems_rfs_fs_open+0x12c>         <== NOT EXECUTED
4001f940:	01 00 00 00 	nop                                            <== NOT EXECUTED
        printf ("rtems-rfs: read-superblock: no memory for group table%d: %s\n",
4001f944:	40 00 15 d8 	call  400250a4 <strerror>                      <== NOT EXECUTED
4001f948:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001f94c:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
4001f950:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
4001f954:	11 10 00 df 	sethi  %hi(0x40037c00), %o0                    <== NOT EXECUTED
4001f958:	40 00 11 89 	call  40023f7c <printf>                        <== NOT EXECUTED
4001f95c:	90 12 22 e0 	or  %o0, 0x2e0, %o0	! 40037ee0 <CSWTCH.2+0x12f0><== NOT EXECUTED
4001f960:	30 bf fe 8d 	b,a   4001f394 <rtems_rfs_fs_open+0x12c>       <== NOT EXECUTED
              rc, strerror (rc));                                     
    errno = rc;                                                       
    return -1;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);  
4001f964:	d0 07 00 00 	ld  [ %i4 ], %o0                               
4001f968:	92 10 20 01 	mov  1, %o1                                    
4001f96c:	94 07 bf d8 	add  %fp, -40, %o2                             
4001f970:	7f ff ca a6 	call  40012408 <rtems_rfs_inode_open>          
4001f974:	96 10 20 01 	mov  1, %o3                                    
  if (rc > 0)                                                         
4001f978:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001f97c:	14 80 00 45 	bg  4001fa90 <rtems_rfs_fs_open+0x828>         <== NEVER TAKEN
4001f980:	01 00 00 00 	nop                                            
              rc, strerror (rc));                                     
    errno = rc;                                                       
    return -1;                                                        
  }                                                                   
                                                                      
  if (((*fs)->flags & RTEMS_RFS_FS_FORCE_OPEN) == 0)                  
4001f984:	d0 07 00 00 	ld  [ %i4 ], %o0                               
4001f988:	c2 02 00 00 	ld  [ %o0 ], %g1                               
4001f98c:	80 88 60 04 	btst  4, %g1                                   
4001f990:	12 80 00 10 	bne  4001f9d0 <rtems_rfs_fs_open+0x768>        
4001f994:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
 * @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);                    
4001f998:	c4 08 60 03 	ldub  [ %g1 + 3 ], %g2                         
4001f99c:	c6 08 60 02 	ldub  [ %g1 + 2 ], %g3                         
4001f9a0:	83 28 e0 08 	sll  %g3, 8, %g1                               
4001f9a4:	82 10 40 02 	or  %g1, %g2, %g1                              
  {                                                                   
    mode = rtems_rfs_inode_get_mode (&inode);                         
                                                                      
    if ((mode == 0xffff) || !RTEMS_RFS_S_ISDIR (mode))                
4001f9a8:	05 3f ff c0 	sethi  %hi(0xffff0000), %g2                    
4001f9ac:	87 28 60 10 	sll  %g1, 0x10, %g3                            
4001f9b0:	80 a0 c0 02 	cmp  %g3, %g2                                  
4001f9b4:	02 80 00 23 	be  4001fa40 <rtems_rfs_fs_open+0x7d8>         <== NEVER TAKEN
4001f9b8:	05 00 00 3c 	sethi  %hi(0xf000), %g2                        
4001f9bc:	82 08 40 02 	and  %g1, %g2, %g1                             
4001f9c0:	05 00 00 10 	sethi  %hi(0x4000), %g2                        
4001f9c4:	80 a0 40 02 	cmp  %g1, %g2                                  
4001f9c8:	12 80 00 1e 	bne  4001fa40 <rtems_rfs_fs_open+0x7d8>        <== NEVER TAKEN
4001f9cc:	01 00 00 00 	nop                                            
      errno = EIO;                                                    
      return -1;                                                      
    }                                                                 
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_close (*fs, &inode);                           
4001f9d0:	7f ff cb 06 	call  400125e8 <rtems_rfs_inode_close>         
4001f9d4:	92 07 bf d8 	add  %fp, -40, %o1                             
  if (rc > 0)                                                         
4001f9d8:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001f9dc:	14 80 00 07 	bg  4001f9f8 <rtems_rfs_fs_open+0x790>         <== NEVER TAKEN
4001f9e0:	01 00 00 00 	nop                                            
      printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
    errno = rc;                                                       
    return -1;                                                        
  }                                                                   
                                                                      
  errno = 0;                                                          
4001f9e4:	40 00 0b d5 	call  40022938 <__errno>                       
4001f9e8:	b0 10 20 00 	clr  %i0	! 0 <PROM_START>                      
4001f9ec:	c0 22 00 00 	clr  [ %o0 ]                                   
4001f9f0:	81 c7 e0 08 	ret                                            
4001f9f4:	81 e8 00 00 	restore                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_close (*fs, &inode);                           
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_buffer_close (*fs);                                     
4001f9f8:	7f ff f4 be 	call  4001ccf0 <rtems_rfs_buffer_close>        <== NOT EXECUTED
4001f9fc:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
    free (*fs);                                                       
4001fa00:	7f ff a1 52 	call  40007f48 <free>                          <== NOT EXECUTED
4001fa04:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
4001fa08:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001fa0c:	7f ff d1 26 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001fa10:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
4001fa14:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001fa18:	02 bf fe 69 	be  4001f3bc <rtems_rfs_fs_open+0x154>         <== NOT EXECUTED
4001fa1c:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
4001fa20:	40 00 15 a1 	call  400250a4 <strerror>                      <== NOT EXECUTED
4001fa24:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001fa28:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
4001fa2c:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
4001fa30:	11 10 00 df 	sethi  %hi(0x40037c00), %o0                    <== NOT EXECUTED
4001fa34:	40 00 11 52 	call  40023f7c <printf>                        <== NOT EXECUTED
4001fa38:	90 12 23 b0 	or  %o0, 0x3b0, %o0	! 40037fb0 <CSWTCH.2+0x13c0><== NOT EXECUTED
4001fa3c:	30 bf fe 60 	b,a   4001f3bc <rtems_rfs_fs_open+0x154>       <== NOT EXECUTED
  {                                                                   
    mode = rtems_rfs_inode_get_mode (&inode);                         
                                                                      
    if ((mode == 0xffff) || !RTEMS_RFS_S_ISDIR (mode))                
    {                                                                 
      rtems_rfs_inode_close (*fs, &inode);                            
4001fa40:	7f ff ca ea 	call  400125e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
4001fa44:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
      rtems_rfs_buffer_close (*fs);                                   
4001fa48:	7f ff f4 aa 	call  4001ccf0 <rtems_rfs_buffer_close>        <== NOT EXECUTED
4001fa4c:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
      free (*fs);                                                     
4001fa50:	7f ff a1 3e 	call  40007f48 <free>                          <== NOT EXECUTED
4001fa54:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                     
4001fa58:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001fa5c:	7f ff d1 12 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001fa60:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
4001fa64:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001fa68:	02 80 00 04 	be  4001fa78 <rtems_rfs_fs_open+0x810>         <== NOT EXECUTED
4001fa6c:	11 10 00 df 	sethi  %hi(0x40037c00), %o0                    <== NOT EXECUTED
        printf ("rtems-rfs: open: invalid root inode mode\n");        
4001fa70:	40 00 11 db 	call  400241dc <puts>                          <== NOT EXECUTED
4001fa74:	90 12 23 80 	or  %o0, 0x380, %o0	! 40037f80 <CSWTCH.2+0x1390><== NOT EXECUTED
      errno = EIO;                                                    
4001fa78:	40 00 0b b0 	call  40022938 <__errno>                       <== NOT EXECUTED
4001fa7c:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4001fa80:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
4001fa84:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4001fa88:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001fa8c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);  
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_buffer_close (*fs);                                     
4001fa90:	7f ff f4 98 	call  4001ccf0 <rtems_rfs_buffer_close>        <== NOT EXECUTED
4001fa94:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
    free (*fs);                                                       
4001fa98:	7f ff a1 2c 	call  40007f48 <free>                          <== NOT EXECUTED
4001fa9c:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
4001faa0:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001faa4:	7f ff d1 00 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001faa8:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
4001faac:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001fab0:	02 bf fe 43 	be  4001f3bc <rtems_rfs_fs_open+0x154>         <== NOT EXECUTED
4001fab4:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: open: reading root inode: %d: %s\n",        
4001fab8:	40 00 15 7b 	call  400250a4 <strerror>                      <== NOT EXECUTED
4001fabc:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001fac0:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
4001fac4:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
4001fac8:	11 10 00 df 	sethi  %hi(0x40037c00), %o0                    <== NOT EXECUTED
4001facc:	40 00 11 2c 	call  40023f7c <printf>                        <== NOT EXECUTED
4001fad0:	90 12 23 50 	or  %o0, 0x350, %o0	! 40037f50 <CSWTCH.2+0x1360><== NOT EXECUTED
4001fad4:	30 bf fe 3a 	b,a   4001f3bc <rtems_rfs_fs_open+0x154>       <== 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);                       
4001fad8:	92 07 bf cc 	add  %fp, -52, %o1                             <== NOT EXECUTED
4001fadc:	7f ff f2 57 	call  4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001fae0:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
  fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));    
                                                                      
  if (!fs->groups)                                                    
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &handle);                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
4001fae4:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001fae8:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
  handle->dirty = false;                                              
4001faec:	c0 2f bf cc 	clrb  [ %fp + -52 ]                            <== NOT EXECUTED
  handle->bnum  = 0;                                                  
4001faf0:	c0 27 bf d0 	clr  [ %fp + -48 ]                             <== NOT EXECUTED
  handle->buffer = NULL;                                              
4001faf4:	c0 27 bf d4 	clr  [ %fp + -44 ]                             <== NOT EXECUTED
4001faf8:	7f ff d0 eb 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001fafc:	ba 10 20 0c 	mov  0xc, %i5                                  <== NOT EXECUTED
4001fb00:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001fb04:	02 bf fe 24 	be  4001f394 <rtems_rfs_fs_open+0x12c>         <== NOT EXECUTED
4001fb08:	11 10 00 df 	sethi  %hi(0x40037c00), %o0                    <== NOT EXECUTED
      printf ("rtems-rfs: read-superblock: no memory for group table\n");
4001fb0c:	40 00 11 b4 	call  400241dc <puts>                          <== NOT EXECUTED
4001fb10:	90 12 22 a8 	or  %o0, 0x2a8, %o0	! 40037ea8 <CSWTCH.2+0x12b8><== NOT EXECUTED
4001fb14:	30 bf fe 20 	b,a   4001f394 <rtems_rfs_fs_open+0x12c>       <== NOT EXECUTED
                                                                      

4001f21c <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) {
4001f21c:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
  uint64_t blocks = rtems_rfs_fs_blocks (fs);                         
  uint64_t block_size = rtems_rfs_fs_block_size (fs);                 
  return blocks * block_size;                                         
4001f220:	d2 06 20 08 	ld  [ %i0 + 8 ], %o1                           <== NOT EXECUTED
4001f224:	d6 06 20 04 	ld  [ %i0 + 4 ], %o3                           <== NOT EXECUTED
4001f228:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
4001f22c:	40 00 45 96 	call  40030884 <__muldi3>                      <== NOT EXECUTED
4001f230:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
}                                                                     
4001f234:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
4001f238:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001f23c:	93 e8 00 09 	restore  %g0, %o1, %o1                         <== NOT EXECUTED
                                                                      

40011e14 <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) {
40011e14:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_rfs_bitmap_bit bit;                                           
  int                  offset;                                        
  bool                 updown;                                        
  int                  direction;                                     
                                                                      
  if (inode)                                                          
40011e18:	80 a6 a0 00 	cmp  %i2, 0                                    
40011e1c:	22 80 00 04 	be,a   40011e2c <rtems_rfs_group_bitmap_alloc+0x18>
40011e20:	e6 06 20 28 	ld  [ %i0 + 0x28 ], %l3                        
  {                                                                   
    size = fs->group_inodes;                                          
40011e24:	e6 06 20 2c 	ld  [ %i0 + 0x2c ], %l3                        
    goal -= RTEMS_RFS_ROOT_INO;                                       
40011e28:	b2 06 7f ff 	add  %i1, -1, %i1                              
  }                                                                   
  else                                                                
    size = fs->group_blocks;                                          
                                                                      
  group_start = goal / size;                                          
40011e2c:	90 10 00 19 	mov  %i1, %o0                                  
40011e30:	7f ff c2 1c 	call  400026a0 <.udiv>                         
40011e34:	92 10 00 13 	mov  %l3, %o1                                  
  bit = (rtems_rfs_bitmap_bit) (goal % size);                         
40011e38:	92 10 00 13 	mov  %l3, %o1                                  
    goal -= RTEMS_RFS_ROOT_INO;                                       
  }                                                                   
  else                                                                
    size = fs->group_blocks;                                          
                                                                      
  group_start = goal / size;                                          
40011e3c:	a2 10 00 08 	mov  %o0, %l1                                  
  bit = (rtems_rfs_bitmap_bit) (goal % size);                         
  offset = 0;                                                         
  updown = true;                                                      
  direction = 1;                                                      
40011e40:	b8 10 20 01 	mov  1, %i4                                    
  }                                                                   
  else                                                                
    size = fs->group_blocks;                                          
                                                                      
  group_start = goal / size;                                          
  bit = (rtems_rfs_bitmap_bit) (goal % size);                         
40011e44:	90 10 00 19 	mov  %i1, %o0                                  
40011e48:	40 00 79 e3 	call  400305d4 <.urem>                         
40011e4c:	ba 10 00 11 	mov  %l1, %i5                                  
  offset = 0;                                                         
  updown = true;                                                      
40011e50:	a0 10 20 01 	mov  1, %l0                                    
  }                                                                   
  else                                                                
    size = fs->group_blocks;                                          
                                                                      
  group_start = goal / size;                                          
  bit = (rtems_rfs_bitmap_bit) (goal % size);                         
40011e54:	d0 27 bf fc 	st  %o0, [ %fp + -4 ]                          
   */                                                                 
  while (true)                                                        
  {                                                                   
    rtems_rfs_bitmap_control* bitmap;                                 
    int                       group;                                  
    bool                      allocated = false;                      
40011e58:	c0 2f bf fb 	clrb  [ %fp + -5 ]                             
  else                                                                
    size = fs->group_blocks;                                          
                                                                      
  group_start = goal / size;                                          
  bit = (rtems_rfs_bitmap_bit) (goal % size);                         
  offset = 0;                                                         
40011e5c:	b2 10 20 00 	clr  %i1                                       
    /*                                                                
     * 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))                    
40011e60:	80 a7 60 00 	cmp  %i5, 0                                    
40011e64:	06 80 00 32 	bl  40011f2c <rtems_rfs_group_bitmap_alloc+0x118><== NEVER TAKEN
40011e68:	80 8c 20 ff 	btst  0xff, %l0                                
40011e6c:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
40011e70:	80 a0 40 1d 	cmp  %g1, %i5                                  
40011e74:	04 80 00 2e 	ble  40011f2c <rtems_rfs_group_bitmap_alloc+0x118>
40011e78:	80 8c 20 ff 	btst  0xff, %l0                                
      updown = false;                                                 
      continue;                                                       
    }                                                                 
                                                                      
   if (inode)                                                         
      bitmap = &fs->groups[group].inode_bitmap;                       
40011e7c:	e4 06 20 20 	ld  [ %i0 + 0x20 ], %l2                        
40011e80:	ab 2f 60 04 	sll  %i5, 4, %l5                               
40011e84:	a9 2f 60 06 	sll  %i5, 6, %l4                               
      direction = direction > 0 ? -1 : 1;                             
      updown = false;                                                 
      continue;                                                       
    }                                                                 
                                                                      
   if (inode)                                                         
40011e88:	80 a6 a0 00 	cmp  %i2, 0                                    
      bitmap = &fs->groups[group].inode_bitmap;                       
40011e8c:	82 05 40 14 	add  %l5, %l4, %g1                             
      direction = direction > 0 ? -1 : 1;                             
      updown = false;                                                 
      continue;                                                       
    }                                                                 
                                                                      
   if (inode)                                                         
40011e90:	02 80 00 46 	be  40011fa8 <rtems_rfs_group_bitmap_alloc+0x194>
40011e94:	a4 04 80 01 	add  %l2, %g1, %l2                             
      bitmap = &fs->groups[group].inode_bitmap;                       
40011e98:	a4 04 a0 2c 	add  %l2, 0x2c, %l2                            
    else                                                              
      bitmap = &fs->groups[group].block_bitmap;                       
                                                                      
    rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);  
40011e9c:	d2 07 bf fc 	ld  [ %fp + -4 ], %o1                          
40011ea0:	90 10 00 12 	mov  %l2, %o0                                  
40011ea4:	94 07 bf fb 	add  %fp, -5, %o2                              
40011ea8:	40 00 24 54 	call  4001aff8 <rtems_rfs_bitmap_map_alloc>    
40011eac:	96 07 bf fc 	add  %fp, -4, %o3                              
    if (rc > 0)                                                       
40011eb0:	80 a2 20 00 	cmp  %o0, 0                                    
40011eb4:	14 80 00 3b 	bg  40011fa0 <rtems_rfs_group_bitmap_alloc+0x18c><== NEVER TAKEN
40011eb8:	01 00 00 00 	nop                                            
      return rc;                                                      
                                                                      
    if (rtems_rfs_fs_release_bitmaps (fs))                            
40011ebc:	c2 06 00 00 	ld  [ %i0 ], %g1                               
40011ec0:	80 88 60 01 	btst  1, %g1                                   
40011ec4:	22 80 00 3b 	be,a   40011fb0 <rtems_rfs_group_bitmap_alloc+0x19c><== ALWAYS TAKEN
40011ec8:	d2 04 80 00 	ld  [ %l2 ], %o1                               
      rtems_rfs_bitmap_release_buffer (fs, bitmap);                   
                                                                      
    if (allocated)                                                    
40011ecc:	c2 0f bf fb 	ldub  [ %fp + -5 ], %g1                        <== NOT EXECUTED
40011ed0:	80 a0 60 00 	cmp  %g1, 0                                    
40011ed4:	12 80 00 3b 	bne  40011fc0 <rtems_rfs_group_bitmap_alloc+0x1ac>
40011ed8:	80 8c 20 ff 	btst  0xff, %l0                                
        printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
                inode ? "inode" : "block", *result);                  
      return 0;                                                       
    }                                                                 
                                                                      
    if (updown)                                                       
40011edc:	22 80 00 07 	be,a   40011ef8 <rtems_rfs_group_bitmap_alloc+0xe4><== NEVER TAKEN
40011ee0:	b2 06 60 01 	inc  %i1                                       <== NOT EXECUTED
      direction = direction > 0 ? -1 : 1;                             
40011ee4:	80 a7 20 00 	cmp  %i4, 0                                    
40011ee8:	04 80 00 03 	ble  40011ef4 <rtems_rfs_group_bitmap_alloc+0xe0><== NEVER TAKEN
40011eec:	b8 10 20 01 	mov  1, %i4                                    
40011ef0:	b8 10 3f ff 	mov  -1, %i4                                   
                                                                      
    offset++;                                                         
40011ef4:	b2 06 60 01 	inc  %i1                                       
   */                                                                 
  while (true)                                                        
  {                                                                   
    rtems_rfs_bitmap_control* bitmap;                                 
    int                       group;                                  
    bool                      allocated = false;                      
40011ef8:	c0 2f bf fb 	clrb  [ %fp + -5 ]                             
                                                                      
    /*                                                                
     * 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);                       
40011efc:	90 10 00 1c 	mov  %i4, %o0                                  
40011f00:	7f ff c1 ae 	call  400025b8 <.umul>                         
40011f04:	92 10 00 19 	mov  %i1, %o1                                  
    if (offset)                                                       
      bit = direction > 0 ? 0 : size - 1;                             
40011f08:	82 10 20 00 	clr  %g1                                       
40011f0c:	80 a7 20 00 	cmp  %i4, 0                                    
40011f10:	04 80 00 17 	ble  40011f6c <rtems_rfs_group_bitmap_alloc+0x158><== ALWAYS TAKEN
40011f14:	ba 02 00 11 	add  %o0, %l1, %i5                             
40011f18:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
    /*                                                                
     * 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))                    
40011f1c:	80 a7 60 00 	cmp  %i5, 0                                    
40011f20:	36 bf ff d4 	bge,a   40011e70 <rtems_rfs_group_bitmap_alloc+0x5c>
40011f24:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
    {                                                                 
      if (!updown)                                                    
40011f28:	80 8c 20 ff 	btst  0xff, %l0                                
40011f2c:	02 80 00 13 	be  40011f78 <rtems_rfs_group_bitmap_alloc+0x164>
40011f30:	80 a7 20 00 	cmp  %i4, 0                                    
        break;                                                        
      direction = direction > 0 ? -1 : 1;                             
40011f34:	04 80 00 03 	ble  40011f40 <rtems_rfs_group_bitmap_alloc+0x12c><== ALWAYS TAKEN
40011f38:	b8 10 20 01 	mov  1, %i4                                    
40011f3c:	b8 10 3f ff 	mov  -1, %i4                                   <== NOT EXECUTED
   */                                                                 
  while (true)                                                        
  {                                                                   
    rtems_rfs_bitmap_control* bitmap;                                 
    int                       group;                                  
    bool                      allocated = false;                      
40011f40:	c0 2f bf fb 	clrb  [ %fp + -5 ]                             
                                                                      
    /*                                                                
     * 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);                       
40011f44:	90 10 00 1c 	mov  %i4, %o0                                  
40011f48:	7f ff c1 9c 	call  400025b8 <.umul>                         
40011f4c:	92 10 00 19 	mov  %i1, %o1                                  
    if ((group < 0) || (group >= fs->group_count))                    
    {                                                                 
      if (!updown)                                                    
        break;                                                        
      direction = direction > 0 ? -1 : 1;                             
      updown = false;                                                 
40011f50:	a0 10 20 00 	clr  %l0                                       
    /*                                                                
     * 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)                                                       
40011f54:	80 a6 60 00 	cmp  %i1, 0                                    
40011f58:	02 bf ff c2 	be  40011e60 <rtems_rfs_group_bitmap_alloc+0x4c><== NEVER TAKEN
40011f5c:	ba 02 00 11 	add  %o0, %l1, %i5                             
      bit = direction > 0 ? 0 : size - 1;                             
40011f60:	80 a7 20 00 	cmp  %i4, 0                                    
40011f64:	14 bf ff ed 	bg  40011f18 <rtems_rfs_group_bitmap_alloc+0x104><== ALWAYS TAKEN
40011f68:	82 10 20 00 	clr  %g1                                       
40011f6c:	82 04 ff ff 	add  %l3, -1, %g1                              
40011f70:	10 bf ff eb 	b  40011f1c <rtems_rfs_group_bitmap_alloc+0x108>
40011f74:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
      direction = direction > 0 ? -1 : 1;                             
                                                                      
    offset++;                                                         
  }                                                                   
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))                
40011f78:	90 10 20 00 	clr  %o0                                       
40011f7c:	40 00 07 ca 	call  40013ea4 <rtems_rfs_trace>               
40011f80:	13 00 00 80 	sethi  %hi(0x20000), %o1                       
40011f84:	80 8a 20 ff 	btst  0xff, %o0                                
40011f88:	22 80 00 06 	be,a   40011fa0 <rtems_rfs_group_bitmap_alloc+0x18c><== ALWAYS TAKEN
40011f8c:	90 10 20 1c 	mov  0x1c, %o0                                 
    printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");  
40011f90:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
40011f94:	40 00 48 92 	call  400241dc <puts>                          <== NOT EXECUTED
40011f98:	90 12 20 b8 	or  %o0, 0xb8, %o0	! 40035cb8 <_CPU_Trap_slot_template+0x9d0><== NOT EXECUTED
                                                                      
  return ENOSPC;                                                      
40011f9c:	90 10 20 1c 	mov  0x1c, %o0                                 <== NOT EXECUTED
}                                                                     
40011fa0:	81 c7 e0 08 	ret                                            
40011fa4:	91 e8 00 08 	restore  %g0, %o0, %o0                         
    }                                                                 
                                                                      
   if (inode)                                                         
      bitmap = &fs->groups[group].inode_bitmap;                       
    else                                                              
      bitmap = &fs->groups[group].block_bitmap;                       
40011fa8:	10 bf ff bd 	b  40011e9c <rtems_rfs_group_bitmap_alloc+0x88>
40011fac:	a4 04 a0 08 	add  %l2, 8, %l2                               
    rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);  
    if (rc > 0)                                                       
      return rc;                                                      
                                                                      
    if (rtems_rfs_fs_release_bitmaps (fs))                            
      rtems_rfs_bitmap_release_buffer (fs, bitmap);                   
40011fb0:	40 00 29 22 	call  4001c438 <rtems_rfs_buffer_handle_release>
40011fb4:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
    if (allocated)                                                    
40011fb8:	10 bf ff c6 	b  40011ed0 <rtems_rfs_group_bitmap_alloc+0xbc>
40011fbc:	c2 0f bf fb 	ldub  [ %fp + -5 ], %g1                        
    {                                                                 
      if (inode)                                                      
40011fc0:	80 a6 a0 00 	cmp  %i2, 0                                    
40011fc4:	32 80 00 15 	bne,a   40012018 <rtems_rfs_group_bitmap_alloc+0x204>
40011fc8:	d2 06 20 2c 	ld  [ %i0 + 0x2c ], %o1                        
        *result = rtems_rfs_group_inode (fs, group, bit);             
      else                                                            
        *result = rtems_rfs_group_block (&fs->groups[group], bit);    
40011fcc:	c2 06 20 20 	ld  [ %i0 + 0x20 ], %g1                        
40011fd0:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
40011fd4:	a8 05 40 14 	add  %l5, %l4, %l4                             
40011fd8:	c2 00 40 14 	ld  [ %g1 + %l4 ], %g1                         
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))            
40011fdc:	90 10 20 00 	clr  %o0                                       
    if (allocated)                                                    
    {                                                                 
      if (inode)                                                      
        *result = rtems_rfs_group_inode (fs, group, bit);             
      else                                                            
        *result = rtems_rfs_group_block (&fs->groups[group], bit);    
40011fe0:	82 00 80 01 	add  %g2, %g1, %g1                             
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))            
40011fe4:	13 00 00 80 	sethi  %hi(0x20000), %o1                       
40011fe8:	40 00 07 af 	call  40013ea4 <rtems_rfs_trace>               
40011fec:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
40011ff0:	80 8a 20 ff 	btst  0xff, %o0                                
40011ff4:	02 80 00 07 	be  40012010 <rtems_rfs_group_bitmap_alloc+0x1fc><== ALWAYS TAKEN
40011ff8:	13 10 00 d7 	sethi  %hi(0x40035c00), %o1                    
        printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
40011ffc:	92 12 60 78 	or  %o1, 0x78, %o1	! 40035c78 <_CPU_Trap_slot_template+0x990><== NOT EXECUTED
40012000:	d4 06 c0 00 	ld  [ %i3 ], %o2                               <== NOT EXECUTED
40012004:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
40012008:	40 00 47 dd 	call  40023f7c <printf>                        <== NOT EXECUTED
4001200c:	90 12 20 80 	or  %o0, 0x80, %o0	! 40035c80 <_CPU_Trap_slot_template+0x998><== NOT EXECUTED
                inode ? "inode" : "block", *result);                  
      return 0;                                                       
40012010:	10 bf ff e4 	b  40011fa0 <rtems_rfs_group_bitmap_alloc+0x18c>
40012014:	90 10 20 00 	clr  %o0                                       
      rtems_rfs_bitmap_release_buffer (fs, bitmap);                   
                                                                      
    if (allocated)                                                    
    {                                                                 
      if (inode)                                                      
        *result = rtems_rfs_group_inode (fs, group, bit);             
40012018:	90 10 00 1d 	mov  %i5, %o0                                  
4001201c:	7f ff c1 67 	call  400025b8 <.umul>                         
40012020:	fa 07 bf fc 	ld  [ %fp + -4 ], %i5                          
40012024:	ba 07 60 01 	inc  %i5                                       
      else                                                            
        *result = rtems_rfs_group_block (&fs->groups[group], bit);    
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))            
40012028:	13 00 00 80 	sethi  %hi(0x20000), %o1                       
      rtems_rfs_bitmap_release_buffer (fs, bitmap);                   
                                                                      
    if (allocated)                                                    
    {                                                                 
      if (inode)                                                      
        *result = rtems_rfs_group_inode (fs, group, bit);             
4001202c:	ba 07 40 08 	add  %i5, %o0, %i5                             
      else                                                            
        *result = rtems_rfs_group_block (&fs->groups[group], bit);    
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))            
40012030:	90 10 20 00 	clr  %o0                                       
40012034:	40 00 07 9c 	call  40013ea4 <rtems_rfs_trace>               
40012038:	fa 26 c0 00 	st  %i5, [ %i3 ]                               
4001203c:	80 8a 20 ff 	btst  0xff, %o0                                
40012040:	02 bf ff f4 	be  40012010 <rtems_rfs_group_bitmap_alloc+0x1fc><== ALWAYS TAKEN
40012044:	13 10 00 d7 	sethi  %hi(0x40035c00), %o1                    
        printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
40012048:	10 bf ff ee 	b  40012000 <rtems_rfs_group_bitmap_alloc+0x1ec><== NOT EXECUTED
4001204c:	92 12 60 70 	or  %o1, 0x70, %o1	! 40035c70 <_CPU_Trap_slot_template+0x988><== NOT EXECUTED
                                                                      

40012050 <rtems_rfs_group_bitmap_free>: int rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs, bool inode, rtems_rfs_bitmap_bit no) {
40012050:	9d e3 bf a0 	save  %sp, -96, %sp                            
  unsigned int              group;                                    
  rtems_rfs_bitmap_bit      bit;                                      
  size_t                    size;                                     
  int                       rc;                                       
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))                
40012054:	90 10 20 00 	clr  %o0                                       
40012058:	13 00 00 80 	sethi  %hi(0x20000), %o1                       
4001205c:	40 00 07 92 	call  40013ea4 <rtems_rfs_trace>               
40012060:	ba 10 00 18 	mov  %i0, %i5                                  
40012064:	80 8a 20 ff 	btst  0xff, %o0                                
40012068:	02 80 00 0b 	be  40012094 <rtems_rfs_group_bitmap_free+0x44><== ALWAYS TAKEN
4001206c:	80 a6 60 00 	cmp  %i1, 0                                    
    printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",   
40012070:	12 80 00 3a 	bne  40012158 <rtems_rfs_group_bitmap_free+0x108><== NOT EXECUTED
40012074:	13 10 00 d7 	sethi  %hi(0x40035c00), %o1                    <== NOT EXECUTED
40012078:	13 10 00 d7 	sethi  %hi(0x40035c00), %o1                    <== NOT EXECUTED
4001207c:	92 12 60 78 	or  %o1, 0x78, %o1	! 40035c78 <_CPU_Trap_slot_template+0x990><== NOT EXECUTED
40012080:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
40012084:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
40012088:	40 00 47 bd 	call  40023f7c <printf>                        <== NOT EXECUTED
4001208c:	90 12 20 f0 	or  %o0, 0xf0, %o0                             <== NOT EXECUTED
            inode ? "inode" : "block", no);                           
                                                                      
  if (inode)                                                          
40012090:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
40012094:	22 80 00 1a 	be,a   400120fc <rtems_rfs_group_bitmap_free+0xac>
40012098:	f8 07 60 28 	ld  [ %i5 + 0x28 ], %i4                        
  {                                                                   
    no -= RTEMS_RFS_ROOT_INO;                                         
    size = fs->group_inodes;                                          
4001209c:	f8 07 60 2c 	ld  [ %i5 + 0x2c ], %i4                        
    printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",   
            inode ? "inode" : "block", no);                           
                                                                      
  if (inode)                                                          
  {                                                                   
    no -= RTEMS_RFS_ROOT_INO;                                         
400120a0:	b4 06 bf ff 	add  %i2, -1, %i2                              
    no -= RTEMS_RFS_SUPERBLOCK_SIZE;                                  
    size = fs->group_blocks;                                          
  }                                                                   
                                                                      
  group = no / size;                                                  
  bit = (rtems_rfs_bitmap_bit) (no % size);                           
400120a4:	92 10 00 1c 	mov  %i4, %o1                                  
400120a8:	40 00 79 4b 	call  400305d4 <.urem>                         
400120ac:	90 10 00 1a 	mov  %i2, %o0                                  
  {                                                                   
    no -= RTEMS_RFS_SUPERBLOCK_SIZE;                                  
    size = fs->group_blocks;                                          
  }                                                                   
                                                                      
  group = no / size;                                                  
400120b0:	92 10 00 1c 	mov  %i4, %o1                                  
  bit = (rtems_rfs_bitmap_bit) (no % size);                           
400120b4:	b6 10 00 08 	mov  %o0, %i3                                  
  {                                                                   
    no -= RTEMS_RFS_SUPERBLOCK_SIZE;                                  
    size = fs->group_blocks;                                          
  }                                                                   
                                                                      
  group = no / size;                                                  
400120b8:	7f ff c1 7a 	call  400026a0 <.udiv>                         
400120bc:	90 10 00 1a 	mov  %i2, %o0                                  
  bit = (rtems_rfs_bitmap_bit) (no % size);                           
                                                                      
  if (inode)                                                          
    bitmap = &fs->groups[group].inode_bitmap;                         
400120c0:	f8 07 60 20 	ld  [ %i5 + 0x20 ], %i4                        
400120c4:	83 2a 20 04 	sll  %o0, 4, %g1                               
400120c8:	91 2a 20 06 	sll  %o0, 6, %o0                               
400120cc:	90 00 40 08 	add  %g1, %o0, %o0                             
  else                                                                
    bitmap = &fs->groups[group].block_bitmap;                         
                                                                      
  rc = rtems_rfs_bitmap_map_clear (bitmap, bit);                      
400120d0:	92 10 00 1b 	mov  %i3, %o1                                  
                                                                      
  group = no / size;                                                  
  bit = (rtems_rfs_bitmap_bit) (no % size);                           
                                                                      
  if (inode)                                                          
    bitmap = &fs->groups[group].inode_bitmap;                         
400120d4:	b8 07 00 08 	add  %i4, %o0, %i4                             
400120d8:	b8 07 20 2c 	add  %i4, 0x2c, %i4                            
  else                                                                
    bitmap = &fs->groups[group].block_bitmap;                         
                                                                      
  rc = rtems_rfs_bitmap_map_clear (bitmap, bit);                      
400120dc:	40 00 23 33 	call  4001ada8 <rtems_rfs_bitmap_map_clear>    
400120e0:	90 10 00 1c 	mov  %i4, %o0                                  
                                                                      
  rtems_rfs_bitmap_release_buffer (fs, bitmap);                       
400120e4:	d2 07 00 00 	ld  [ %i4 ], %o1                               
  if (inode)                                                          
    bitmap = &fs->groups[group].inode_bitmap;                         
  else                                                                
    bitmap = &fs->groups[group].block_bitmap;                         
                                                                      
  rc = rtems_rfs_bitmap_map_clear (bitmap, bit);                      
400120e8:	b0 10 00 08 	mov  %o0, %i0                                  
                                                                      
  rtems_rfs_bitmap_release_buffer (fs, bitmap);                       
400120ec:	40 00 28 d3 	call  4001c438 <rtems_rfs_buffer_handle_release>
400120f0:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  return rc;                                                          
}                                                                     
400120f4:	81 c7 e0 08 	ret                                            
400120f8:	81 e8 00 00 	restore                                        
    no -= RTEMS_RFS_ROOT_INO;                                         
    size = fs->group_inodes;                                          
  }                                                                   
  else                                                                
  {                                                                   
    no -= RTEMS_RFS_SUPERBLOCK_SIZE;                                  
400120fc:	b4 06 bf ff 	add  %i2, -1, %i2                              
    size = fs->group_blocks;                                          
  }                                                                   
                                                                      
  group = no / size;                                                  
  bit = (rtems_rfs_bitmap_bit) (no % size);                           
40012100:	92 10 00 1c 	mov  %i4, %o1                                  
40012104:	40 00 79 34 	call  400305d4 <.urem>                         
40012108:	90 10 00 1a 	mov  %i2, %o0                                  
  {                                                                   
    no -= RTEMS_RFS_SUPERBLOCK_SIZE;                                  
    size = fs->group_blocks;                                          
  }                                                                   
                                                                      
  group = no / size;                                                  
4001210c:	92 10 00 1c 	mov  %i4, %o1                                  
  bit = (rtems_rfs_bitmap_bit) (no % size);                           
40012110:	b6 10 00 08 	mov  %o0, %i3                                  
  {                                                                   
    no -= RTEMS_RFS_SUPERBLOCK_SIZE;                                  
    size = fs->group_blocks;                                          
  }                                                                   
                                                                      
  group = no / size;                                                  
40012114:	7f ff c1 63 	call  400026a0 <.udiv>                         
40012118:	90 10 00 1a 	mov  %i2, %o0                                  
  bit = (rtems_rfs_bitmap_bit) (no % size);                           
                                                                      
  if (inode)                                                          
    bitmap = &fs->groups[group].inode_bitmap;                         
  else                                                                
    bitmap = &fs->groups[group].block_bitmap;                         
4001211c:	f8 07 60 20 	ld  [ %i5 + 0x20 ], %i4                        
40012120:	83 2a 20 04 	sll  %o0, 4, %g1                               
40012124:	91 2a 20 06 	sll  %o0, 6, %o0                               
40012128:	90 00 40 08 	add  %g1, %o0, %o0                             
                                                                      
  rc = rtems_rfs_bitmap_map_clear (bitmap, bit);                      
4001212c:	92 10 00 1b 	mov  %i3, %o1                                  
  bit = (rtems_rfs_bitmap_bit) (no % size);                           
                                                                      
  if (inode)                                                          
    bitmap = &fs->groups[group].inode_bitmap;                         
  else                                                                
    bitmap = &fs->groups[group].block_bitmap;                         
40012130:	b8 07 00 08 	add  %i4, %o0, %i4                             
40012134:	b8 07 20 08 	add  %i4, 8, %i4                               
                                                                      
  rc = rtems_rfs_bitmap_map_clear (bitmap, bit);                      
40012138:	40 00 23 1c 	call  4001ada8 <rtems_rfs_bitmap_map_clear>    
4001213c:	90 10 00 1c 	mov  %i4, %o0                                  
                                                                      
  rtems_rfs_bitmap_release_buffer (fs, bitmap);                       
40012140:	d2 07 00 00 	ld  [ %i4 ], %o1                               
  if (inode)                                                          
    bitmap = &fs->groups[group].inode_bitmap;                         
  else                                                                
    bitmap = &fs->groups[group].block_bitmap;                         
                                                                      
  rc = rtems_rfs_bitmap_map_clear (bitmap, bit);                      
40012144:	b0 10 00 08 	mov  %o0, %i0                                  
                                                                      
  rtems_rfs_bitmap_release_buffer (fs, bitmap);                       
40012148:	40 00 28 bc 	call  4001c438 <rtems_rfs_buffer_handle_release>
4001214c:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  return rc;                                                          
}                                                                     
40012150:	81 c7 e0 08 	ret                                            
40012154:	81 e8 00 00 	restore                                        
  rtems_rfs_bitmap_bit      bit;                                      
  size_t                    size;                                     
  int                       rc;                                       
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))                
    printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",   
40012158:	10 bf ff ca 	b  40012080 <rtems_rfs_group_bitmap_free+0x30> <== NOT EXECUTED
4001215c:	92 12 60 70 	or  %o1, 0x70, %o1                             <== NOT EXECUTED
                                                                      

40012160 <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) {
40012160:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
  unsigned int              group;                                    
  rtems_rfs_bitmap_bit      bit;                                      
  size_t                    size;                                     
  int                       rc;                                       
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))                
40012164:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
40012168:	13 00 00 80 	sethi  %hi(0x20000), %o1                       <== NOT EXECUTED
4001216c:	40 00 07 4e 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
40012170:	ba 10 00 18 	mov  %i0, %i5                                  <== NOT EXECUTED
40012174:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40012178:	02 80 00 0b 	be  400121a4 <rtems_rfs_group_bitmap_test+0x44><== NOT EXECUTED
4001217c:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
    printf ("rtems-rfs: group-bitmap-test: %s test: %" PRId32 "\n",   
40012180:	12 80 00 2f 	bne  4001223c <rtems_rfs_group_bitmap_test+0xdc><== NOT EXECUTED
40012184:	13 10 00 d7 	sethi  %hi(0x40035c00), %o1                    <== NOT EXECUTED
40012188:	13 10 00 d7 	sethi  %hi(0x40035c00), %o1                    <== NOT EXECUTED
4001218c:	92 12 60 78 	or  %o1, 0x78, %o1	! 40035c78 <_CPU_Trap_slot_template+0x990><== NOT EXECUTED
40012190:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
40012194:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
40012198:	40 00 47 79 	call  40023f7c <printf>                        <== NOT EXECUTED
4001219c:	90 12 21 20 	or  %o0, 0x120, %o0                            <== NOT EXECUTED
            inode ? "inode" : "block", no);                           
                                                                      
  if (inode)                                                          
400121a0:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
400121a4:	22 80 00 0b 	be,a   400121d0 <rtems_rfs_group_bitmap_test+0x70><== NOT EXECUTED
400121a8:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           <== NOT EXECUTED
  {                                                                   
    if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (fs))) 
400121ac:	80 a6 a0 00 	cmp  %i2, 0                                    <== NOT EXECUTED
400121b0:	04 80 00 06 	ble  400121c8 <rtems_rfs_group_bitmap_test+0x68><== NOT EXECUTED
400121b4:	b0 10 20 16 	mov  0x16, %i0                                 <== NOT EXECUTED
400121b8:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        <== NOT EXECUTED
400121bc:	80 a6 80 01 	cmp  %i2, %g1                                  <== NOT EXECUTED
400121c0:	28 80 00 21 	bleu,a   40012244 <rtems_rfs_group_bitmap_test+0xe4><== NOT EXECUTED
400121c4:	f8 07 60 2c 	ld  [ %i5 + 0x2c ], %i4                        <== NOT EXECUTED
  rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);                
                                                                      
  rtems_rfs_bitmap_release_buffer (fs, bitmap);                       
                                                                      
  return rc;                                                          
}                                                                     
400121c8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400121cc:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    no -= RTEMS_RFS_ROOT_INO;                                         
    size = fs->group_inodes;                                          
  }                                                                   
  else                                                                
  {                                                                   
    if (no >= rtems_rfs_fs_blocks (fs))                               
400121d0:	80 a6 80 01 	cmp  %i2, %g1                                  <== NOT EXECUTED
400121d4:	1a bf ff fd 	bcc  400121c8 <rtems_rfs_group_bitmap_test+0x68><== NOT EXECUTED
400121d8:	b0 10 20 16 	mov  0x16, %i0                                 <== NOT EXECUTED
        return EINVAL;                                                
    size = fs->group_blocks;                                          
400121dc:	f8 07 60 28 	ld  [ %i5 + 0x28 ], %i4                        <== NOT EXECUTED
  }                                                                   
                                                                      
  group = no / size;                                                  
  bit = (rtems_rfs_bitmap_bit) (no % size);                           
400121e0:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
400121e4:	40 00 78 fc 	call  400305d4 <.urem>                         <== NOT EXECUTED
400121e8:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
    if (no >= rtems_rfs_fs_blocks (fs))                               
        return EINVAL;                                                
    size = fs->group_blocks;                                          
  }                                                                   
                                                                      
  group = no / size;                                                  
400121ec:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
  bit = (rtems_rfs_bitmap_bit) (no % size);                           
400121f0:	b2 10 00 08 	mov  %o0, %i1                                  <== NOT EXECUTED
    if (no >= rtems_rfs_fs_blocks (fs))                               
        return EINVAL;                                                
    size = fs->group_blocks;                                          
  }                                                                   
                                                                      
  group = no / size;                                                  
400121f4:	7f ff c1 2b 	call  400026a0 <.udiv>                         <== NOT EXECUTED
400121f8:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
  bit = (rtems_rfs_bitmap_bit) (no % size);                           
                                                                      
  if (inode)                                                          
    bitmap = &fs->groups[group].inode_bitmap;                         
  else                                                                
    bitmap = &fs->groups[group].block_bitmap;                         
400121fc:	f8 07 60 20 	ld  [ %i5 + 0x20 ], %i4                        <== NOT EXECUTED
40012200:	83 2a 20 04 	sll  %o0, 4, %g1                               <== NOT EXECUTED
40012204:	91 2a 20 06 	sll  %o0, 6, %o0                               <== NOT EXECUTED
40012208:	90 00 40 08 	add  %g1, %o0, %o0                             <== NOT EXECUTED
4001220c:	b8 07 00 08 	add  %i4, %o0, %i4                             <== NOT EXECUTED
40012210:	b8 07 20 08 	add  %i4, 8, %i4                               <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);                
40012214:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
40012218:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
4001221c:	40 00 23 06 	call  4001ae34 <rtems_rfs_bitmap_map_test>     <== NOT EXECUTED
40012220:	94 10 00 1b 	mov  %i3, %o2                                  <== NOT EXECUTED
                                                                      
  rtems_rfs_bitmap_release_buffer (fs, bitmap);                       
40012224:	d2 07 00 00 	ld  [ %i4 ], %o1                               <== 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);                
40012228:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
                                                                      
  rtems_rfs_bitmap_release_buffer (fs, bitmap);                       
4001222c:	40 00 28 83 	call  4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40012230:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
                                                                      
  return rc;                                                          
}                                                                     
40012234:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40012238:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  rtems_rfs_bitmap_bit      bit;                                      
  size_t                    size;                                     
  int                       rc;                                       
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))                
    printf ("rtems-rfs: group-bitmap-test: %s test: %" PRId32 "\n",   
4001223c:	10 bf ff d5 	b  40012190 <rtems_rfs_group_bitmap_test+0x30> <== NOT EXECUTED
40012240:	92 12 60 70 	or  %o1, 0x70, %o1                             <== NOT EXECUTED
                                                                      
  if (inode)                                                          
  {                                                                   
    if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (fs))) 
        return EINVAL;                                                
    no -= RTEMS_RFS_ROOT_INO;                                         
40012244:	b4 06 bf ff 	add  %i2, -1, %i2                              <== NOT EXECUTED
        return EINVAL;                                                
    size = fs->group_blocks;                                          
  }                                                                   
                                                                      
  group = no / size;                                                  
  bit = (rtems_rfs_bitmap_bit) (no % size);                           
40012248:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
4001224c:	40 00 78 e2 	call  400305d4 <.urem>                         <== NOT EXECUTED
40012250:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
    if (no >= rtems_rfs_fs_blocks (fs))                               
        return EINVAL;                                                
    size = fs->group_blocks;                                          
  }                                                                   
                                                                      
  group = no / size;                                                  
40012254:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
  bit = (rtems_rfs_bitmap_bit) (no % size);                           
40012258:	b2 10 00 08 	mov  %o0, %i1                                  <== NOT EXECUTED
    if (no >= rtems_rfs_fs_blocks (fs))                               
        return EINVAL;                                                
    size = fs->group_blocks;                                          
  }                                                                   
                                                                      
  group = no / size;                                                  
4001225c:	7f ff c1 11 	call  400026a0 <.udiv>                         <== NOT EXECUTED
40012260:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
  bit = (rtems_rfs_bitmap_bit) (no % size);                           
                                                                      
  if (inode)                                                          
    bitmap = &fs->groups[group].inode_bitmap;                         
40012264:	f8 07 60 20 	ld  [ %i5 + 0x20 ], %i4                        <== NOT EXECUTED
40012268:	83 2a 20 04 	sll  %o0, 4, %g1                               <== NOT EXECUTED
4001226c:	91 2a 20 06 	sll  %o0, 6, %o0                               <== NOT EXECUTED
40012270:	90 00 40 08 	add  %g1, %o0, %o0                             <== NOT EXECUTED
40012274:	b8 07 00 08 	add  %i4, %o0, %i4                             <== NOT EXECUTED
40012278:	10 bf ff e7 	b  40012214 <rtems_rfs_group_bitmap_test+0xb4> <== NOT EXECUTED
4001227c:	b8 07 20 2c 	add  %i4, 0x2c, %i4                            <== NOT EXECUTED
                                                                      

40011d68 <rtems_rfs_group_close>: int rtems_rfs_group_close (rtems_rfs_file_system* fs, rtems_rfs_group* group) {
40011d68:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int result = 0;                                                     
  int rc;                                                             
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_CLOSE))                  
40011d6c:	90 10 20 00 	clr  %o0                                       
40011d70:	13 00 00 40 	sethi  %hi(0x10000), %o1                       
40011d74:	40 00 08 4c 	call  40013ea4 <rtems_rfs_trace>               
40011d78:	ba 10 00 18 	mov  %i0, %i5                                  
40011d7c:	80 8a 20 ff 	btst  0xff, %o0                                
40011d80:	32 80 00 17 	bne,a   40011ddc <rtems_rfs_group_close+0x74>  <== NEVER TAKEN
40011d84:	d2 06 40 00 	ld  [ %i1 ], %o1                               <== 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);                 
40011d88:	40 00 25 24 	call  4001b218 <rtems_rfs_bitmap_close>        
40011d8c:	90 06 60 2c 	add  %i1, 0x2c, %o0                            
 */                                                                   
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);                       
40011d90:	92 06 60 44 	add  %i1, 0x44, %o1                            
40011d94:	b8 10 00 08 	mov  %o0, %i4                                  
40011d98:	40 00 29 a8 	call  4001c438 <rtems_rfs_buffer_handle_release>
40011d9c:	90 10 00 1d 	mov  %i5, %o0                                  
  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);                 
40011da0:	90 06 60 08 	add  %i1, 8, %o0                               
  handle->dirty = false;                                              
40011da4:	c0 2e 60 44 	clrb  [ %i1 + 0x44 ]                           
  handle->bnum  = 0;                                                  
40011da8:	c0 26 60 48 	clr  [ %i1 + 0x48 ]                            
40011dac:	40 00 25 1b 	call  4001b218 <rtems_rfs_bitmap_close>        
40011db0:	c0 26 60 4c 	clr  [ %i1 + 0x4c ]                            
  if (rc > 0)                                                         
40011db4:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40011db8:	04 80 00 0d 	ble  40011dec <rtems_rfs_group_close+0x84>     <== ALWAYS TAKEN
40011dbc:	90 10 00 1d 	mov  %i5, %o0                                  
 */                                                                   
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);                       
40011dc0:	40 00 29 9e 	call  4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40011dc4:	92 06 60 20 	add  %i1, 0x20, %o1                            <== NOT EXECUTED
  handle->dirty = false;                                              
40011dc8:	c0 2e 60 20 	clrb  [ %i1 + 0x20 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
40011dcc:	c0 26 60 24 	clr  [ %i1 + 0x24 ]                            <== NOT EXECUTED
  handle->buffer = NULL;                                              
40011dd0:	c0 26 60 28 	clr  [ %i1 + 0x28 ]                            <== NOT EXECUTED
  rc = rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
  if (rc > 0)                                                         
    result = rc;                                                      
                                                                      
  return result;                                                      
}                                                                     
40011dd4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40011dd8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
{                                                                     
  int result = 0;                                                     
  int rc;                                                             
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_CLOSE))                  
    printf ("rtems-rfs: group-close: base=%" PRId32 "\n", group->base);
40011ddc:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
40011de0:	40 00 48 67 	call  40023f7c <printf>                        <== NOT EXECUTED
40011de4:	90 12 20 48 	or  %o0, 0x48, %o0	! 40035c48 <_CPU_Trap_slot_template+0x960><== NOT EXECUTED
40011de8:	30 bf ff e8 	b,a   40011d88 <rtems_rfs_group_close+0x20>    <== NOT EXECUTED
40011dec:	b0 38 00 1c 	xnor  %g0, %i4, %i0                            
 */                                                                   
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);                       
40011df0:	92 06 60 20 	add  %i1, 0x20, %o1                            
40011df4:	40 00 29 91 	call  4001c438 <rtems_rfs_buffer_handle_release>
40011df8:	b1 3e 20 1f 	sra  %i0, 0x1f, %i0                            
40011dfc:	b0 0f 00 18 	and  %i4, %i0, %i0                             
  handle->dirty = false;                                              
40011e00:	c0 2e 60 20 	clrb  [ %i1 + 0x20 ]                           
  handle->bnum  = 0;                                                  
40011e04:	c0 26 60 24 	clr  [ %i1 + 0x24 ]                            
  handle->buffer = NULL;                                              
40011e08:	c0 26 60 28 	clr  [ %i1 + 0x28 ]                            
  rc = rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
  if (rc > 0)                                                         
    result = rc;                                                      
                                                                      
  return result;                                                      
}                                                                     
40011e0c:	81 c7 e0 08 	ret                                            
40011e10:	81 e8 00 00 	restore                                        
                                                                      

40011b34 <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) {
40011b34:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rc;                                                             
                                                                      
  if (base >= rtems_rfs_fs_blocks (fs))                               
40011b38:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
40011b3c:	80 a0 40 19 	cmp  %g1, %i1                                  
40011b40:	08 80 00 44 	bleu  40011c50 <rtems_rfs_group_open+0x11c>    <== NEVER TAKEN
40011b44:	ba 10 00 18 	mov  %i0, %i5                                  
      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))                      
40011b48:	84 06 80 19 	add  %i2, %i1, %g2                             
40011b4c:	80 a0 40 02 	cmp  %g1, %g2                                  
40011b50:	28 80 00 02 	bleu,a   40011b58 <rtems_rfs_group_open+0x24>  <== ALWAYS TAKEN
40011b54:	b4 20 40 19 	sub  %g1, %i1, %i2                             
40011b58:	80 a6 80 1b 	cmp  %i2, %i3                                  
40011b5c:	18 80 00 25 	bgu  40011bf0 <rtems_rfs_group_open+0xbc>      <== ALWAYS TAKEN
40011b60:	a2 10 00 1a 	mov  %i2, %l1                                  
   * the format configuration needs reviewing.                        
   */                                                                 
  if (inodes > size)                                                  
    inodes = size;                                                    
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))                   
40011b64:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
40011b68:	40 00 08 cf 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
40011b6c:	13 00 00 20 	sethi  %hi(0x8000), %o1                        <== NOT EXECUTED
40011b70:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40011b74:	12 80 00 27 	bne  40011c10 <rtems_rfs_group_open+0xdc>      <== NOT EXECUTED
40011b78:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
    printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
            base, size, inodes);                                      
                                                                      
  group->base = base;                                                 
40011b7c:	f2 27 00 00 	st  %i1, [ %i4 ]                               <== NOT EXECUTED
  group->size = size;                                                 
40011b80:	f4 27 20 04 	st  %i2, [ %i4 + 4 ]                           
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
40011b84:	c0 2f 20 20 	clrb  [ %i4 + 0x20 ]                           
  handle->bnum  = 0;                                                  
40011b88:	c0 27 20 24 	clr  [ %i4 + 0x24 ]                            
  handle->buffer = NULL;                                              
40011b8c:	c0 27 20 28 	clr  [ %i4 + 0x28 ]                            
      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,               
40011b90:	a0 07 20 08 	add  %i4, 8, %l0                               
40011b94:	b6 07 20 20 	add  %i4, 0x20, %i3                            
40011b98:	90 10 00 10 	mov  %l0, %o0                                  
40011b9c:	92 10 00 1d 	mov  %i5, %o1                                  
40011ba0:	94 10 00 1b 	mov  %i3, %o2                                  
40011ba4:	96 10 00 1a 	mov  %i2, %o3                                  
40011ba8:	40 00 25 8b 	call  4001b1d4 <rtems_rfs_bitmap_open>         
40011bac:	98 10 00 19 	mov  %i1, %o4                                  
                              &group->block_bitmap_buffer, size,      
                              group->base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
  if (rc > 0)                                                         
40011bb0:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40011bb4:	04 80 00 37 	ble  40011c90 <rtems_rfs_group_open+0x15c>     <== ALWAYS TAKEN
40011bb8:	92 10 00 1b 	mov  %i3, %o1                                  
 */                                                                   
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);                       
40011bbc:	40 00 2a 1f 	call  4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40011bc0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);  
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))                 
40011bc4:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
40011bc8:	13 00 00 20 	sethi  %hi(0x8000), %o1                        <== NOT EXECUTED
  handle->dirty = false;                                              
40011bcc:	c0 2f 20 20 	clrb  [ %i4 + 0x20 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
40011bd0:	c0 27 20 24 	clr  [ %i4 + 0x24 ]                            <== NOT EXECUTED
40011bd4:	40 00 08 b4 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
40011bd8:	c0 27 20 28 	clr  [ %i4 + 0x28 ]                            <== NOT EXECUTED
40011bdc:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40011be0:	12 80 00 13 	bne  40011c2c <rtems_rfs_group_open+0xf8>      <== NOT EXECUTED
40011be4:	01 00 00 00 	nop                                            <== NOT EXECUTED
    rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);       
    rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);       
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
40011be8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40011bec:	81 e8 00 00 	restore                                        <== NOT EXECUTED
   * the format configuration needs reviewing.                        
   */                                                                 
  if (inodes > size)                                                  
    inodes = size;                                                    
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))                   
40011bf0:	90 10 20 00 	clr  %o0                                       
40011bf4:	13 00 00 20 	sethi  %hi(0x8000), %o1                        
40011bf8:	40 00 08 ab 	call  40013ea4 <rtems_rfs_trace>               
40011bfc:	a2 10 00 1b 	mov  %i3, %l1                                  
40011c00:	80 8a 20 ff 	btst  0xff, %o0                                
40011c04:	22 bf ff df 	be,a   40011b80 <rtems_rfs_group_open+0x4c>    <== ALWAYS TAKEN
40011c08:	f2 27 00 00 	st  %i1, [ %i4 ]                               
    printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
40011c0c:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
40011c10:	11 10 00 d6 	sethi  %hi(0x40035800), %o0                    <== NOT EXECUTED
40011c14:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
40011c18:	96 10 00 11 	mov  %l1, %o3                                  <== NOT EXECUTED
40011c1c:	40 00 48 d8 	call  40023f7c <printf>                        <== NOT EXECUTED
40011c20:	90 12 23 90 	or  %o0, 0x390, %o0                            <== NOT EXECUTED
            base, size, inodes);                                      
                                                                      
  group->base = base;                                                 
40011c24:	10 bf ff d7 	b  40011b80 <rtems_rfs_group_open+0x4c>        <== NOT EXECUTED
40011c28:	f2 27 00 00 	st  %i1, [ %i4 ]                               <== NOT EXECUTED
                              group->base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);  
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))                 
      printf ("rtems-rfs: group-open: could not open block bitmap: %d: %s\n",
40011c2c:	40 00 4d 1e 	call  400250a4 <strerror>                      <== NOT EXECUTED
40011c30:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40011c34:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
40011c38:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40011c3c:	11 10 00 d6 	sethi  %hi(0x40035800), %o0                    <== NOT EXECUTED
40011c40:	40 00 48 cf 	call  40023f7c <printf>                        <== NOT EXECUTED
40011c44:	90 12 23 c8 	or  %o0, 0x3c8, %o0	! 40035bc8 <_CPU_Trap_slot_template+0x8e0><== NOT EXECUTED
40011c48:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40011c4c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
{                                                                     
  int rc;                                                             
                                                                      
  if (base >= rtems_rfs_fs_blocks (fs))                               
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))                 
40011c50:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
40011c54:	13 00 00 20 	sethi  %hi(0x8000), %o1                        <== NOT EXECUTED
40011c58:	40 00 08 93 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
40011c5c:	b0 10 20 05 	mov  5, %i0                                    <== NOT EXECUTED
40011c60:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40011c64:	02 80 00 3f 	be  40011d60 <rtems_rfs_group_open+0x22c>      <== NOT EXECUTED
40011c68:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
40011c6c:	40 00 4d 0e 	call  400250a4 <strerror>                      <== NOT EXECUTED
40011c70:	90 10 20 05 	mov  5, %o0	! 5 <PROM_START+0x5>               <== NOT EXECUTED
40011c74:	92 10 20 05 	mov  5, %o1                                    <== NOT EXECUTED
40011c78:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40011c7c:	11 10 00 d6 	sethi  %hi(0x40035800), %o0                    <== NOT EXECUTED
40011c80:	40 00 48 bf 	call  40023f7c <printf>                        <== NOT EXECUTED
40011c84:	90 12 23 50 	or  %o0, 0x350, %o0	! 40035b50 <_CPU_Trap_slot_template+0x868><== NOT EXECUTED
40011c88:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40011c8c:	81 e8 00 00 	restore                                        <== 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,               
40011c90:	d8 07 00 00 	ld  [ %i4 ], %o4                               
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
40011c94:	c0 2f 20 44 	clrb  [ %i4 + 0x44 ]                           
  handle->bnum  = 0;                                                  
40011c98:	c0 27 20 48 	clr  [ %i4 + 0x48 ]                            
  handle->buffer = NULL;                                              
40011c9c:	c0 27 20 4c 	clr  [ %i4 + 0x4c ]                            
40011ca0:	b4 07 20 44 	add  %i4, 0x44, %i2                            
40011ca4:	90 07 20 2c 	add  %i4, 0x2c, %o0                            
40011ca8:	92 10 00 1d 	mov  %i5, %o1                                  
40011cac:	94 10 00 1a 	mov  %i2, %o2                                  
40011cb0:	96 10 00 11 	mov  %l1, %o3                                  
40011cb4:	40 00 25 48 	call  4001b1d4 <rtems_rfs_bitmap_open>         
40011cb8:	98 03 20 01 	inc  %o4                                       
                              &group->inode_bitmap_buffer, inodes,    
                              group->base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
  if (rc > 0)                                                         
40011cbc:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40011cc0:	04 80 00 1e 	ble  40011d38 <rtems_rfs_group_open+0x204>     <== ALWAYS TAKEN
40011cc4:	92 10 00 1a 	mov  %i2, %o1                                  
 */                                                                   
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);                       
40011cc8:	40 00 29 dc 	call  4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40011ccc:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &group->inode_bitmap_buffer);  
    rtems_rfs_bitmap_close (&group->block_bitmap);                    
40011cd0:	90 10 00 10 	mov  %l0, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
40011cd4:	c0 2f 20 44 	clrb  [ %i4 + 0x44 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
40011cd8:	c0 27 20 48 	clr  [ %i4 + 0x48 ]                            <== NOT EXECUTED
40011cdc:	40 00 25 4f 	call  4001b218 <rtems_rfs_bitmap_close>        <== NOT EXECUTED
40011ce0:	c0 27 20 4c 	clr  [ %i4 + 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);                       
40011ce4:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
40011ce8:	40 00 29 d4 	call  4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40011cec:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
    rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);  
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))                 
40011cf0:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
40011cf4:	13 00 00 20 	sethi  %hi(0x8000), %o1                        <== NOT EXECUTED
  handle->dirty = false;                                              
40011cf8:	c0 2f 20 20 	clrb  [ %i4 + 0x20 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
40011cfc:	c0 27 20 24 	clr  [ %i4 + 0x24 ]                            <== NOT EXECUTED
40011d00:	40 00 08 69 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
40011d04:	c0 27 20 28 	clr  [ %i4 + 0x28 ]                            <== NOT EXECUTED
40011d08:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40011d0c:	02 80 00 15 	be  40011d60 <rtems_rfs_group_open+0x22c>      <== NOT EXECUTED
40011d10:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: group-open: could not open inode bitmap: %d: %s\n",
40011d14:	40 00 4c e4 	call  400250a4 <strerror>                      <== NOT EXECUTED
40011d18:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40011d1c:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
40011d20:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40011d24:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
40011d28:	40 00 48 95 	call  40023f7c <printf>                        <== NOT EXECUTED
40011d2c:	90 12 20 08 	or  %o0, 8, %o0	! 40035c08 <_CPU_Trap_slot_template+0x920><== NOT EXECUTED
40011d30:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40011d34:	81 e8 00 00 	restore                                        <== NOT EXECUTED
              rc, strerror (rc));                                     
    return rc;                                                        
  }                                                                   
                                                                      
  if (rtems_rfs_fs_release_bitmaps (fs))                              
40011d38:	c2 07 40 00 	ld  [ %i5 ], %g1                               
40011d3c:	80 88 60 01 	btst  1, %g1                                   
40011d40:	12 bf ff aa 	bne  40011be8 <rtems_rfs_group_open+0xb4>      <== NEVER TAKEN
40011d44:	b0 10 20 00 	clr  %i0                                       
  {                                                                   
    rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);       
40011d48:	d2 07 20 08 	ld  [ %i4 + 8 ], %o1                           
40011d4c:	40 00 29 bb 	call  4001c438 <rtems_rfs_buffer_handle_release>
40011d50:	90 10 00 1d 	mov  %i5, %o0                                  
    rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);       
40011d54:	d2 07 20 2c 	ld  [ %i4 + 0x2c ], %o1                        
40011d58:	40 00 29 b8 	call  4001c438 <rtems_rfs_buffer_handle_release>
40011d5c:	90 10 00 1d 	mov  %i5, %o0                                  
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
40011d60:	81 c7 e0 08 	ret                                            
40011d64:	81 e8 00 00 	restore                                        
                                                                      

40012280 <rtems_rfs_group_usage>: size_t* blocks, size_t* inodes) { int g; *blocks = 0;
40012280:	c0 22 40 00 	clr  [ %o1 ]                                   <== NOT EXECUTED
  *inodes = 0;                                                        
40012284:	c0 22 80 00 	clr  [ %o2 ]                                   <== NOT EXECUTED
                                                                      
  for (g = 0; g < fs->group_count; g++)                               
40012288:	c2 02 20 24 	ld  [ %o0 + 0x24 ], %g1                        <== NOT EXECUTED
4001228c:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40012290:	04 80 00 14 	ble  400122e0 <rtems_rfs_group_usage+0x60>     <== NOT EXECUTED
40012294:	84 10 20 00 	clr  %g2                                       <== NOT EXECUTED
40012298:	c2 02 20 20 	ld  [ %o0 + 0x20 ], %g1                        <== NOT EXECUTED
  {                                                                   
    rtems_rfs_group* group = &fs->groups[g];                          
    *blocks +=                                                        
      rtems_rfs_bitmap_map_size(&group->block_bitmap) -               
4001229c:	da 00 60 14 	ld  [ %g1 + 0x14 ], %o5                        <== NOT EXECUTED
  *inodes = 0;                                                        
                                                                      
  for (g = 0; g < fs->group_count; g++)                               
  {                                                                   
    rtems_rfs_group* group = &fs->groups[g];                          
    *blocks +=                                                        
400122a0:	c8 00 60 18 	ld  [ %g1 + 0x18 ], %g4                        <== NOT EXECUTED
      rtems_rfs_bitmap_map_size(&group->block_bitmap) -               
400122a4:	c6 02 40 00 	ld  [ %o1 ], %g3                               <== NOT EXECUTED
  int g;                                                              
                                                                      
  *blocks = 0;                                                        
  *inodes = 0;                                                        
                                                                      
  for (g = 0; g < fs->group_count; g++)                               
400122a8:	84 00 a0 01 	inc  %g2                                       <== NOT EXECUTED
  {                                                                   
    rtems_rfs_group* group = &fs->groups[g];                          
    *blocks +=                                                        
      rtems_rfs_bitmap_map_size(&group->block_bitmap) -               
400122ac:	86 03 40 03 	add  %o5, %g3, %g3                             <== NOT EXECUTED
  *inodes = 0;                                                        
                                                                      
  for (g = 0; g < fs->group_count; g++)                               
  {                                                                   
    rtems_rfs_group* group = &fs->groups[g];                          
    *blocks +=                                                        
400122b0:	86 20 c0 04 	sub  %g3, %g4, %g3                             <== NOT EXECUTED
400122b4:	c6 22 40 00 	st  %g3, [ %o1 ]                               <== NOT EXECUTED
      rtems_rfs_bitmap_map_size(&group->block_bitmap) -               
      rtems_rfs_bitmap_map_free (&group->block_bitmap);               
    *inodes +=                                                        
      rtems_rfs_bitmap_map_size (&group->inode_bitmap) -              
400122b8:	da 00 60 38 	ld  [ %g1 + 0x38 ], %o5                        <== NOT EXECUTED
  {                                                                   
    rtems_rfs_group* group = &fs->groups[g];                          
    *blocks +=                                                        
      rtems_rfs_bitmap_map_size(&group->block_bitmap) -               
      rtems_rfs_bitmap_map_free (&group->block_bitmap);               
    *inodes +=                                                        
400122bc:	c8 00 60 3c 	ld  [ %g1 + 0x3c ], %g4                        <== NOT EXECUTED
      rtems_rfs_bitmap_map_size (&group->inode_bitmap) -              
400122c0:	c6 02 80 00 	ld  [ %o2 ], %g3                               <== NOT EXECUTED
400122c4:	86 03 40 03 	add  %o5, %g3, %g3                             <== NOT EXECUTED
  {                                                                   
    rtems_rfs_group* group = &fs->groups[g];                          
    *blocks +=                                                        
      rtems_rfs_bitmap_map_size(&group->block_bitmap) -               
      rtems_rfs_bitmap_map_free (&group->block_bitmap);               
    *inodes +=                                                        
400122c8:	86 20 c0 04 	sub  %g3, %g4, %g3                             <== NOT EXECUTED
400122cc:	c6 22 80 00 	st  %g3, [ %o2 ]                               <== NOT EXECUTED
  int g;                                                              
                                                                      
  *blocks = 0;                                                        
  *inodes = 0;                                                        
                                                                      
  for (g = 0; g < fs->group_count; g++)                               
400122d0:	c6 02 20 24 	ld  [ %o0 + 0x24 ], %g3                        <== NOT EXECUTED
400122d4:	80 a0 c0 02 	cmp  %g3, %g2                                  <== NOT EXECUTED
400122d8:	14 bf ff f1 	bg  4001229c <rtems_rfs_group_usage+0x1c>      <== NOT EXECUTED
400122dc:	82 00 60 50 	add  %g1, 0x50, %g1                            <== 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))                             
400122e0:	c4 02 20 04 	ld  [ %o0 + 4 ], %g2                           <== NOT EXECUTED
400122e4:	c2 02 40 00 	ld  [ %o1 ], %g1                               <== NOT EXECUTED
400122e8:	80 a0 40 02 	cmp  %g1, %g2                                  <== NOT EXECUTED
400122ec:	38 80 00 02 	bgu,a   400122f4 <rtems_rfs_group_usage+0x74>  <== NOT EXECUTED
400122f0:	82 10 00 02 	mov  %g2, %g1                                  <== NOT EXECUTED
400122f4:	c2 22 40 00 	st  %g1, [ %o1 ]                               <== NOT EXECUTED
    *blocks = rtems_rfs_fs_blocks (fs);                               
  if (*inodes > rtems_rfs_fs_inodes (fs))                             
400122f8:	c4 02 20 14 	ld  [ %o0 + 0x14 ], %g2                        <== NOT EXECUTED
400122fc:	c2 02 80 00 	ld  [ %o2 ], %g1                               <== NOT EXECUTED
40012300:	80 a0 40 02 	cmp  %g1, %g2                                  <== NOT EXECUTED
40012304:	38 80 00 02 	bgu,a   4001230c <rtems_rfs_group_usage+0x8c>  <== NOT EXECUTED
40012308:	82 10 00 02 	mov  %g2, %g1                                  <== NOT EXECUTED
4001230c:	c2 22 80 00 	st  %g1, [ %o2 ]                               <== NOT EXECUTED
    *inodes = rtems_rfs_fs_inodes (fs);                               
                                                                      
  return 0;                                                           
}                                                                     
40012310:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
40012314:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
                                                                      

400125e8 <rtems_rfs_inode_close>: } int rtems_rfs_inode_close (rtems_rfs_file_system* fs, rtems_rfs_inode_handle* handle) {
400125e8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rc;                                                             
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))                  
400125ec:	90 10 20 00 	clr  %o0                                       
400125f0:	40 00 06 2d 	call  40013ea4 <rtems_rfs_trace>               
400125f4:	13 00 02 00 	sethi  %hi(0x80000), %o1                       
400125f8:	80 8a 20 ff 	btst  0xff, %o0                                
400125fc:	32 80 00 16 	bne,a   40012654 <rtems_rfs_inode_close+0x6c>  <== NEVER TAKEN
40012600:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
    printf ("rtems-rfs: inode-close: ino: %" PRIu32 "\n", handle->ino);
                                                                      
  rc = rtems_rfs_inode_unload (fs, handle, true);                     
40012604:	90 10 00 18 	mov  %i0, %o0                                  
40012608:	92 10 00 19 	mov  %i1, %o1                                  
4001260c:	7f ff ff b6 	call  400124e4 <rtems_rfs_inode_unload>        
40012610:	94 10 20 01 	mov  1, %o2                                    
                                                                      
  if ((rc == 0) && (handle->loads > 0))                               
40012614:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40012618:	32 80 00 0d 	bne,a   4001264c <rtems_rfs_inode_close+0x64>  <== NEVER TAKEN
4001261c:	c0 26 60 08 	clr  [ %i1 + 8 ]                               <== NOT EXECUTED
40012620:	c2 06 60 24 	ld  [ %i1 + 0x24 ], %g1                        
40012624:	80 a0 60 00 	cmp  %g1, 0                                    
40012628:	04 80 00 08 	ble  40012648 <rtems_rfs_inode_close+0x60>     <== ALWAYS TAKEN
4001262c:	90 10 20 00 	clr  %o0                                       
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))                
40012630:	13 00 02 00 	sethi  %hi(0x80000), %o1                       <== NOT EXECUTED
40012634:	40 00 06 1c 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
40012638:	b0 10 20 05 	mov  5, %i0                                    <== NOT EXECUTED
4001263c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40012640:	32 80 00 0a 	bne,a   40012668 <rtems_rfs_inode_close+0x80>  <== NOT EXECUTED
40012644:	d2 06 60 24 	ld  [ %i1 + 0x24 ], %o1                        <== NOT EXECUTED
      printf ("rtems-rfs: inode-close: bad loads number: %d\n",       
              handle->loads);                                         
    rc = EIO;                                                         
  }                                                                   
                                                                      
  handle->ino = 0;                                                    
40012648:	c0 26 60 08 	clr  [ %i1 + 8 ]                               
  return rc;                                                          
}                                                                     
4001264c:	81 c7 e0 08 	ret                                            
40012650:	81 e8 00 00 	restore                                        
                       rtems_rfs_inode_handle* handle)                
{                                                                     
  int rc;                                                             
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))                  
    printf ("rtems-rfs: inode-close: ino: %" PRIu32 "\n", handle->ino);
40012654:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
40012658:	40 00 46 49 	call  40023f7c <printf>                        <== NOT EXECUTED
4001265c:	90 12 21 f0 	or  %o0, 0x1f0, %o0	! 40035df0 <_CPU_Trap_slot_template+0xb08><== NOT EXECUTED
                                                                      
  rc = rtems_rfs_inode_unload (fs, handle, true);                     
40012660:	10 bf ff ea 	b  40012608 <rtems_rfs_inode_close+0x20>       <== NOT EXECUTED
40012664:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
                                                                      
  if ((rc == 0) && (handle->loads > 0))                               
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))                
      printf ("rtems-rfs: inode-close: bad loads number: %d\n",       
40012668:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
4001266c:	40 00 46 44 	call  40023f7c <printf>                        <== NOT EXECUTED
40012670:	90 12 22 18 	or  %o0, 0x218, %o0	! 40035e18 <_CPU_Trap_slot_template+0xb30><== NOT EXECUTED
              handle->loads);                                         
    rc = EIO;                                                         
  }                                                                   
                                                                      
  handle->ino = 0;                                                    
40012674:	c0 26 60 08 	clr  [ %i1 + 8 ]                               <== NOT EXECUTED
  return rc;                                                          
}                                                                     
40012678:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001267c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40012950 <rtems_rfs_inode_create>: uint16_t mode, uint16_t links, uid_t uid, gid_t gid, rtems_rfs_ino* ino) {
40012950:	9d e3 bf 50 	save  %sp, -176, %sp                           
  rtems_rfs_inode_handle parent_inode;                                
  rtems_rfs_inode_handle inode;                                       
  int                    rc;                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))                 
40012954:	90 10 20 00 	clr  %o0                                       
                        uint16_t                mode,                 
                        uint16_t                links,                
                        uid_t                   uid,                  
                        gid_t                   gid,                  
                        rtems_rfs_ino*          ino)                  
{                                                                     
40012958:	e4 17 a0 5e 	lduh  [ %fp + 0x5e ], %l2                      
4001295c:	e2 17 a0 62 	lduh  [ %fp + 0x62 ], %l1                      
  rtems_rfs_inode_handle parent_inode;                                
  rtems_rfs_inode_handle inode;                                       
  int                    rc;                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))                 
40012960:	13 00 10 00 	sethi  %hi(0x400000), %o1                      
40012964:	40 00 05 50 	call  40013ea4 <rtems_rfs_trace>               
40012968:	a6 0f 30 00 	and  %i4, -4096, %l3                           
4001296c:	80 8a 20 ff 	btst  0xff, %o0                                
40012970:	22 80 00 28 	be,a   40012a10 <rtems_rfs_inode_create+0xc0>  <== ALWAYS TAKEN
40012974:	a7 2c e0 10 	sll  %l3, 0x10, %l3                            
  {                                                                   
    const char* type = "unknown";                                     
    int         c;                                                    
    if (RTEMS_RFS_S_ISDIR (mode))                                     
40012978:	05 00 00 10 	sethi  %hi(0x4000), %g2                        <== NOT EXECUTED
4001297c:	80 a4 c0 02 	cmp  %l3, %g2                                  <== NOT EXECUTED
40012980:	02 80 00 4f 	be  40012abc <rtems_rfs_inode_create+0x16c>    <== NOT EXECUTED
40012984:	05 00 00 08 	sethi  %hi(0x2000), %g2                        <== NOT EXECUTED
      type = "dir";                                                   
    else if (RTEMS_RFS_S_ISCHR (mode))                                
40012988:	80 a4 c0 02 	cmp  %l3, %g2                                  <== NOT EXECUTED
4001298c:	02 80 00 52 	be  40012ad4 <rtems_rfs_inode_create+0x184>    <== NOT EXECUTED
40012990:	05 00 00 18 	sethi  %hi(0x6000), %g2                        <== NOT EXECUTED
      type = "char";                                                  
    else if (RTEMS_RFS_S_ISBLK (mode))                                
40012994:	80 a4 c0 02 	cmp  %l3, %g2                                  <== NOT EXECUTED
40012998:	02 80 00 4c 	be  40012ac8 <rtems_rfs_inode_create+0x178>    <== NOT EXECUTED
4001299c:	05 00 00 20 	sethi  %hi(0x8000), %g2                        <== NOT EXECUTED
      type = "block";                                                 
    else if (RTEMS_RFS_S_ISREG (mode))                                
400129a0:	80 a4 c0 02 	cmp  %l3, %g2                                  <== NOT EXECUTED
400129a4:	02 80 00 4f 	be  40012ae0 <rtems_rfs_inode_create+0x190>    <== NOT EXECUTED
400129a8:	05 00 00 28 	sethi  %hi(0xa000), %g2                        <== NOT EXECUTED
  rtems_rfs_inode_handle inode;                                       
  int                    rc;                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))                 
  {                                                                   
    const char* type = "unknown";                                     
400129ac:	29 10 00 d7 	sethi  %hi(0x40035c00), %l4                    <== NOT EXECUTED
      type = "char";                                                  
    else if (RTEMS_RFS_S_ISBLK (mode))                                
      type = "block";                                                 
    else if (RTEMS_RFS_S_ISREG (mode))                                
      type = "file";                                                  
    else if (RTEMS_RFS_S_ISLNK (mode))                                
400129b0:	80 a4 c0 02 	cmp  %l3, %g2                                  <== NOT EXECUTED
400129b4:	02 80 00 4e 	be  40012aec <rtems_rfs_inode_create+0x19c>    <== NOT EXECUTED
400129b8:	a8 15 22 90 	or  %l4, 0x290, %l4                            <== NOT EXECUTED
      type = "link";                                                  
    printf("rtems-rfs: inode-create: parent:%" PRIu32 " name:", parent);
400129bc:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
400129c0:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
400129c4:	40 00 45 6e 	call  40023f7c <printf>                        <== NOT EXECUTED
400129c8:	90 12 22 a0 	or  %o0, 0x2a0, %o0	! 40035ea0 <_CPU_Trap_slot_template+0xbb8><== NOT EXECUTED
    for (c = 0; c < length; c++)                                      
400129cc:	a0 10 20 00 	clr  %l0                                       <== NOT EXECUTED
400129d0:	80 a6 e0 00 	cmp  %i3, 0                                    <== NOT EXECUTED
400129d4:	02 80 00 08 	be  400129f4 <rtems_rfs_inode_create+0xa4>     <== NOT EXECUTED
400129d8:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
      printf ("%c", name[c]);                                         
400129dc:	d0 4e 80 01 	ldsb  [ %i2 + %g1 ], %o0                       <== NOT EXECUTED
400129e0:	40 00 45 d1 	call  40024124 <putchar>                       <== NOT EXECUTED
400129e4:	a0 04 20 01 	inc  %l0                                       <== NOT EXECUTED
    else if (RTEMS_RFS_S_ISREG (mode))                                
      type = "file";                                                  
    else if (RTEMS_RFS_S_ISLNK (mode))                                
      type = "link";                                                  
    printf("rtems-rfs: inode-create: parent:%" PRIu32 " name:", parent);
    for (c = 0; c < length; c++)                                      
400129e8:	80 a4 00 1b 	cmp  %l0, %i3                                  <== NOT EXECUTED
400129ec:	12 bf ff fc 	bne  400129dc <rtems_rfs_inode_create+0x8c>    <== NOT EXECUTED
400129f0:	82 10 00 10 	mov  %l0, %g1                                  <== NOT EXECUTED
      printf ("%c", name[c]);                                         
    printf (" type:%s mode:%04x (%03o)\n", type, mode, mode & ((1 << 10) - 1));
400129f4:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
400129f8:	92 10 00 14 	mov  %l4, %o1                                  <== NOT EXECUTED
400129fc:	90 12 22 d0 	or  %o0, 0x2d0, %o0                            <== NOT EXECUTED
40012a00:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
40012a04:	40 00 45 5e 	call  40023f7c <printf>                        <== NOT EXECUTED
40012a08:	96 0f 23 ff 	and  %i4, 0x3ff, %o3                           <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * The file type is field within the mode. Check we have a sane mode set.
   */                                                                 
  switch (mode & RTEMS_RFS_S_IFMT)                                    
40012a0c:	a7 2c e0 10 	sll  %l3, 0x10, %l3                            <== NOT EXECUTED
40012a10:	05 00 00 18 	sethi  %hi(0x6000), %g2                        
40012a14:	83 34 e0 10 	srl  %l3, 0x10, %g1                            
40012a18:	80 a0 40 02 	cmp  %g1, %g2                                  
40012a1c:	02 80 00 15 	be  40012a70 <rtems_rfs_inode_create+0x120>    <== NEVER TAKEN
40012a20:	d4 07 a0 64 	ld  [ %fp + 0x64 ], %o2                        
40012a24:	08 80 00 0c 	bleu  40012a54 <rtems_rfs_inode_create+0x104>  
40012a28:	05 00 00 08 	sethi  %hi(0x2000), %g2                        
40012a2c:	05 00 00 20 	sethi  %hi(0x8000), %g2                        
40012a30:	80 a0 40 02 	cmp  %g1, %g2                                  
40012a34:	02 80 00 0f 	be  40012a70 <rtems_rfs_inode_create+0x120>    
40012a38:	05 00 00 28 	sethi  %hi(0xa000), %g2                        
40012a3c:	80 a0 40 02 	cmp  %g1, %g2                                  
40012a40:	02 80 00 0d 	be  40012a74 <rtems_rfs_inode_create+0x124>    <== ALWAYS TAKEN
40012a44:	90 10 00 18 	mov  %i0, %o0                                  
    case RTEMS_RFS_S_IFBLK:                                           
    case RTEMS_RFS_S_IFREG:                                           
    case RTEMS_RFS_S_IFLNK:                                           
      break;                                                          
    default:                                                          
      return EINVAL;                                                  
40012a48:	a0 10 20 16 	mov  0x16, %l0                                 <== NOT EXECUTED
    rtems_rfs_inode_free (fs, *ino);                                  
    return rc;                                                        
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
40012a4c:	81 c7 e0 08 	ret                                            
40012a50:	91 e8 00 10 	restore  %g0, %l0, %o0                         
  }                                                                   
                                                                      
  /*                                                                  
   * The file type is field within the mode. Check we have a sane mode set.
   */                                                                 
  switch (mode & RTEMS_RFS_S_IFMT)                                    
40012a54:	80 a0 40 02 	cmp  %g1, %g2                                  
40012a58:	02 80 00 05 	be  40012a6c <rtems_rfs_inode_create+0x11c>    <== NEVER TAKEN
40012a5c:	05 00 00 10 	sethi  %hi(0x4000), %g2                        
40012a60:	80 a0 40 02 	cmp  %g1, %g2                                  
40012a64:	12 bf ff fa 	bne  40012a4c <rtems_rfs_inode_create+0xfc>    <== NEVER TAKEN
40012a68:	a0 10 20 16 	mov  0x16, %l0                                 
      break;                                                          
    default:                                                          
      return EINVAL;                                                  
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_alloc (fs, parent, ino);                       
40012a6c:	d4 07 a0 64 	ld  [ %fp + 0x64 ], %o2                        
40012a70:	90 10 00 18 	mov  %i0, %o0                                  
40012a74:	7f ff fe 29 	call  40012318 <rtems_rfs_inode_alloc>         
40012a78:	92 10 00 19 	mov  %i1, %o1                                  
  if (rc > 0)                                                         
40012a7c:	a0 92 20 00 	orcc  %o0, 0, %l0                              
40012a80:	14 bf ff f3 	bg  40012a4c <rtems_rfs_inode_create+0xfc>     
40012a84:	c2 07 a0 64 	ld  [ %fp + 0x64 ], %g1                        
    return rc;                                                        
                                                                      
  rc = rtems_rfs_inode_open (fs, *ino, &inode, true);                 
40012a88:	90 10 00 18 	mov  %i0, %o0                                  
40012a8c:	d2 00 40 00 	ld  [ %g1 ], %o1                               
40012a90:	94 07 bf d8 	add  %fp, -40, %o2                             
40012a94:	7f ff fe 5d 	call  40012408 <rtems_rfs_inode_open>          
40012a98:	96 10 20 01 	mov  1, %o3                                    
  if (rc > 0)                                                         
40012a9c:	a0 92 20 00 	orcc  %o0, 0, %l0                              
40012aa0:	04 80 00 16 	ble  40012af8 <rtems_rfs_inode_create+0x1a8>   <== ALWAYS TAKEN
40012aa4:	90 07 bf d8 	add  %fp, -40, %o0                             
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_inode_free (fs, *ino);                                  
40012aa8:	c2 07 a0 64 	ld  [ %fp + 0x64 ], %g1                        <== NOT EXECUTED
40012aac:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40012ab0:	7f ff fe 24 	call  40012340 <rtems_rfs_inode_free>          <== NOT EXECUTED
40012ab4:	d2 00 40 00 	ld  [ %g1 ], %o1                               <== NOT EXECUTED
40012ab8:	30 bf ff e5 	b,a   40012a4c <rtems_rfs_inode_create+0xfc>   <== NOT EXECUTED
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))                 
  {                                                                   
    const char* type = "unknown";                                     
    int         c;                                                    
    if (RTEMS_RFS_S_ISDIR (mode))                                     
      type = "dir";                                                   
40012abc:	29 10 00 d7 	sethi  %hi(0x40035c00), %l4                    <== NOT EXECUTED
40012ac0:	10 bf ff bf 	b  400129bc <rtems_rfs_inode_create+0x6c>      <== NOT EXECUTED
40012ac4:	a8 15 22 78 	or  %l4, 0x278, %l4	! 40035e78 <_CPU_Trap_slot_template+0xb90><== NOT EXECUTED
    else if (RTEMS_RFS_S_ISCHR (mode))                                
      type = "char";                                                  
    else if (RTEMS_RFS_S_ISBLK (mode))                                
      type = "block";                                                 
40012ac8:	29 10 00 d7 	sethi  %hi(0x40035c00), %l4                    <== NOT EXECUTED
40012acc:	10 bf ff bc 	b  400129bc <rtems_rfs_inode_create+0x6c>      <== NOT EXECUTED
40012ad0:	a8 15 20 78 	or  %l4, 0x78, %l4	! 40035c78 <_CPU_Trap_slot_template+0x990><== NOT EXECUTED
    const char* type = "unknown";                                     
    int         c;                                                    
    if (RTEMS_RFS_S_ISDIR (mode))                                     
      type = "dir";                                                   
    else if (RTEMS_RFS_S_ISCHR (mode))                                
      type = "char";                                                  
40012ad4:	29 10 00 d7 	sethi  %hi(0x40035c00), %l4                    <== NOT EXECUTED
40012ad8:	10 bf ff b9 	b  400129bc <rtems_rfs_inode_create+0x6c>      <== NOT EXECUTED
40012adc:	a8 15 22 80 	or  %l4, 0x280, %l4	! 40035e80 <_CPU_Trap_slot_template+0xb98><== NOT EXECUTED
    else if (RTEMS_RFS_S_ISBLK (mode))                                
      type = "block";                                                 
    else if (RTEMS_RFS_S_ISREG (mode))                                
      type = "file";                                                  
40012ae0:	29 10 00 d7 	sethi  %hi(0x40035c00), %l4                    <== NOT EXECUTED
40012ae4:	10 bf ff b6 	b  400129bc <rtems_rfs_inode_create+0x6c>      <== NOT EXECUTED
40012ae8:	a8 15 22 88 	or  %l4, 0x288, %l4	! 40035e88 <_CPU_Trap_slot_template+0xba0><== NOT EXECUTED
    else if (RTEMS_RFS_S_ISLNK (mode))                                
      type = "link";                                                  
40012aec:	29 10 00 d7 	sethi  %hi(0x40035c00), %l4                    <== NOT EXECUTED
40012af0:	10 bf ff b3 	b  400129bc <rtems_rfs_inode_create+0x6c>      <== NOT EXECUTED
40012af4:	a8 15 22 98 	or  %l4, 0x298, %l4	! 40035e98 <_CPU_Trap_slot_template+0xbb0><== NOT EXECUTED
  {                                                                   
    rtems_rfs_inode_free (fs, *ino);                                  
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_initialise (&inode, links, mode, uid, gid);    
40012af8:	92 10 00 1d 	mov  %i5, %o1                                  
40012afc:	94 10 00 1c 	mov  %i4, %o2                                  
40012b00:	96 10 00 12 	mov  %l2, %o3                                  
40012b04:	7f ff ff 3d 	call  400127f8 <rtems_rfs_inode_initialise>    
40012b08:	98 10 00 11 	mov  %l1, %o4                                  
  if (rc > 0)                                                         
40012b0c:	a0 92 20 00 	orcc  %o0, 0, %l0                              
40012b10:	14 80 00 13 	bg  40012b5c <rtems_rfs_inode_create+0x20c>    <== NEVER TAKEN
40012b14:	03 10 00 00 	sethi  %hi(0x40000000), %g1                    
  /*                                                                  
   * 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))                                       
40012b18:	80 a4 c0 01 	cmp  %l3, %g1                                  
40012b1c:	02 80 00 45 	be  40012c30 <rtems_rfs_inode_create+0x2e0>    
40012b20:	c2 07 a0 64 	ld  [ %fp + 0x64 ], %g1                        
      rtems_rfs_inode_close (fs, &inode);                             
      return rc;                                                      
    }                                                                 
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);        
40012b24:	90 10 00 18 	mov  %i0, %o0                                  
40012b28:	92 10 00 19 	mov  %i1, %o1                                  
40012b2c:	94 07 bf b0 	add  %fp, -80, %o2                             
40012b30:	7f ff fe 36 	call  40012408 <rtems_rfs_inode_open>          
40012b34:	96 10 20 01 	mov  1, %o3                                    
  if (rc > 0)                                                         
40012b38:	a0 92 20 00 	orcc  %o0, 0, %l0                              
40012b3c:	04 80 00 10 	ble  40012b7c <rtems_rfs_inode_create+0x22c>   <== ALWAYS TAKEN
40012b40:	92 07 bf d8 	add  %fp, -40, %o1                             
  {                                                                   
    rtems_rfs_inode_delete (fs, &inode);                              
40012b44:	7f ff fe cf 	call  40012680 <rtems_rfs_inode_delete>        <== NOT EXECUTED
40012b48:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
    rtems_rfs_inode_close (fs, &inode);                               
40012b4c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40012b50:	7f ff fe a6 	call  400125e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
40012b54:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
40012b58:	30 bf ff bd 	b,a   40012a4c <rtems_rfs_inode_create+0xfc>   <== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_initialise (&inode, links, mode, uid, gid);    
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_inode_close (fs, &inode);                               
40012b5c:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
40012b60:	7f ff fe a2 	call  400125e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
40012b64:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
    rtems_rfs_inode_free (fs, *ino);                                  
40012b68:	c2 07 a0 64 	ld  [ %fp + 0x64 ], %g1                        <== NOT EXECUTED
40012b6c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40012b70:	7f ff fd f4 	call  40012340 <rtems_rfs_inode_free>          <== NOT EXECUTED
40012b74:	d2 00 40 00 	ld  [ %g1 ], %o1                               <== NOT EXECUTED
40012b78:	30 bf ff b5 	b,a   40012a4c <rtems_rfs_inode_create+0xfc>   <== NOT EXECUTED
    rtems_rfs_inode_delete (fs, &inode);                              
    rtems_rfs_inode_close (fs, &inode);                               
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, *ino);
40012b7c:	c2 07 a0 64 	ld  [ %fp + 0x64 ], %g1                        
40012b80:	90 10 00 18 	mov  %i0, %o0                                  
40012b84:	d8 00 40 00 	ld  [ %g1 ], %o4                               
40012b88:	92 07 bf b0 	add  %fp, -80, %o1                             
40012b8c:	94 10 00 1a 	mov  %i2, %o2                                  
40012b90:	40 00 29 e5 	call  4001d324 <rtems_rfs_dir_add_entry>       
40012b94:	96 10 00 1b 	mov  %i3, %o3                                  
  if (rc > 0)                                                         
40012b98:	a0 92 20 00 	orcc  %o0, 0, %l0                              
40012b9c:	14 80 00 3c 	bg  40012c8c <rtems_rfs_inode_create+0x33c>    <== NEVER TAKEN
40012ba0:	03 10 00 00 	sethi  %hi(0x40000000), %g1                    
                                                                      
  /*                                                                  
   * 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))                                       
40012ba4:	80 a4 c0 01 	cmp  %l3, %g1                                  
40012ba8:	12 80 00 15 	bne  40012bfc <rtems_rfs_inode_create+0x2ac>   
40012bac:	92 07 bf b0 	add  %fp, -80, %o1                             
 */                                                                   
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);                  
40012bb0:	c2 07 bf bc 	ld  [ %fp + -68 ], %g1                         
  if (links == 0xffff)                                                
    links = 0;                                                        
40012bb4:	09 3f ff c0 	sethi  %hi(0xffff0000), %g4                    
 */                                                                   
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);                  
40012bb8:	c6 08 40 00 	ldub  [ %g1 ], %g3                             
40012bbc:	c4 08 60 01 	ldub  [ %g1 + 1 ], %g2                         
40012bc0:	87 28 e0 08 	sll  %g3, 8, %g3                               
40012bc4:	84 10 c0 02 	or  %g3, %g2, %g2                              
  if (links == 0xffff)                                                
40012bc8:	87 28 a0 10 	sll  %g2, 0x10, %g3                            
40012bcc:	87 30 e0 10 	srl  %g3, 0x10, %g3                            
    links = 0;                                                        
40012bd0:	86 39 00 03 	xnor  %g4, %g3, %g3                            
40012bd4:	80 a0 00 03 	cmp  %g0, %g3                                  
40012bd8:	86 60 20 00 	subx  %g0, 0, %g3                              
40012bdc:	84 08 80 03 	and  %g2, %g3, %g2                             
    rtems_rfs_inode_set_links (&parent_inode,                         
40012be0:	84 00 a0 01 	inc  %g2                                       
 * @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);                  
40012be4:	87 30 a0 08 	srl  %g2, 8, %g3                               
40012be8:	c6 28 40 00 	stb  %g3, [ %g1 ]                              
40012bec:	c2 07 bf bc 	ld  [ %fp + -68 ], %g1                         
40012bf0:	c4 28 60 01 	stb  %g2, [ %g1 + 1 ]                          
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
40012bf4:	82 10 20 01 	mov  1, %g1                                    
40012bf8:	c2 2f bf c0 	stb  %g1, [ %fp + -64 ]                        
                               rtems_rfs_inode_get_links (&parent_inode) + 1);
                                                                      
  rc = rtems_rfs_inode_close (fs, &parent_inode);                     
40012bfc:	7f ff fe 7b 	call  400125e8 <rtems_rfs_inode_close>         
40012c00:	90 10 00 18 	mov  %i0, %o0                                  
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_inode_delete (fs, &inode);                              
40012c04:	92 07 bf d8 	add  %fp, -40, %o1                             
   */                                                                 
  if (RTEMS_RFS_S_ISDIR (mode))                                       
    rtems_rfs_inode_set_links (&parent_inode,                         
                               rtems_rfs_inode_get_links (&parent_inode) + 1);
                                                                      
  rc = rtems_rfs_inode_close (fs, &parent_inode);                     
40012c08:	a0 10 00 08 	mov  %o0, %l0                                  
  if (rc > 0)                                                         
40012c0c:	80 a4 20 00 	cmp  %l0, 0                                    
40012c10:	04 80 00 29 	ble  40012cb4 <rtems_rfs_inode_create+0x364>   <== ALWAYS TAKEN
40012c14:	90 10 00 18 	mov  %i0, %o0                                  
  {                                                                   
    rtems_rfs_inode_delete (fs, &inode);                              
40012c18:	7f ff fe 9a 	call  40012680 <rtems_rfs_inode_delete>        <== NOT EXECUTED
40012c1c:	01 00 00 00 	nop                                            <== NOT EXECUTED
    rtems_rfs_inode_close (fs, &inode);                               
40012c20:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40012c24:	7f ff fe 71 	call  400125e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
40012c28:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
40012c2c:	30 bf ff 88 	b,a   40012a4c <rtems_rfs_inode_create+0xfc>   <== NOT EXECUTED
   *                                                                  
   * The inode delete will free the inode.                            
   */                                                                 
  if (RTEMS_RFS_S_ISDIR (mode))                                       
  {                                                                   
    rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, *ino);          
40012c30:	90 10 00 18 	mov  %i0, %o0                                  
40012c34:	d8 00 40 00 	ld  [ %g1 ], %o4                               
40012c38:	92 07 bf d8 	add  %fp, -40, %o1                             
40012c3c:	96 10 20 01 	mov  1, %o3                                    
40012c40:	15 10 00 cf 	sethi  %hi(0x40033c00), %o2                    
40012c44:	40 00 29 b8 	call  4001d324 <rtems_rfs_dir_add_entry>       
40012c48:	94 12 a0 10 	or  %o2, 0x10, %o2	! 40033c10 <flashdisk_ops+0x1c>
    if (rc == 0)                                                      
40012c4c:	a0 92 20 00 	orcc  %o0, 0, %l0                              
40012c50:	12 80 00 0b 	bne  40012c7c <rtems_rfs_inode_create+0x32c>   <== NEVER TAKEN
40012c54:	80 a4 20 00 	cmp  %l0, 0                                    
      rc = rtems_rfs_dir_add_entry (fs, &inode, "..", 2, parent);     
40012c58:	90 10 00 18 	mov  %i0, %o0                                  
40012c5c:	92 07 bf d8 	add  %fp, -40, %o1                             
40012c60:	96 10 20 02 	mov  2, %o3                                    
40012c64:	15 10 00 cf 	sethi  %hi(0x40033c00), %o2                    
40012c68:	98 10 00 19 	mov  %i1, %o4                                  
40012c6c:	40 00 29 ae 	call  4001d324 <rtems_rfs_dir_add_entry>       
40012c70:	94 12 a0 18 	or  %o2, 0x18, %o2                             
40012c74:	a0 10 00 08 	mov  %o0, %l0                                  
    if (rc > 0)                                                       
40012c78:	80 a4 20 00 	cmp  %l0, 0                                    
40012c7c:	04 bf ff ab 	ble  40012b28 <rtems_rfs_inode_create+0x1d8>   <== ALWAYS TAKEN
40012c80:	90 10 00 18 	mov  %i0, %o0                                  
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);        
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_inode_delete (fs, &inode);                              
40012c84:	10 bf ff b0 	b  40012b44 <rtems_rfs_inode_create+0x1f4>     <== NOT EXECUTED
40012c88:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, *ino);
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_inode_delete (fs, &inode);                              
40012c8c:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
40012c90:	7f ff fe 7c 	call  40012680 <rtems_rfs_inode_delete>        <== NOT EXECUTED
40012c94:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
    rtems_rfs_inode_close (fs, &inode);                               
40012c98:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
40012c9c:	7f ff fe 53 	call  400125e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
40012ca0:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
    rtems_rfs_inode_close (fs, &parent_inode);                        
40012ca4:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40012ca8:	7f ff fe 50 	call  400125e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
40012cac:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
40012cb0:	30 bf ff 67 	b,a   40012a4c <rtems_rfs_inode_create+0xfc>   <== NOT EXECUTED
    rtems_rfs_inode_delete (fs, &inode);                              
    rtems_rfs_inode_close (fs, &inode);                               
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
40012cb4:	7f ff fe 4d 	call  400125e8 <rtems_rfs_inode_close>         
40012cb8:	01 00 00 00 	nop                                            
  if (rc > 0)                                                         
40012cbc:	a0 92 20 00 	orcc  %o0, 0, %l0                              
40012cc0:	14 bf ff 7b 	bg  40012aac <rtems_rfs_inode_create+0x15c>    <== NEVER TAKEN
40012cc4:	c2 07 a0 64 	ld  [ %fp + 0x64 ], %g1                        
  {                                                                   
    rtems_rfs_inode_free (fs, *ino);                                  
    return rc;                                                        
  }                                                                   
                                                                      
  return 0;                                                           
40012cc8:	10 bf ff 61 	b  40012a4c <rtems_rfs_inode_create+0xfc>      
40012ccc:	a0 10 20 00 	clr  %l0                                       
                                                                      

40012680 <rtems_rfs_inode_delete>: } int rtems_rfs_inode_delete (rtems_rfs_file_system* fs, rtems_rfs_inode_handle* handle) {
40012680:	9d e3 bf 50 	save  %sp, -176, %sp                           
  int rc = 0;                                                         
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))                 
40012684:	90 10 20 00 	clr  %o0                                       
40012688:	40 00 06 07 	call  40013ea4 <rtems_rfs_trace>               
4001268c:	13 00 20 00 	sethi  %hi(0x800000), %o1                      
40012690:	80 8a 20 ff 	btst  0xff, %o0                                
40012694:	02 80 00 0b 	be  400126c0 <rtems_rfs_inode_delete+0x40>     <== ALWAYS TAKEN
40012698:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
    printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",    
4001269c:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
400126a0:	02 80 00 13 	be  400126ec <rtems_rfs_inode_delete+0x6c>     <== NOT EXECUTED
400126a4:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
400126a8:	15 10 00 d7 	sethi  %hi(0x40035c00), %o2                    <== NOT EXECUTED
400126ac:	94 12 a1 50 	or  %o2, 0x150, %o2	! 40035d50 <_CPU_Trap_slot_template+0xa68><== NOT EXECUTED
400126b0:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
400126b4:	40 00 46 32 	call  40023f7c <printf>                        <== NOT EXECUTED
400126b8:	90 12 22 48 	or  %o0, 0x248, %o0	! 40035e48 <_CPU_Trap_slot_template+0xb60><== NOT EXECUTED
           rtems_rfs_inode_ino (handle),                              
           rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");        
                                                                      
  if (rtems_rfs_inode_is_loaded (handle))                             
400126bc:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         <== NOT EXECUTED
400126c0:	80 a0 60 00 	cmp  %g1, 0                                    
400126c4:	02 80 00 08 	be  400126e4 <rtems_rfs_inode_delete+0x64>     <== NEVER TAKEN
400126c8:	90 10 20 00 	clr  %o0                                       
    rtems_rfs_block_map map;                                          
                                                                      
    /*                                                                
     * Free the ino number.                                           
     */                                                               
    rc = rtems_rfs_inode_free (fs, handle->ino);                      
400126cc:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           
400126d0:	7f ff ff 1c 	call  40012340 <rtems_rfs_inode_free>          
400126d4:	90 10 00 18 	mov  %i0, %o0                                  
    if (rc > 0)                                                       
400126d8:	80 a2 20 00 	cmp  %o0, 0                                    
400126dc:	24 80 00 07 	ble,a   400126f8 <rtems_rfs_inode_delete+0x78> <== ALWAYS TAKEN
400126e0:	90 10 00 18 	mov  %i0, %o0                                  
      handle->loads = 0;                                              
      handle->node = NULL;                                            
    }                                                                 
  }                                                                   
  return rc;                                                          
}                                                                     
400126e4:	81 c7 e0 08 	ret                                            
400126e8:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                        rtems_rfs_inode_handle* handle)               
{                                                                     
  int rc = 0;                                                         
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))                 
    printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",    
400126ec:	15 10 00 d1 	sethi  %hi(0x40034400), %o2                    <== NOT EXECUTED
400126f0:	10 bf ff f0 	b  400126b0 <rtems_rfs_inode_delete+0x30>      <== NOT EXECUTED
400126f4:	94 12 a0 00 	mov  %o2, %o2	! 40034400 <__FUNCTION__.6193+0x338><== NOT EXECUTED
      return rc;                                                      
                                                                      
    /*                                                                
     * Free the blocks the inode may have attached.                   
     */                                                               
    rc = rtems_rfs_block_map_open (fs, handle, &map);                 
400126f8:	92 10 00 19 	mov  %i1, %o1                                  
400126fc:	40 00 23 c5 	call  4001b610 <rtems_rfs_block_map_open>      
40012700:	94 07 bf b0 	add  %fp, -80, %o2                             
    if (rc == 0)                                                      
40012704:	80 a2 20 00 	cmp  %o0, 0                                    
40012708:	12 bf ff f7 	bne  400126e4 <rtems_rfs_inode_delete+0x64>    <== NEVER TAKEN
4001270c:	92 07 bf b0 	add  %fp, -80, %o1                             
    {                                                                 
      int rrc;                                                        
      rrc = rtems_rfs_block_map_free_all (fs, &map);                  
40012710:	40 00 26 d7 	call  4001c26c <rtems_rfs_block_map_free_all>  
40012714:	90 10 00 18 	mov  %i0, %o0                                  
      rc = rtems_rfs_block_map_close (fs, &map);                      
40012718:	92 07 bf b0 	add  %fp, -80, %o1                             
4001271c:	40 00 24 1e 	call  4001b794 <rtems_rfs_block_map_close>     
40012720:	90 10 00 18 	mov  %i0, %o0                                  
      if (rc > 0)                                                     
        rrc = rc;                                                     
      memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);              
40012724:	d0 06 60 0c 	ld  [ %i1 + 0xc ], %o0                         
40012728:	92 10 20 ff 	mov  0xff, %o1                                 
4001272c:	40 00 45 96 	call  40023d84 <memset>                        
40012730:	94 10 20 38 	mov  0x38, %o2                                 
      rtems_rfs_buffer_mark_dirty (&handle->buffer);                  
40012734:	82 10 20 01 	mov  1, %g1                                    
      /*                                                              
       * 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);     
40012738:	90 10 00 18 	mov  %i0, %o0                                  
4001273c:	92 06 60 10 	add  %i1, 0x10, %o1                            
40012740:	40 00 27 3e 	call  4001c438 <rtems_rfs_buffer_handle_release>
40012744:	c2 2e 60 10 	stb  %g1, [ %i1 + 0x10 ]                       
      handle->loads = 0;                                              
40012748:	c0 26 60 24 	clr  [ %i1 + 0x24 ]                            
      handle->node = NULL;                                            
4001274c:	10 bf ff e6 	b  400126e4 <rtems_rfs_inode_delete+0x64>      
40012750:	c0 26 60 0c 	clr  [ %i1 + 0xc ]                             
                                                                      

40012354 <rtems_rfs_inode_load>: } int rtems_rfs_inode_load (rtems_rfs_file_system* fs, rtems_rfs_inode_handle* handle) {
40012354:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_LOAD))                   
40012358:	90 10 20 00 	clr  %o0                                       
4001235c:	40 00 06 d2 	call  40013ea4 <rtems_rfs_trace>               
40012360:	13 00 04 00 	sethi  %hi(0x100000), %o1                      
40012364:	80 8a 20 ff 	btst  0xff, %o0                                
40012368:	02 80 00 0c 	be  40012398 <rtems_rfs_inode_load+0x44>       <== ALWAYS TAKEN
4001236c:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
    printf ("rtems-rfs: inode-load: ino=%" PRIu32 " loads=%i loaded=%s\n",
40012370:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
40012374:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40012378:	02 80 00 11 	be  400123bc <rtems_rfs_inode_load+0x68>       <== NOT EXECUTED
4001237c:	d4 06 60 24 	ld  [ %i1 + 0x24 ], %o2                        <== NOT EXECUTED
40012380:	17 10 00 d7 	sethi  %hi(0x40035c00), %o3                    <== NOT EXECUTED
40012384:	96 12 e1 50 	or  %o3, 0x150, %o3	! 40035d50 <_CPU_Trap_slot_template+0xa68><== NOT EXECUTED
40012388:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
4001238c:	40 00 46 fc 	call  40023f7c <printf>                        <== NOT EXECUTED
40012390:	90 12 21 58 	or  %o0, 0x158, %o0	! 40035d58 <_CPU_Trap_slot_template+0xa70><== NOT EXECUTED
                                                                      
  /*                                                                  
   * An inode does not move so once loaded no need to do again.       
   */                                                                 
                                                                      
  if (!rtems_rfs_inode_is_loaded (handle))                            
40012394:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         <== NOT EXECUTED
40012398:	80 a0 60 00 	cmp  %g1, 0                                    
4001239c:	22 80 00 0b 	be,a   400123c8 <rtems_rfs_inode_load+0x74>    
400123a0:	d4 06 60 1c 	ld  [ %i1 + 0x1c ], %o2                        
                                                                      
    handle->node = rtems_rfs_buffer_data (&handle->buffer);           
    handle->node += handle->offset;                                   
  }                                                                   
                                                                      
  handle->loads++;                                                    
400123a4:	c2 06 60 24 	ld  [ %i1 + 0x24 ], %g1                        
                                                                      
  return 0;                                                           
400123a8:	b0 10 20 00 	clr  %i0                                       
                                                                      
    handle->node = rtems_rfs_buffer_data (&handle->buffer);           
    handle->node += handle->offset;                                   
  }                                                                   
                                                                      
  handle->loads++;                                                    
400123ac:	82 00 60 01 	inc  %g1                                       
400123b0:	c2 26 60 24 	st  %g1, [ %i1 + 0x24 ]                        
                                                                      
  return 0;                                                           
}                                                                     
400123b4:	81 c7 e0 08 	ret                                            
400123b8:	81 e8 00 00 	restore                                        
int                                                                   
rtems_rfs_inode_load (rtems_rfs_file_system*  fs,                     
                      rtems_rfs_inode_handle* handle)                 
{                                                                     
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_LOAD))                   
    printf ("rtems-rfs: inode-load: ino=%" PRIu32 " loads=%i loaded=%s\n",
400123bc:	17 10 00 d1 	sethi  %hi(0x40034400), %o3                    <== NOT EXECUTED
400123c0:	10 bf ff f2 	b  40012388 <rtems_rfs_inode_load+0x34>        <== NOT EXECUTED
400123c4:	96 12 e0 00 	mov  %o3, %o3	! 40034400 <__FUNCTION__.6193+0x338><== NOT EXECUTED
                                                                      
  if (!rtems_rfs_inode_is_loaded (handle))                            
  {                                                                   
    int rc;                                                           
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs,&handle->buffer,         
400123c8:	90 10 00 18 	mov  %i0, %o0                                  
400123cc:	92 06 60 10 	add  %i1, 0x10, %o1                            
400123d0:	40 00 28 94 	call  4001c620 <rtems_rfs_buffer_handle_request>
400123d4:	96 10 20 01 	mov  1, %o3                                    
                                          handle->block, true);       
    if (rc > 0)                                                       
400123d8:	b0 92 20 00 	orcc  %o0, 0, %i0                              
400123dc:	14 bf ff f6 	bg  400123b4 <rtems_rfs_inode_load+0x60>       <== NEVER TAKEN
400123e0:	01 00 00 00 	nop                                            
      return rc;                                                      
                                                                      
    handle->node = rtems_rfs_buffer_data (&handle->buffer);           
400123e4:	c4 06 60 18 	ld  [ %i1 + 0x18 ], %g2                        
    handle->node += handle->offset;                                   
400123e8:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
400123ec:	c4 00 a0 1c 	ld  [ %g2 + 0x1c ], %g2                        
400123f0:	87 28 60 03 	sll  %g1, 3, %g3                               
400123f4:	83 28 60 06 	sll  %g1, 6, %g1                               
400123f8:	82 20 40 03 	sub  %g1, %g3, %g1                             
400123fc:	82 00 80 01 	add  %g2, %g1, %g1                             
40012400:	10 bf ff e9 	b  400123a4 <rtems_rfs_inode_load+0x50>        
40012404:	c2 26 60 0c 	st  %g1, [ %i1 + 0xc ]                         
                                                                      

40012408 <rtems_rfs_inode_open>: int rtems_rfs_inode_open (rtems_rfs_file_system* fs, rtems_rfs_ino ino, rtems_rfs_inode_handle* handle, bool load) {
40012408:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int group;                                                          
  int gino;                                                           
  int index;                                                          
  int rc;                                                             
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))                   
4001240c:	90 10 20 00 	clr  %o0                                       
40012410:	40 00 06 a5 	call  40013ea4 <rtems_rfs_trace>               
40012414:	13 00 01 00 	sethi  %hi(0x40000), %o1                       
40012418:	80 8a 20 ff 	btst  0xff, %o0                                
4001241c:	32 80 00 2d 	bne,a   400124d0 <rtems_rfs_inode_open+0xc8>   <== NEVER TAKEN
40012420:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
    printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);        
                                                                      
  if (ino == RTEMS_RFS_EMPTY_INO)                                     
40012424:	80 a6 60 00 	cmp  %i1, 0                                    
40012428:	12 80 00 04 	bne  40012438 <rtems_rfs_inode_open+0x30>      <== ALWAYS TAKEN
4001242c:	82 10 20 16 	mov  0x16, %g1                                 
                                                                      
  rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);            
  if ((rc == 0) && load)                                              
    rc = rtems_rfs_inode_load (fs, handle);                           
  return rc;                                                          
}                                                                     
40012430:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40012434:	91 e8 00 01 	restore  %g0, %g1, %o0                         <== NOT EXECUTED
    printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);        
                                                                      
  if (ino == RTEMS_RFS_EMPTY_INO)                                     
    return EINVAL;                                                    
                                                                      
  if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))          
40012438:	c4 06 20 14 	ld  [ %i0 + 0x14 ], %g2                        
4001243c:	ba 06 7f ff 	add  %i1, -1, %i5                              
40012440:	80 a7 40 02 	cmp  %i5, %g2                                  
40012444:	18 bf ff fb 	bgu  40012430 <rtems_rfs_inode_open+0x28>      <== NEVER TAKEN
40012448:	90 10 00 1d 	mov  %i5, %o0                                  
  handle->ino = ino;                                                  
  handle->node = NULL;                                                
  handle->loads = 0;                                                  
                                                                      
  gino  = ino - RTEMS_RFS_ROOT_INO;                                   
  group = gino / fs->group_inodes;                                    
4001244c:	e0 06 20 2c 	ld  [ %i0 + 0x2c ], %l0                        
    return EINVAL;                                                    
                                                                      
  if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))          
    return EINVAL;                                                    
                                                                      
  handle->ino = ino;                                                  
40012450:	f2 26 a0 08 	st  %i1, [ %i2 + 8 ]                           
  handle->node = NULL;                                                
  handle->loads = 0;                                                  
                                                                      
  gino  = ino - RTEMS_RFS_ROOT_INO;                                   
  group = gino / fs->group_inodes;                                    
  gino  = gino % fs->group_inodes;                                    
40012454:	92 10 00 10 	mov  %l0, %o1                                  
                                                                      
  if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))          
    return EINVAL;                                                    
                                                                      
  handle->ino = ino;                                                  
  handle->node = NULL;                                                
40012458:	c0 26 a0 0c 	clr  [ %i2 + 0xc ]                             
  handle->loads = 0;                                                  
                                                                      
  gino  = ino - RTEMS_RFS_ROOT_INO;                                   
  group = gino / fs->group_inodes;                                    
  gino  = gino % fs->group_inodes;                                    
4001245c:	40 00 78 5e 	call  400305d4 <.urem>                         
40012460:	c0 26 a0 24 	clr  [ %i2 + 0x24 ]                            
  index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
40012464:	f8 06 20 30 	ld  [ %i0 + 0x30 ], %i4                        
  handle->node = NULL;                                                
  handle->loads = 0;                                                  
                                                                      
  gino  = ino - RTEMS_RFS_ROOT_INO;                                   
  group = gino / fs->group_inodes;                                    
  gino  = gino % fs->group_inodes;                                    
40012468:	b2 10 00 08 	mov  %o0, %i1                                  
  index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
                                                                      
  handle->offset = gino % fs->inodes_per_block;                       
4001246c:	40 00 78 5a 	call  400305d4 <.urem>                         
40012470:	92 10 00 1c 	mov  %i4, %o1                                  
  handle->ino = ino;                                                  
  handle->node = NULL;                                                
  handle->loads = 0;                                                  
                                                                      
  gino  = ino - RTEMS_RFS_ROOT_INO;                                   
  group = gino / fs->group_inodes;                                    
40012474:	92 10 00 10 	mov  %l0, %o1                                  
  gino  = gino % fs->group_inodes;                                    
  index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
                                                                      
  handle->offset = gino % fs->inodes_per_block;                       
40012478:	d0 26 a0 20 	st  %o0, [ %i2 + 0x20 ]                        
  handle->ino = ino;                                                  
  handle->node = NULL;                                                
  handle->loads = 0;                                                  
                                                                      
  gino  = ino - RTEMS_RFS_ROOT_INO;                                   
  group = gino / fs->group_inodes;                                    
4001247c:	7f ff c0 89 	call  400026a0 <.udiv>                         
40012480:	90 10 00 1d 	mov  %i5, %o0                                  
  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); 
40012484:	c4 06 20 20 	ld  [ %i0 + 0x20 ], %g2                        
40012488:	87 2a 20 04 	sll  %o0, 4, %g3                               
4001248c:	83 2a 20 06 	sll  %o0, 6, %g1                               
40012490:	82 00 c0 01 	add  %g3, %g1, %g1                             
  handle->loads = 0;                                                  
                                                                      
  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;
40012494:	fa 00 80 01 	ld  [ %g2 + %g1 ], %i5                         
40012498:	90 10 00 19 	mov  %i1, %o0                                  
4001249c:	ba 07 60 02 	add  %i5, 2, %i5                               
400124a0:	7f ff c0 80 	call  400026a0 <.udiv>                         
400124a4:	92 10 00 1c 	mov  %i4, %o1                                  
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
400124a8:	c0 2e a0 10 	clrb  [ %i2 + 0x10 ]                           
                                                                      
  handle->offset = gino % fs->inodes_per_block;                       
  handle->block  = rtems_rfs_group_block (&fs->groups[group], index); 
400124ac:	90 07 40 08 	add  %i5, %o0, %o0                             
  handle->bnum  = 0;                                                  
400124b0:	c0 26 a0 14 	clr  [ %i2 + 0x14 ]                            
400124b4:	d0 26 a0 1c 	st  %o0, [ %i2 + 0x1c ]                        
  handle->buffer = NULL;                                              
400124b8:	c0 26 a0 18 	clr  [ %i2 + 0x18 ]                            
                                                                      
  rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);            
  if ((rc == 0) && load)                                              
400124bc:	80 a6 e0 00 	cmp  %i3, 0                                    
400124c0:	02 bf ff dc 	be  40012430 <rtems_rfs_inode_open+0x28>       <== NEVER TAKEN
400124c4:	82 10 20 00 	clr  %g1                                       
    rc = rtems_rfs_inode_load (fs, handle);                           
400124c8:	7f ff ff a3 	call  40012354 <rtems_rfs_inode_load>          
400124cc:	93 e8 00 1a 	restore  %g0, %i2, %o1                         
  int gino;                                                           
  int index;                                                          
  int rc;                                                             
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))                   
    printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);        
400124d0:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
400124d4:	40 00 46 aa 	call  40023f7c <printf>                        <== NOT EXECUTED
400124d8:	90 12 21 90 	or  %o0, 0x190, %o0	! 40035d90 <_CPU_Trap_slot_template+0xaa8><== NOT EXECUTED
                                                                      
  if (ino == RTEMS_RFS_EMPTY_INO)                                     
400124dc:	10 bf ff d3 	b  40012428 <rtems_rfs_inode_open+0x20>        <== NOT EXECUTED
400124e0:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
                                                                      

40012754 <rtems_rfs_inode_time_stamp_now>: int rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle, bool atime, bool mtime) {
40012754:	9d e3 bf a0 	save  %sp, -96, %sp                            
  time_t now;                                                         
  if (!rtems_rfs_inode_is_loaded (handle))                            
40012758:	c2 06 20 0c 	ld  [ %i0 + 0xc ], %g1                         
                                                                      
int                                                                   
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,       
                                bool                    atime,        
                                bool                    mtime)        
{                                                                     
4001275c:	ba 10 00 18 	mov  %i0, %i5                                  
  time_t now;                                                         
  if (!rtems_rfs_inode_is_loaded (handle))                            
40012760:	80 a0 60 00 	cmp  %g1, 0                                    
40012764:	02 80 00 23 	be  400127f0 <rtems_rfs_inode_time_stamp_now+0x9c><== NEVER TAKEN
40012768:	b0 10 20 06 	mov  6, %i0                                    
    return ENXIO;                                                     
  now = time (NULL);                                                  
4001276c:	40 00 56 48 	call  4002808c <time>                          
40012770:	90 10 20 00 	clr  %o0                                       
  if (atime)                                                          
40012774:	80 a6 60 00 	cmp  %i1, 0                                    
40012778:	02 80 00 0f 	be  400127b4 <rtems_rfs_inode_time_stamp_now+0x60><== NEVER TAKEN
4001277c:	80 a6 a0 00 	cmp  %i2, 0                                    
 */                                                                   
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);                  
40012780:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
40012784:	85 32 20 18 	srl  %o0, 0x18, %g2                            
40012788:	c4 28 60 10 	stb  %g2, [ %g1 + 0x10 ]                       
4001278c:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
40012790:	85 32 20 10 	srl  %o0, 0x10, %g2                            
40012794:	c4 28 60 11 	stb  %g2, [ %g1 + 0x11 ]                       
40012798:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
4001279c:	85 32 20 08 	srl  %o0, 8, %g2                               
400127a0:	c4 28 60 12 	stb  %g2, [ %g1 + 0x12 ]                       
400127a4:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
400127a8:	d0 28 60 13 	stb  %o0, [ %g1 + 0x13 ]                       
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
400127ac:	82 10 20 01 	mov  1, %g1                                    
400127b0:	c2 2f 60 10 	stb  %g1, [ %i5 + 0x10 ]                       
    rtems_rfs_inode_set_atime (handle, now);                          
  if (mtime)                                                          
400127b4:	02 80 00 0f 	be  400127f0 <rtems_rfs_inode_time_stamp_now+0x9c><== NEVER TAKEN
400127b8:	b0 10 20 00 	clr  %i0                                       
 */                                                                   
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);                  
400127bc:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
400127c0:	85 32 20 18 	srl  %o0, 0x18, %g2                            
400127c4:	c4 28 60 14 	stb  %g2, [ %g1 + 0x14 ]                       
400127c8:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
400127cc:	85 32 20 10 	srl  %o0, 0x10, %g2                            
400127d0:	c4 28 60 15 	stb  %g2, [ %g1 + 0x15 ]                       
400127d4:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
400127d8:	85 32 20 08 	srl  %o0, 8, %g2                               
400127dc:	c4 28 60 16 	stb  %g2, [ %g1 + 0x16 ]                       
400127e0:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
400127e4:	d0 28 60 17 	stb  %o0, [ %g1 + 0x17 ]                       
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
400127e8:	82 10 20 01 	mov  1, %g1                                    
400127ec:	c2 2f 60 10 	stb  %g1, [ %i5 + 0x10 ]                       
    rtems_rfs_inode_set_mtime (handle, now);                          
  return 0;                                                           
}                                                                     
400127f0:	81 c7 e0 08 	ret                                            
400127f4:	81 e8 00 00 	restore                                        
                                                                      

400124e4 <rtems_rfs_inode_unload>: int rtems_rfs_inode_unload (rtems_rfs_file_system* fs, rtems_rfs_inode_handle* handle, bool update_ctime) {
400124e4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rc = 0;                                                         
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))                 
400124e8:	90 10 20 00 	clr  %o0                                       
400124ec:	40 00 06 6e 	call  40013ea4 <rtems_rfs_trace>               
400124f0:	13 00 08 00 	sethi  %hi(0x200000), %o1                      
400124f4:	80 8a 20 ff 	btst  0xff, %o0                                
400124f8:	02 80 00 0c 	be  40012528 <rtems_rfs_inode_unload+0x44>     <== ALWAYS TAKEN
400124fc:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
    printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
40012500:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
40012504:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40012508:	02 80 00 25 	be  4001259c <rtems_rfs_inode_unload+0xb8>     <== NOT EXECUTED
4001250c:	d4 06 60 24 	ld  [ %i1 + 0x24 ], %o2                        <== NOT EXECUTED
40012510:	17 10 00 d7 	sethi  %hi(0x40035c00), %o3                    <== NOT EXECUTED
40012514:	96 12 e1 50 	or  %o3, 0x150, %o3	! 40035d50 <_CPU_Trap_slot_template+0xa68><== NOT EXECUTED
40012518:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
4001251c:	40 00 46 98 	call  40023f7c <printf>                        <== NOT EXECUTED
40012520:	90 12 21 b8 	or  %o0, 0x1b8, %o0	! 40035db8 <_CPU_Trap_slot_template+0xad0><== NOT EXECUTED
            handle->ino, handle->loads,                               
            rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");       
                                                                      
  if (rtems_rfs_inode_is_loaded (handle))                             
40012524:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         <== NOT EXECUTED
40012528:	80 a0 60 00 	cmp  %g1, 0                                    
4001252c:	22 80 00 0d 	be,a   40012560 <rtems_rfs_inode_unload+0x7c>  
40012530:	90 10 20 00 	clr  %o0                                       
  {                                                                   
    if (handle->loads == 0)                                           
40012534:	c4 06 60 24 	ld  [ %i1 + 0x24 ], %g2                        
40012538:	80 a0 a0 00 	cmp  %g2, 0                                    
4001253c:	12 80 00 04 	bne  4001254c <rtems_rfs_inode_unload+0x68>    <== ALWAYS TAKEN
40012540:	90 10 20 05 	mov  5, %o0                                    
      handle->node = NULL;                                            
    }                                                                 
  }                                                                   
                                                                      
  return rc;                                                          
}                                                                     
40012544:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40012548:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
  if (rtems_rfs_inode_is_loaded (handle))                             
  {                                                                   
    if (handle->loads == 0)                                           
      return EIO;                                                     
                                                                      
    handle->loads--;                                                  
4001254c:	84 00 bf ff 	add  %g2, -1, %g2                              
                                                                      
    if (handle->loads == 0)                                           
40012550:	80 a0 a0 00 	cmp  %g2, 0                                    
40012554:	02 80 00 05 	be  40012568 <rtems_rfs_inode_unload+0x84>     
40012558:	c4 26 60 24 	st  %g2, [ %i1 + 0x24 ]                        
int                                                                   
rtems_rfs_inode_unload (rtems_rfs_file_system*  fs,                   
                        rtems_rfs_inode_handle* handle,               
                        bool                    update_ctime)         
{                                                                     
  int rc = 0;                                                         
4001255c:	90 10 20 00 	clr  %o0                                       
      handle->node = NULL;                                            
    }                                                                 
  }                                                                   
                                                                      
  return rc;                                                          
}                                                                     
40012560:	81 c7 e0 08 	ret                                            
40012564:	91 e8 00 08 	restore  %g0, %o0, %o0                         
    if (handle->loads == 0)                                           
    {                                                                 
      /*                                                              
       * If the buffer is dirty it will be release. Also set the ctime.
       */                                                             
      if (rtems_rfs_buffer_dirty (&handle->buffer) && update_ctime)   
40012568:	c2 0e 60 10 	ldub  [ %i1 + 0x10 ], %g1                      
4001256c:	80 a0 60 00 	cmp  %g1, 0                                    
40012570:	02 80 00 06 	be  40012588 <rtems_rfs_inode_unload+0xa4>     
40012574:	90 10 00 18 	mov  %i0, %o0                                  
40012578:	80 a6 a0 00 	cmp  %i2, 0                                    
4001257c:	12 80 00 0b 	bne  400125a8 <rtems_rfs_inode_unload+0xc4>    <== ALWAYS TAKEN
40012580:	01 00 00 00 	nop                                            
        rtems_rfs_inode_set_ctime (handle, time (NULL));              
      rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);     
40012584:	90 10 00 18 	mov  %i0, %o0                                  
40012588:	40 00 27 ac 	call  4001c438 <rtems_rfs_buffer_handle_release>
4001258c:	92 06 60 10 	add  %i1, 0x10, %o1                            
      handle->node = NULL;                                            
40012590:	c0 26 60 0c 	clr  [ %i1 + 0xc ]                             
    }                                                                 
  }                                                                   
                                                                      
  return rc;                                                          
}                                                                     
40012594:	81 c7 e0 08 	ret                                            
40012598:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                        bool                    update_ctime)         
{                                                                     
  int rc = 0;                                                         
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))                 
    printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
4001259c:	17 10 00 d1 	sethi  %hi(0x40034400), %o3                    <== NOT EXECUTED
400125a0:	10 bf ff de 	b  40012518 <rtems_rfs_inode_unload+0x34>      <== NOT EXECUTED
400125a4:	96 12 e0 00 	mov  %o3, %o3	! 40034400 <__FUNCTION__.6193+0x338><== NOT EXECUTED
    {                                                                 
      /*                                                              
       * If the buffer is dirty it will be release. Also set the ctime.
       */                                                             
      if (rtems_rfs_buffer_dirty (&handle->buffer) && update_ctime)   
        rtems_rfs_inode_set_ctime (handle, time (NULL));              
400125a8:	40 00 56 b9 	call  4002808c <time>                          
400125ac:	90 10 20 00 	clr  %o0                                       
 */                                                                   
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);                  
400125b0:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
400125b4:	85 32 20 18 	srl  %o0, 0x18, %g2                            
400125b8:	c4 28 60 18 	stb  %g2, [ %g1 + 0x18 ]                       
400125bc:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
400125c0:	85 32 20 10 	srl  %o0, 0x10, %g2                            
400125c4:	c4 28 60 19 	stb  %g2, [ %g1 + 0x19 ]                       
400125c8:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
400125cc:	85 32 20 08 	srl  %o0, 8, %g2                               
400125d0:	c4 28 60 1a 	stb  %g2, [ %g1 + 0x1a ]                       
400125d4:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
400125d8:	d0 28 60 1b 	stb  %o0, [ %g1 + 0x1b ]                       
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
400125dc:	82 10 20 01 	mov  1, %g1                                    
400125e0:	10 bf ff e9 	b  40012584 <rtems_rfs_inode_unload+0xa0>      
400125e4:	c2 2e 60 10 	stb  %g1, [ %i1 + 0x10 ]                       
                                                                      

4001fb98 <rtems_rfs_link>: const char* name, int length, rtems_rfs_ino parent, rtems_rfs_ino target, bool link_dir) {
4001fb98:	9d e3 bf 50 	save  %sp, -176, %sp                           
  rtems_rfs_inode_handle parent_inode;                                
  rtems_rfs_inode_handle target_inode;                                
  uint16_t               links;                                       
  int                    rc;                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_LINK))                         
4001fb9c:	90 10 20 00 	clr  %o0                                       
4001fba0:	13 00 40 00 	sethi  %hi(0x1000000), %o1                     
4001fba4:	7f ff d0 c0 	call  40013ea4 <rtems_rfs_trace>               
4001fba8:	a2 10 00 18 	mov  %i0, %l1                                  
4001fbac:	80 8a 20 ff 	btst  0xff, %o0                                
4001fbb0:	12 80 00 52 	bne  4001fcf8 <rtems_rfs_link+0x160>           <== NEVER TAKEN
4001fbb4:	92 10 00 1b 	mov  %i3, %o1                                  
    for (c = 0; c < length; c++)                                      
      printf ("%c", name[c]);                                         
    printf ("(%" PRIu32 ")\n", target);                               
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_open (fs, target, &target_inode, true);        
4001fbb8:	90 10 00 11 	mov  %l1, %o0                                  
4001fbbc:	92 10 00 1c 	mov  %i4, %o1                                  
4001fbc0:	94 07 bf d8 	add  %fp, -40, %o2                             
4001fbc4:	7f ff ca 11 	call  40012408 <rtems_rfs_inode_open>          
4001fbc8:	96 10 20 01 	mov  1, %o3                                    
  if (rc)                                                             
4001fbcc:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001fbd0:	12 80 00 3d 	bne  4001fcc4 <rtems_rfs_link+0x12c>           <== NEVER TAKEN
4001fbd4:	80 a7 60 00 	cmp  %i5, 0                                    
                                                                      
  /*                                                                  
   * 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)))
4001fbd8:	12 80 00 0b 	bne  4001fc04 <rtems_rfs_link+0x6c>            <== NEVER TAKEN
4001fbdc:	90 10 00 11 	mov  %l1, %o0                                  
4001fbe0:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
4001fbe4:	c4 08 60 02 	ldub  [ %g1 + 2 ], %g2                         
4001fbe8:	03 00 00 3c 	sethi  %hi(0xf000), %g1                        
4001fbec:	85 28 a0 08 	sll  %g2, 8, %g2                               
4001fbf0:	84 08 80 01 	and  %g2, %g1, %g2                             
4001fbf4:	03 00 00 10 	sethi  %hi(0x4000), %g1                        
4001fbf8:	80 a0 80 01 	cmp  %g2, %g1                                  
4001fbfc:	02 80 00 55 	be  4001fd50 <rtems_rfs_link+0x1b8>            <== NEVER TAKEN
4001fc00:	b0 10 20 86 	mov  0x86, %i0                                 
  {                                                                   
    rtems_rfs_inode_close (fs, &target_inode);                        
    return ENOTSUP;                                                   
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);        
4001fc04:	92 10 00 1b 	mov  %i3, %o1                                  
4001fc08:	94 07 bf b0 	add  %fp, -80, %o2                             
4001fc0c:	7f ff c9 ff 	call  40012408 <rtems_rfs_inode_open>          
4001fc10:	96 10 20 01 	mov  1, %o3                                    
4001fc14:	b0 10 00 08 	mov  %o0, %i0                                  
  if (rc)                                                             
4001fc18:	80 a6 20 00 	cmp  %i0, 0                                    
4001fc1c:	12 80 00 27 	bne  4001fcb8 <rtems_rfs_link+0x120>           <== NEVER TAKEN
4001fc20:	90 10 00 11 	mov  %l1, %o0                                  
  {                                                                   
    rtems_rfs_inode_close (fs, &target_inode);                        
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
4001fc24:	92 07 bf b0 	add  %fp, -80, %o1                             
4001fc28:	94 10 00 19 	mov  %i1, %o2                                  
4001fc2c:	96 10 00 1a 	mov  %i2, %o3                                  
4001fc30:	7f ff f5 bd 	call  4001d324 <rtems_rfs_dir_add_entry>       
4001fc34:	98 10 00 1c 	mov  %i4, %o4                                  
  if (rc > 0)                                                         
4001fc38:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001fc3c:	14 80 00 42 	bg  4001fd44 <rtems_rfs_link+0x1ac>            <== NEVER TAKEN
4001fc40:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
 */                                                                   
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);                  
4001fc44:	c6 08 60 01 	ldub  [ %g1 + 1 ], %g3                         
4001fc48:	c4 08 40 00 	ldub  [ %g1 ], %g2                             
4001fc4c:	85 28 a0 08 	sll  %g2, 8, %g2                               
4001fc50:	84 10 80 03 	or  %g2, %g3, %g2                              
  if (links == 0xffff)                                                
4001fc54:	07 3f ff c0 	sethi  %hi(0xffff0000), %g3                    
4001fc58:	89 28 a0 10 	sll  %g2, 0x10, %g4                            
4001fc5c:	80 a1 00 03 	cmp  %g4, %g3                                  
4001fc60:	22 80 00 40 	be,a   4001fd60 <rtems_rfs_link+0x1c8>         <== NEVER TAKEN
4001fc64:	84 10 20 01 	mov  1, %g2                                    <== NOT EXECUTED
4001fc68:	84 00 a0 01 	inc  %g2                                       
4001fc6c:	87 28 a0 10 	sll  %g2, 0x10, %g3                            
4001fc70:	87 30 e0 18 	srl  %g3, 0x18, %g3                            
 * @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);                  
4001fc74:	c6 28 40 00 	stb  %g3, [ %g1 ]                              
4001fc78:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
  }                                                                   
                                                                      
  links = rtems_rfs_inode_get_links (&target_inode) + 1;              
  rtems_rfs_inode_set_links (&target_inode, links);                   
                                                                      
  rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);    
4001fc7c:	92 10 20 01 	mov  1, %o1                                    
4001fc80:	c4 28 60 01 	stb  %g2, [ %g1 + 1 ]                          
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
4001fc84:	82 10 20 01 	mov  1, %g1                                    
4001fc88:	90 07 bf b0 	add  %fp, -80, %o0                             
4001fc8c:	c2 2f bf e8 	stb  %g1, [ %fp + -24 ]                        
4001fc90:	7f ff ca b1 	call  40012754 <rtems_rfs_inode_time_stamp_now>
4001fc94:	94 10 20 01 	mov  1, %o2                                    
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_inode_close (fs, &parent_inode);                        
4001fc98:	92 07 bf b0 	add  %fp, -80, %o1                             
  }                                                                   
                                                                      
  links = rtems_rfs_inode_get_links (&target_inode) + 1;              
  rtems_rfs_inode_set_links (&target_inode, links);                   
                                                                      
  rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);    
4001fc9c:	b0 10 00 08 	mov  %o0, %i0                                  
  if (rc > 0)                                                         
4001fca0:	80 a6 20 00 	cmp  %i0, 0                                    
4001fca4:	04 80 00 0a 	ble  4001fccc <rtems_rfs_link+0x134>           <== ALWAYS TAKEN
4001fca8:	90 10 00 11 	mov  %l1, %o0                                  
  }                                                                   
                                                                      
  rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_inode_close (fs, &parent_inode);                        
4001fcac:	7f ff ca 4f 	call  400125e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
4001fcb0:	01 00 00 00 	nop                                            <== NOT EXECUTED
    rtems_rfs_inode_close (fs, &target_inode);                        
4001fcb4:	90 10 00 11 	mov  %l1, %o0                                  <== NOT EXECUTED
4001fcb8:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
4001fcbc:	7f ff ca 4b 	call  400125e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
4001fcc0:	01 00 00 00 	nop                                            <== NOT EXECUTED
4001fcc4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001fcc8:	81 e8 00 00 	restore                                        <== 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);                     
4001fccc:	7f ff ca 47 	call  400125e8 <rtems_rfs_inode_close>         
4001fcd0:	01 00 00 00 	nop                                            
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_inode_close (fs, &target_inode);                        
4001fcd4:	92 07 bf d8 	add  %fp, -40, %o1                             
    rtems_rfs_inode_close (fs, &parent_inode);                        
    rtems_rfs_inode_close (fs, &target_inode);                        
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_close (fs, &parent_inode);                     
4001fcd8:	b0 10 00 08 	mov  %o0, %i0                                  
  if (rc > 0)                                                         
4001fcdc:	80 a6 20 00 	cmp  %i0, 0                                    
4001fce0:	14 bf ff f7 	bg  4001fcbc <rtems_rfs_link+0x124>            <== NEVER TAKEN
4001fce4:	90 10 00 11 	mov  %l1, %o0                                  
  {                                                                   
    rtems_rfs_inode_close (fs, &target_inode);                        
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_close (fs, &target_inode);                     
4001fce8:	7f ff ca 40 	call  400125e8 <rtems_rfs_inode_close>         
4001fcec:	01 00 00 00 	nop                                            
                                                                      
  return rc;                                                          
}                                                                     
4001fcf0:	81 c7 e0 08 	ret                                            
4001fcf4:	91 e8 00 08 	restore  %g0, %o0, %o0                         
  int                    rc;                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_LINK))                         
  {                                                                   
    int c;                                                            
    printf ("rtems-rfs: link: parent(%" PRIu32 ") -> ", parent);      
4001fcf8:	11 10 00 df 	sethi  %hi(0x40037c00), %o0                    <== NOT EXECUTED
4001fcfc:	40 00 10 a0 	call  40023f7c <printf>                        <== NOT EXECUTED
4001fd00:	90 12 23 f8 	or  %o0, 0x3f8, %o0	! 40037ff8 <CSWTCH.2+0x1408><== NOT EXECUTED
4001fd04:	a0 10 00 19 	mov  %i1, %l0                                  <== NOT EXECUTED
    for (c = 0; c < length; c++)                                      
4001fd08:	80 a6 a0 00 	cmp  %i2, 0                                    <== NOT EXECUTED
4001fd0c:	04 80 00 08 	ble  4001fd2c <rtems_rfs_link+0x194>           <== NOT EXECUTED
4001fd10:	b0 06 40 1a 	add  %i1, %i2, %i0                             <== NOT EXECUTED
      printf ("%c", name[c]);                                         
4001fd14:	d0 4c 00 00 	ldsb  [ %l0 ], %o0                             <== NOT EXECUTED
4001fd18:	40 00 11 03 	call  40024124 <putchar>                       <== NOT EXECUTED
4001fd1c:	a0 04 20 01 	inc  %l0                                       <== NOT EXECUTED
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_LINK))                         
  {                                                                   
    int c;                                                            
    printf ("rtems-rfs: link: parent(%" PRIu32 ") -> ", parent);      
    for (c = 0; c < length; c++)                                      
4001fd20:	80 a4 00 18 	cmp  %l0, %i0                                  <== NOT EXECUTED
4001fd24:	32 bf ff fd 	bne,a   4001fd18 <rtems_rfs_link+0x180>        <== NOT EXECUTED
4001fd28:	d0 4c 00 00 	ldsb  [ %l0 ], %o0                             <== NOT EXECUTED
      printf ("%c", name[c]);                                         
    printf ("(%" PRIu32 ")\n", target);                               
4001fd2c:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
4001fd30:	11 10 00 e0 	sethi  %hi(0x40038000), %o0                    <== NOT EXECUTED
4001fd34:	40 00 10 92 	call  40023f7c <printf>                        <== NOT EXECUTED
4001fd38:	90 12 20 20 	or  %o0, 0x20, %o0	! 40038020 <CSWTCH.2+0x1430><== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_open (fs, target, &target_inode, true);        
4001fd3c:	10 bf ff a0 	b  4001fbbc <rtems_rfs_link+0x24>              <== NOT EXECUTED
4001fd40:	90 10 00 11 	mov  %l1, %o0                                  <== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_inode_close (fs, &parent_inode);                        
4001fd44:	90 10 00 11 	mov  %l1, %o0                                  <== NOT EXECUTED
4001fd48:	10 bf ff d9 	b  4001fcac <rtems_rfs_link+0x114>             <== NOT EXECUTED
4001fd4c:	92 07 bf b0 	add  %fp, -80, %o1                             <== 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)))
  {                                                                   
    rtems_rfs_inode_close (fs, &target_inode);                        
4001fd50:	7f ff ca 26 	call  400125e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
4001fd54:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
4001fd58:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001fd5c:	81 e8 00 00 	restore                                        <== 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)                                                
4001fd60:	10 bf ff c5 	b  4001fc74 <rtems_rfs_link+0xdc>              <== NOT EXECUTED
4001fd64:	86 10 20 00 	clr  %g3                                       <== NOT EXECUTED
                                                                      

400205cc <rtems_rfs_mutex_create>: RTEMS_INHERIT_PRIORITY | RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL) #endif int rtems_rfs_mutex_create (rtems_rfs_mutex* mutex) {
400205cc:	9d e3 bf a0 	save  %sp, -96, %sp                            
#if __rtems__                                                         
  rtems_status_code sc;                                               
  sc = rtems_semaphore_create (rtems_build_name ('R', 'F', 'S', 'm'), 
400205d0:	92 10 20 01 	mov  1, %o1                                    
400205d4:	98 10 00 18 	mov  %i0, %o4                                  
400205d8:	11 14 91 94 	sethi  %hi(0x52465000), %o0                    
400205dc:	94 10 20 54 	mov  0x54, %o2                                 
400205e0:	90 12 23 6d 	or  %o0, 0x36d, %o0                            
400205e4:	96 10 20 00 	clr  %o3                                       
400205e8:	7f ff b1 18 	call  4000ca48 <rtems_semaphore_create>        
400205ec:	b0 10 20 00 	clr  %i0                                       
                               1, RTEMS_RFS_MUTEX_ATTRIBS, 0,         
                               mutex);                                
  if (sc != RTEMS_SUCCESSFUL)                                         
400205f0:	80 a2 20 00 	cmp  %o0, 0                                    
400205f4:	02 80 00 0f 	be  40020630 <rtems_rfs_mutex_create+0x64>     <== ALWAYS TAKEN
400205f8:	ba 10 00 08 	mov  %o0, %i5                                  
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
400205fc:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
40020600:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40020604:	7f ff ce 28 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
40020608:	b0 10 20 05 	mov  5, %i0                                    <== NOT EXECUTED
4002060c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40020610:	02 80 00 08 	be  40020630 <rtems_rfs_mutex_create+0x64>     <== NOT EXECUTED
40020614:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: open failed: %s\n",                  
40020618:	7f ff dc 7e 	call  40017810 <rtems_status_text>             <== NOT EXECUTED
4002061c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40020620:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40020624:	11 10 00 e0 	sethi  %hi(0x40038000), %o0                    <== NOT EXECUTED
40020628:	40 00 0e 55 	call  40023f7c <printf>                        <== NOT EXECUTED
4002062c:	90 12 22 50 	or  %o0, 0x250, %o0	! 40038250 <CSWTCH.2+0x1660><== NOT EXECUTED
              rtems_status_text (sc));                                
    return EIO;                                                       
  }                                                                   
#endif                                                                
  return 0;                                                           
}                                                                     
40020630:	81 c7 e0 08 	ret                                            
40020634:	81 e8 00 00 	restore                                        
                                                                      

40020638 <rtems_rfs_mutex_destroy>: int rtems_rfs_mutex_destroy (rtems_rfs_mutex* mutex) {
40020638:	9d e3 bf a0 	save  %sp, -96, %sp                            
#if __rtems__                                                         
  rtems_status_code sc;                                               
  sc = rtems_semaphore_delete (*mutex);                               
4002063c:	d0 06 00 00 	ld  [ %i0 ], %o0                               
40020640:	7f ff b1 73 	call  4000cc0c <rtems_semaphore_delete>        
40020644:	b0 10 20 00 	clr  %i0                                       
  if (sc != RTEMS_SUCCESSFUL)                                         
40020648:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4002064c:	02 80 00 0e 	be  40020684 <rtems_rfs_mutex_destroy+0x4c>    <== ALWAYS TAKEN
40020650:	90 10 20 00 	clr  %o0                                       
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
40020654:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40020658:	7f ff ce 13 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4002065c:	b0 10 20 05 	mov  5, %i0                                    <== NOT EXECUTED
40020660:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40020664:	02 80 00 08 	be  40020684 <rtems_rfs_mutex_destroy+0x4c>    <== NOT EXECUTED
40020668:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: close failed: %s\n",                 
4002066c:	7f ff dc 69 	call  40017810 <rtems_status_text>             <== NOT EXECUTED
40020670:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40020674:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40020678:	11 10 00 e0 	sethi  %hi(0x40038000), %o0                    <== NOT EXECUTED
4002067c:	40 00 0e 40 	call  40023f7c <printf>                        <== NOT EXECUTED
40020680:	90 12 22 78 	or  %o0, 0x278, %o0	! 40038278 <CSWTCH.2+0x1688><== NOT EXECUTED
              rtems_status_text (sc));                                
    return EIO;                                                       
  }                                                                   
#endif                                                                
  return 0;                                                           
}                                                                     
40020684:	81 c7 e0 08 	ret                                            
40020688:	81 e8 00 00 	restore                                        
                                                                      

4001c27c <rtems_rfs_release_chain>: static int rtems_rfs_release_chain (rtems_chain_control* chain, uint32_t* count, bool modified) {
4001c27c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_rfs_buffer* buffer;                                           
  int               rrc = 0;                                          
  int               rc;                                               
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))                
4001c280:	90 10 20 00 	clr  %o0                                       
4001c284:	92 10 20 80 	mov  0x80, %o1                                 
4001c288:	7f ff df 07 	call  40013ea4 <rtems_rfs_trace>               
4001c28c:	ba 10 00 18 	mov  %i0, %i5                                  
4001c290:	80 8a 20 ff 	btst  0xff, %o0                                
4001c294:	32 80 00 1c 	bne,a   4001c304 <rtems_rfs_release_chain+0x88><== NEVER TAKEN
4001c298:	d2 06 40 00 	ld  [ %i1 ], %o1                               <== NOT EXECUTED
    (*count)--;                                                       
                                                                      
    buffer->user = (void*) 0;                                         
                                                                      
    rc = rtems_rfs_buffer_io_release (buffer, modified);              
    if ((rc > 0) && (rrc == 0))                                       
4001c29c:	b0 10 20 00 	clr  %i0                                       
4001c2a0:	b8 07 60 04 	add  %i5, 4, %i4                               
  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))                               
4001c2a4:	c2 07 40 00 	ld  [ %i5 ], %g1                               
4001c2a8:	80 a0 40 1c 	cmp  %g1, %i4                                  
4001c2ac:	02 80 00 14 	be  4001c2fc <rtems_rfs_release_chain+0x80>    
4001c2b0:	90 10 00 1d 	mov  %i5, %o0                                  
 */                                                                   
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(               
  rtems_chain_control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Get( the_chain );                                     
4001c2b4:	7f ff c5 69 	call  4000d858 <_Chain_Get>                    
4001c2b8:	01 00 00 00 	nop                                            
  {                                                                   
    buffer = (rtems_rfs_buffer*) rtems_chain_get (chain);             
    (*count)--;                                                       
4001c2bc:	c2 06 40 00 	ld  [ %i1 ], %g1                               
                                                                      
    buffer->user = (void*) 0;                                         
                                                                      
    rc = rtems_rfs_buffer_io_release (buffer, modified);              
4001c2c0:	92 10 00 1a 	mov  %i2, %o1                                  
    printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count); 
                                                                      
  while (!rtems_chain_is_empty (chain))                               
  {                                                                   
    buffer = (rtems_rfs_buffer*) rtems_chain_get (chain);             
    (*count)--;                                                       
4001c2c4:	82 00 7f ff 	add  %g1, -1, %g1                              
4001c2c8:	c2 26 40 00 	st  %g1, [ %i1 ]                               
                                                                      
    buffer->user = (void*) 0;                                         
                                                                      
    rc = rtems_rfs_buffer_io_release (buffer, modified);              
4001c2cc:	40 00 18 7b 	call  400224b8 <rtems_rfs_buffer_bdbuf_release>
4001c2d0:	c0 22 20 34 	clr  [ %o0 + 0x34 ]                            
    if ((rc > 0) && (rrc == 0))                                       
4001c2d4:	80 a2 20 00 	cmp  %o0, 0                                    
4001c2d8:	04 bf ff f4 	ble  4001c2a8 <rtems_rfs_release_chain+0x2c>   <== ALWAYS TAKEN
4001c2dc:	c2 07 40 00 	ld  [ %i5 ], %g1                               
4001c2e0:	80 a6 20 00 	cmp  %i0, 0                                    <== NOT EXECUTED
4001c2e4:	12 bf ff f1 	bne  4001c2a8 <rtems_rfs_release_chain+0x2c>   <== NOT EXECUTED
4001c2e8:	01 00 00 00 	nop                                            <== NOT EXECUTED
4001c2ec:	b0 10 00 08 	mov  %o0, %i0                                  <== 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))                               
4001c2f0:	80 a0 40 1c 	cmp  %g1, %i4                                  <== NOT EXECUTED
4001c2f4:	12 bf ff f0 	bne  4001c2b4 <rtems_rfs_release_chain+0x38>   <== NOT EXECUTED
4001c2f8:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
    rc = rtems_rfs_buffer_io_release (buffer, modified);              
    if ((rc > 0) && (rrc == 0))                                       
      rrc = rc;                                                       
  }                                                                   
  return rrc;                                                         
}                                                                     
4001c2fc:	81 c7 e0 08 	ret                                            
4001c300:	81 e8 00 00 	restore                                        
  rtems_rfs_buffer* buffer;                                           
  int               rrc = 0;                                          
  int               rc;                                               
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))                
    printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count); 
4001c304:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
4001c308:	40 00 1f 1d 	call  40023f7c <printf>                        <== NOT EXECUTED
4001c30c:	90 12 21 00 	or  %o0, 0x100, %o0	! 40036d00 <CSWTCH.2+0x110><== NOT EXECUTED
    (*count)--;                                                       
                                                                      
    buffer->user = (void*) 0;                                         
                                                                      
    rc = rtems_rfs_buffer_io_release (buffer, modified);              
    if ((rc > 0) && (rrc == 0))                                       
4001c310:	10 bf ff e4 	b  4001c2a0 <rtems_rfs_release_chain+0x24>     <== NOT EXECUTED
4001c314:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
                                                                      

400130d0 <rtems_rfs_rtems_chown>: static int rtems_rfs_rtems_chown (const rtems_filesystem_location_info_t *pathloc, uid_t owner, gid_t group) {
400130d0:	9d e3 bf 78 	save  %sp, -136, %sp                           
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);  
400130d4:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
                                                                      
  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);                                       
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
400130d8:	d2 06 20 08 	ld  [ %i0 + 8 ], %o1                           
static int                                                            
rtems_rfs_rtems_chown (const rtems_filesystem_location_info_t *pathloc,
                       uid_t                                   owner, 
                       gid_t                                   group) 
{                                                                     
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);  
400130dc:	f8 00 60 08 	ld  [ %g1 + 8 ], %i4                           
                                                                      
  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);                                       
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
400130e0:	94 07 bf d8 	add  %fp, -40, %o2                             
400130e4:	90 10 00 1c 	mov  %i4, %o0                                  
400130e8:	7f ff fc c8 	call  40012408 <rtems_rfs_inode_open>          
400130ec:	96 10 20 01 	mov  1, %o3                                    
  if (rc > 0)                                                         
400130f0:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400130f4:	04 80 00 07 	ble  40013110 <rtems_rfs_rtems_chown+0x40>     <== ALWAYS TAKEN
400130f8:	01 00 00 00 	nop                                            
  rtems_rfs_inode_set_uid_gid (&inode, owner, group);                 
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
  if (rc)                                                             
  {                                                                   
    return rtems_rfs_rtems_error ("chown: closing inode", rc);        
400130fc:	40 00 3e 0f 	call  40022938 <__errno>                       <== NOT EXECUTED
40013100:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <LEON_REG+0x7fffffff>  <== NOT EXECUTED
40013104:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
40013108:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001310c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  /*                                                                  
   *  Verify I am the owner of the node or the super user.            
   */                                                                 
                                                                      
#if defined (RTEMS_POSIX_API)                                         
  uid = geteuid();                                                    
40013110:	40 00 12 95 	call  40017b64 <geteuid>                       
40013114:	01 00 00 00 	nop                                            
 * @return uint16_t The user id (uid).                                
 */                                                                   
static inline uint16_t                                                
rtems_rfs_inode_get_uid (rtems_rfs_inode_handle* handle)              
{                                                                     
  return rtems_rfs_read_u32 (&handle->node->owner) & 0xffff;          
40013118:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
                                                                      
  if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))        
4001311c:	91 2a 20 10 	sll  %o0, 0x10, %o0                            
40013120:	c4 08 60 06 	ldub  [ %g1 + 6 ], %g2                         
40013124:	c6 08 60 07 	ldub  [ %g1 + 7 ], %g3                         
40013128:	85 28 a0 08 	sll  %g2, 8, %g2                               
4001312c:	84 10 80 03 	or  %g2, %g3, %g2                              
40013130:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
40013134:	80 a0 80 08 	cmp  %g2, %o0                                  
40013138:	02 80 00 05 	be  4001314c <rtems_rfs_rtems_chown+0x7c>      <== ALWAYS TAKEN
4001313c:	89 32 20 10 	srl  %o0, 0x10, %g4                            
40013140:	80 a1 20 00 	cmp  %g4, 0                                    <== NOT EXECUTED
40013144:	12 80 00 19 	bne  400131a8 <rtems_rfs_rtems_chown+0xd8>     <== NOT EXECUTED
40013148:	92 07 bf d8 	add  %fp, -40, %o1                             <== 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);
4001314c:	b5 2e a0 10 	sll  %i2, 0x10, %i2                            
40013150:	b4 16 80 19 	or  %i2, %i1, %i2                              
40013154:	85 36 a0 18 	srl  %i2, 0x18, %g2                            
40013158:	c4 28 60 04 	stb  %g2, [ %g1 + 4 ]                          
4001315c:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
40013160:	85 36 a0 10 	srl  %i2, 0x10, %g2                            
40013164:	c4 28 60 05 	stb  %g2, [ %g1 + 5 ]                          
40013168:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
4001316c:	b5 36 a0 08 	srl  %i2, 8, %i2                               
40013170:	f4 28 60 06 	stb  %i2, [ %g1 + 6 ]                          
40013174:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
  }                                                                   
#endif                                                                
                                                                      
  rtems_rfs_inode_set_uid_gid (&inode, owner, group);                 
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
40013178:	90 10 00 1c 	mov  %i4, %o0                                  
4001317c:	f2 28 60 07 	stb  %i1, [ %g1 + 7 ]                          
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
40013180:	82 10 20 01 	mov  1, %g1                                    
40013184:	92 07 bf d8 	add  %fp, -40, %o1                             
40013188:	c2 2f bf e8 	stb  %g1, [ %fp + -24 ]                        
4001318c:	7f ff fd 17 	call  400125e8 <rtems_rfs_inode_close>         
40013190:	b0 10 20 00 	clr  %i0                                       
  if (rc)                                                             
40013194:	80 a2 20 00 	cmp  %o0, 0                                    
40013198:	12 bf ff d9 	bne  400130fc <rtems_rfs_rtems_chown+0x2c>     <== NEVER TAKEN
4001319c:	ba 10 00 08 	mov  %o0, %i5                                  
  {                                                                   
    return rtems_rfs_rtems_error ("chown: closing inode", rc);        
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
400131a0:	81 c7 e0 08 	ret                                            
400131a4:	81 e8 00 00 	restore                                        
#if defined (RTEMS_POSIX_API)                                         
  uid = geteuid();                                                    
                                                                      
  if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))        
  {                                                                   
    rtems_rfs_inode_close (fs, &inode);                               
400131a8:	7f ff fd 10 	call  400125e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
400131ac:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
    return rtems_rfs_rtems_error ("chown: not able", EPERM);          
400131b0:	40 00 3d e2 	call  40022938 <__errno>                       <== NOT EXECUTED
400131b4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
400131b8:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
400131bc:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
400131c0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400131c4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

400206d0 <rtems_rfs_rtems_device_close>: rtems_device_major_number major; rtems_device_minor_number minor; rtems_rfs_rtems_device_get_major_and_minor (iop, &major, &minor); return rtems_deviceio_close (iop, major, minor);
400206d0:	d2 02 20 2c 	ld  [ %o0 + 0x2c ], %o1                        <== NOT EXECUTED
400206d4:	d4 02 20 30 	ld  [ %o0 + 0x30 ], %o2                        <== NOT EXECUTED
400206d8:	82 13 c0 00 	mov  %o7, %g1                                  <== NOT EXECUTED
400206dc:	40 00 05 24 	call  40021b6c <rtems_deviceio_close>          <== NOT EXECUTED
400206e0:	9e 10 40 00 	mov  %g1, %o7                                  <== NOT EXECUTED
                                                                      

4002068c <rtems_rfs_rtems_device_ftruncate>: static int rtems_rfs_rtems_device_ftruncate (rtems_libio_t* iop, off_t length) { return 0; }
4002068c:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
40020690:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
                                                                      

40020694 <rtems_rfs_rtems_device_ioctl>: rtems_device_major_number major; rtems_device_minor_number minor; rtems_rfs_rtems_device_get_major_and_minor (iop, &major, &minor); return rtems_deviceio_control (iop, command, buffer, major, minor);
40020694:	d6 02 20 2c 	ld  [ %o0 + 0x2c ], %o3                        <== NOT EXECUTED
40020698:	d8 02 20 30 	ld  [ %o0 + 0x30 ], %o4                        <== NOT EXECUTED
4002069c:	82 13 c0 00 	mov  %o7, %g1                                  <== NOT EXECUTED
400206a0:	40 00 05 75 	call  40021c74 <rtems_deviceio_control>        <== NOT EXECUTED
400206a4:	9e 10 40 00 	mov  %g1, %o7                                  <== NOT EXECUTED
                                                                      

400206e4 <rtems_rfs_rtems_device_open>: static int rtems_rfs_rtems_device_open ( rtems_libio_t *iop, const char *pathname, int oflag, mode_t mode) {
400206e4:	9d e3 bf 78 	save  %sp, -136, %sp                           <== NOT EXECUTED
  rtems_rfs_file_system*        fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
400206e8:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        <== NOT EXECUTED
  rtems_rfs_ino                 ino = rtems_rfs_rtems_get_iop_ino (iop);
400206ec:	e0 06 20 1c 	ld  [ %i0 + 0x1c ], %l0                        <== NOT EXECUTED
rtems_rfs_rtems_device_open ( rtems_libio_t *iop,                     
                              const char    *pathname,                
                              int            oflag,                   
                              mode_t         mode)                    
{                                                                     
  rtems_rfs_file_system*        fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
400206f0:	fa 00 60 08 	ld  [ %g1 + 8 ], %i5                           <== 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);
400206f4:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
  .fstat_h     = rtems_rfs_rtems_fstat,                               
  .ftruncate_h = rtems_rfs_rtems_device_ftruncate,                    
  .fsync_h     = rtems_filesystem_default_fsync_or_fdatasync,         
  .fdatasync_h = rtems_filesystem_default_fsync_or_fdatasync,         
  .fcntl_h     = rtems_filesystem_default_fcntl                       
};                                                                    
400206f8:	c2 07 60 80 	ld  [ %i5 + 0x80 ], %g1                        <== NOT EXECUTED
400206fc:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
40020700:	7f ff b1 7a 	call  4000cce8 <rtems_semaphore_obtain>        <== NOT EXECUTED
40020704:	d0 00 40 00 	ld  [ %g1 ], %o0                               <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL)                                         
40020708:	b8 92 20 00 	orcc  %o0, 0, %i4                              <== NOT EXECUTED
4002070c:	12 80 00 17 	bne  40020768 <rtems_rfs_rtems_device_open+0x84><== NOT EXECUTED
40020710:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
  rtems_device_minor_number     minor;                                
  int                           rc;                                   
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
40020714:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40020718:	92 10 00 10 	mov  %l0, %o1                                  <== NOT EXECUTED
4002071c:	94 07 bf d8 	add  %fp, -40, %o2                             <== NOT EXECUTED
40020720:	7f ff c7 3a 	call  40012408 <rtems_rfs_inode_open>          <== NOT EXECUTED
40020724:	96 10 20 01 	mov  1, %o3                                    <== NOT EXECUTED
  if (rc > 0)                                                         
40020728:	b8 92 20 00 	orcc  %o0, 0, %i4                              <== NOT EXECUTED
4002072c:	04 80 00 23 	ble  400207b8 <rtems_rfs_rtems_device_open+0xd4><== NOT EXECUTED
40020730:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         <== 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);            
40020734:	f6 07 60 80 	ld  [ %i5 + 0x80 ], %i3                        <== NOT EXECUTED
  rtems_rfs_buffers_release (fs);                                     
40020738:	7f ff f1 04 	call  4001cb48 <rtems_rfs_buffers_release>     <== NOT EXECUTED
4002073c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)                       
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_release (*mutex);            
40020740:	7f ff b1 b9 	call  4000ce24 <rtems_semaphore_release>       <== NOT EXECUTED
40020744:	d0 06 c0 00 	ld  [ %i3 ], %o0                               <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL)                                         
40020748:	ba 92 20 00 	orcc  %o0, 0, %i5                              <== NOT EXECUTED
4002074c:	12 80 00 4c 	bne  4002087c <rtems_rfs_rtems_device_open+0x198><== NOT EXECUTED
40020750:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
    return rtems_rfs_rtems_error ("device_open: closing inode", rc);  
40020754:	40 00 08 79 	call  40022938 <__errno>                       <== NOT EXECUTED
40020758:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4002075c:	f8 22 00 00 	st  %i4, [ %o0 ]                               <== NOT EXECUTED
40020760:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40020764:	81 e8 00 00 	restore                                        <== NOT EXECUTED
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
  if (sc != RTEMS_SUCCESSFUL)                                         
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
40020768:	7f ff cd cf 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4002076c:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40020770:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40020774:	22 bf ff e9 	be,a   40020718 <rtems_rfs_rtems_device_open+0x34><== NOT EXECUTED
40020778:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
      printf ("rtems-rfs: mutex: obtain failed: %s\n",                
4002077c:	7f ff dc 25 	call  40017810 <rtems_status_text>             <== NOT EXECUTED
40020780:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
40020784:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40020788:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
4002078c:	40 00 0d fc 	call  40023f7c <printf>                        <== NOT EXECUTED
40020790:	90 12 23 58 	or  %o0, 0x358, %o0	! 40035f58 <_CPU_Trap_slot_template+0xc70><== NOT EXECUTED
  rtems_device_minor_number     minor;                                
  int                           rc;                                   
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
40020794:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40020798:	92 10 00 10 	mov  %l0, %o1                                  <== NOT EXECUTED
4002079c:	94 07 bf d8 	add  %fp, -40, %o2                             <== NOT EXECUTED
400207a0:	7f ff c7 1a 	call  40012408 <rtems_rfs_inode_open>          <== NOT EXECUTED
400207a4:	96 10 20 01 	mov  1, %o3                                    <== NOT EXECUTED
  if (rc > 0)                                                         
400207a8:	b8 92 20 00 	orcc  %o0, 0, %i4                              <== NOT EXECUTED
400207ac:	34 bf ff e3 	bg,a   40020738 <rtems_rfs_rtems_device_open+0x54><== NOT EXECUTED
400207b0:	f6 07 60 80 	ld  [ %i5 + 0x80 ], %i3                        <== 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]);      
400207b4:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         <== 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);                            
400207b8:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
400207bc:	ec 08 60 1c 	ldub  [ %g1 + 0x1c ], %l6                      <== NOT EXECUTED
400207c0:	ea 08 60 1d 	ldub  [ %g1 + 0x1d ], %l5                      <== NOT EXECUTED
400207c4:	e6 08 60 1e 	ldub  [ %g1 + 0x1e ], %l3                      <== NOT EXECUTED
400207c8:	e8 08 60 1f 	ldub  [ %g1 + 0x1f ], %l4                      <== NOT EXECUTED
400207cc:	e4 08 60 20 	ldub  [ %g1 + 0x20 ], %l2                      <== NOT EXECUTED
400207d0:	e2 08 60 21 	ldub  [ %g1 + 0x21 ], %l1                      <== NOT EXECUTED
400207d4:	e0 08 60 22 	ldub  [ %g1 + 0x22 ], %l0                      <== NOT EXECUTED
400207d8:	ee 08 60 23 	ldub  [ %g1 + 0x23 ], %l7                      <== NOT EXECUTED
400207dc:	7f ff c7 83 	call  400125e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
400207e0:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
  if (rc > 0)                                                         
400207e4:	b8 92 20 00 	orcc  %o0, 0, %i4                              <== NOT EXECUTED
400207e8:	34 bf ff d4 	bg,a   40020738 <rtems_rfs_rtems_device_open+0x54><== NOT EXECUTED
400207ec:	f6 07 60 80 	ld  [ %i5 + 0x80 ], %i3                        <== 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);            
400207f0:	f8 07 60 80 	ld  [ %i5 + 0x80 ], %i4                        <== NOT EXECUTED
  rtems_rfs_buffers_release (fs);                                     
400207f4:	7f ff f0 d5 	call  4001cb48 <rtems_rfs_buffers_release>     <== NOT EXECUTED
400207f8:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)                       
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_release (*mutex);            
400207fc:	7f ff b1 8a 	call  4000ce24 <rtems_semaphore_release>       <== NOT EXECUTED
40020800:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL)                                         
40020804:	ba 92 20 00 	orcc  %o0, 0, %i5                              <== NOT EXECUTED
40020808:	12 80 00 2d 	bne  400208bc <rtems_rfs_rtems_device_open+0x1d8><== NOT EXECUTED
4002080c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
40020810:	ad 2d a0 18 	sll  %l6, 0x18, %l6                            <== NOT EXECUTED
40020814:	a8 0d 20 ff 	and  %l4, 0xff, %l4                            <== NOT EXECUTED
40020818:	a5 2c a0 18 	sll  %l2, 0x18, %l2                            <== NOT EXECUTED
4002081c:	ae 0d e0 ff 	and  %l7, 0xff, %l7                            <== NOT EXECUTED
  rtems_rfs_rtems_unlock (fs);                                        
                                                                      
  iop->data0 = major;                                                 
  iop->data1 = (void *) minor;                                        
                                                                      
  return rtems_deviceio_open (iop, pathname, oflag, mode, minor, major);
40020820:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40020824:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
40020828:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
4002082c:	96 10 00 1b 	mov  %i3, %o3                                  <== NOT EXECUTED
40020830:	aa 0d 60 ff 	and  %l5, 0xff, %l5                            <== NOT EXECUTED
40020834:	a6 0c e0 ff 	and  %l3, 0xff, %l3                            <== NOT EXECUTED
40020838:	ab 2d 60 10 	sll  %l5, 0x10, %l5                            <== NOT EXECUTED
4002083c:	a7 2c e0 08 	sll  %l3, 8, %l3                               <== NOT EXECUTED
40020840:	9a 15 80 15 	or  %l6, %l5, %o5                              <== NOT EXECUTED
40020844:	a2 0c 60 ff 	and  %l1, 0xff, %l1                            <== NOT EXECUTED
40020848:	9a 13 40 14 	or  %o5, %l4, %o5                              <== NOT EXECUTED
4002084c:	a3 2c 60 10 	sll  %l1, 0x10, %l1                            <== NOT EXECUTED
40020850:	9a 13 40 13 	or  %o5, %l3, %o5                              <== NOT EXECUTED
40020854:	98 14 80 11 	or  %l2, %l1, %o4                              <== NOT EXECUTED
    return rtems_rfs_rtems_error ("device_open: closing inode", rc);  
  }                                                                   
                                                                      
  rtems_rfs_rtems_unlock (fs);                                        
                                                                      
  iop->data0 = major;                                                 
40020858:	da 26 20 2c 	st  %o5, [ %i0 + 0x2c ]                        <== NOT EXECUTED
4002085c:	98 13 00 17 	or  %o4, %l7, %o4                              <== NOT EXECUTED
40020860:	a0 0c 20 ff 	and  %l0, 0xff, %l0                            <== NOT EXECUTED
40020864:	a1 2c 20 08 	sll  %l0, 8, %l0                               <== NOT EXECUTED
40020868:	98 13 00 10 	or  %o4, %l0, %o4                              <== NOT EXECUTED
  iop->data1 = (void *) minor;                                        
                                                                      
  return rtems_deviceio_open (iop, pathname, oflag, mode, minor, major);
4002086c:	40 00 04 b3 	call  40021b38 <rtems_deviceio_open>           <== NOT EXECUTED
40020870:	d8 26 20 30 	st  %o4, [ %i0 + 0x30 ]                        <== NOT EXECUTED
}                                                                     
40020874:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40020878:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
4002087c:	7f ff cd 8a 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
40020880:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40020884:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40020888:	02 bf ff b3 	be  40020754 <rtems_rfs_rtems_device_open+0x70><== NOT EXECUTED
4002088c:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: release failed: %s\n",               
40020890:	7f ff db e0 	call  40017810 <rtems_status_text>             <== NOT EXECUTED
40020894:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40020898:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
4002089c:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
400208a0:	40 00 0d b7 	call  40023f7c <printf>                        <== NOT EXECUTED
400208a4:	90 12 22 f0 	or  %o0, 0x2f0, %o0	! 40035ef0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
    return rtems_rfs_rtems_error ("device_open: closing inode", rc);  
400208a8:	40 00 08 24 	call  40022938 <__errno>                       <== NOT EXECUTED
400208ac:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
400208b0:	f8 22 00 00 	st  %i4, [ %o0 ]                               <== NOT EXECUTED
400208b4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400208b8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_release (*mutex);            
  if (sc != RTEMS_SUCCESSFUL)                                         
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
400208bc:	7f ff cd 7a 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
400208c0:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
400208c4:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
400208c8:	22 bf ff d3 	be,a   40020814 <rtems_rfs_rtems_device_open+0x130><== NOT EXECUTED
400208cc:	ad 2d a0 18 	sll  %l6, 0x18, %l6                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: release failed: %s\n",               
400208d0:	7f ff db d0 	call  40017810 <rtems_status_text>             <== NOT EXECUTED
400208d4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
400208d8:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
400208dc:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
400208e0:	40 00 0d a7 	call  40023f7c <printf>                        <== NOT EXECUTED
400208e4:	90 12 22 f0 	or  %o0, 0x2f0, %o0	! 40035ef0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
400208e8:	10 bf ff cb 	b  40020814 <rtems_rfs_rtems_device_open+0x130><== NOT EXECUTED
400208ec:	ad 2d a0 18 	sll  %l6, 0x18, %l6                            <== NOT EXECUTED
                                                                      

400206bc <rtems_rfs_rtems_device_read>: rtems_device_major_number major; rtems_device_minor_number minor; rtems_rfs_rtems_device_get_major_and_minor (iop, &major, &minor); return rtems_deviceio_read (iop, buffer, count, major, minor);
400206bc:	d6 02 20 2c 	ld  [ %o0 + 0x2c ], %o3                        <== NOT EXECUTED
400206c0:	d8 02 20 30 	ld  [ %o0 + 0x30 ], %o4                        <== NOT EXECUTED
400206c4:	82 13 c0 00 	mov  %o7, %g1                                  <== NOT EXECUTED
400206c8:	40 00 05 35 	call  40021b9c <rtems_deviceio_read>           <== NOT EXECUTED
400206cc:	9e 10 40 00 	mov  %g1, %o7                                  <== NOT EXECUTED
                                                                      

400206a8 <rtems_rfs_rtems_device_write>: rtems_device_major_number major; rtems_device_minor_number minor; rtems_rfs_rtems_device_get_major_and_minor (iop, &major, &minor); return rtems_deviceio_write (iop, buffer, count, major, minor);
400206a8:	d6 02 20 2c 	ld  [ %o0 + 0x2c ], %o3                        <== NOT EXECUTED
400206ac:	d8 02 20 30 	ld  [ %o0 + 0x30 ], %o4                        <== NOT EXECUTED
400206b0:	82 13 c0 00 	mov  %o7, %g1                                  <== NOT EXECUTED
400206b4:	40 00 05 55 	call  40021c08 <rtems_deviceio_write>          <== NOT EXECUTED
400206b8:	9e 10 40 00 	mov  %g1, %o7                                  <== NOT EXECUTED
                                                                      

400208f8 <rtems_rfs_rtems_dir_open>: static int rtems_rfs_rtems_dir_open (rtems_libio_t* iop, const char* pathname, int oflag, mode_t mode) {
400208f8:	9d e3 bf 78 	save  %sp, -136, %sp                           
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
400208fc:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
  rtems_rfs_ino          ino = rtems_rfs_rtems_get_iop_ino (iop);     
40020900:	f6 06 20 1c 	ld  [ %i0 + 0x1c ], %i3                        
rtems_rfs_rtems_dir_open (rtems_libio_t* iop,                         
                          const char*    pathname,                    
                          int            oflag,                       
                          mode_t         mode)                        
{                                                                     
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
40020904:	fa 00 60 08 	ld  [ %g1 + 8 ], %i5                           
 */                                                                   
static inline int                                                     
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)                         
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
40020908:	92 10 20 00 	clr  %o1                                       
  .fstat_h     = rtems_rfs_rtems_fstat,                               
  .ftruncate_h = rtems_filesystem_default_ftruncate_directory,        
  .fsync_h     = rtems_filesystem_default_fsync_or_fdatasync,         
  .fdatasync_h = rtems_rfs_rtems_fdatasync,                           
  .fcntl_h     = rtems_filesystem_default_fcntl                       
};                                                                    
4002090c:	c2 07 60 80 	ld  [ %i5 + 0x80 ], %g1                        
40020910:	94 10 20 00 	clr  %o2                                       
40020914:	7f ff b0 f5 	call  4000cce8 <rtems_semaphore_obtain>        
40020918:	d0 00 40 00 	ld  [ %g1 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
4002091c:	b8 92 20 00 	orcc  %o0, 0, %i4                              
40020920:	12 80 00 2d 	bne  400209d4 <rtems_rfs_rtems_dir_open+0xdc>  <== NEVER TAKEN
40020924:	90 10 20 00 	clr  %o0                                       
  rtems_rfs_inode_handle inode;                                       
  int                    rc;                                          
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
40020928:	90 10 00 1d 	mov  %i5, %o0                                  
4002092c:	92 10 00 1b 	mov  %i3, %o1                                  
40020930:	94 07 bf d8 	add  %fp, -40, %o2                             
40020934:	7f ff c6 b5 	call  40012408 <rtems_rfs_inode_open>          
40020938:	96 10 20 01 	mov  1, %o3                                    
  if (rc)                                                             
4002093c:	b8 92 20 00 	orcc  %o0, 0, %i4                              
40020940:	32 80 00 39 	bne,a   40020a24 <rtems_rfs_rtems_dir_open+0x12c><== NEVER TAKEN
40020944:	f6 07 60 80 	ld  [ %i5 + 0x80 ], %i3                        <== 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);                    
40020948:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
4002094c:	c4 08 60 02 	ldub  [ %g1 + 2 ], %g2                         
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
    return rtems_rfs_rtems_error ("dir_open: opening inode", rc);     
  }                                                                   
                                                                      
  if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))         
40020950:	03 00 00 3c 	sethi  %hi(0xf000), %g1                        
40020954:	85 28 a0 08 	sll  %g2, 8, %g2                               
40020958:	84 08 80 01 	and  %g2, %g1, %g2                             
4002095c:	03 00 00 10 	sethi  %hi(0x4000), %g1                        
40020960:	80 a0 80 01 	cmp  %g2, %g1                                  
40020964:	12 80 00 48 	bne  40020a84 <rtems_rfs_rtems_dir_open+0x18c> <== NEVER TAKEN
40020968:	92 07 bf d8 	add  %fp, -40, %o1                             
    return rtems_rfs_rtems_error ("dir_open: not dir", ENOTDIR);      
  }                                                                   
                                                                      
  iop->offset = 0;                                                    
                                                                      
  rtems_rfs_inode_close (fs, &inode);                                 
4002096c:	90 10 00 1d 	mov  %i5, %o0                                  
    rtems_rfs_inode_close (fs, &inode);                               
    rtems_rfs_rtems_unlock (fs);                                      
    return rtems_rfs_rtems_error ("dir_open: not dir", ENOTDIR);      
  }                                                                   
                                                                      
  iop->offset = 0;                                                    
40020970:	c0 26 20 08 	clr  [ %i0 + 8 ]                               
                                                                      
  rtems_rfs_inode_close (fs, &inode);                                 
40020974:	7f ff c7 1d 	call  400125e8 <rtems_rfs_inode_close>         
40020978:	c0 26 20 0c 	clr  [ %i0 + 0xc ]                             
 * 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);            
4002097c:	f8 07 60 80 	ld  [ %i5 + 0x80 ], %i4                        
  rtems_rfs_buffers_release (fs);                                     
40020980:	7f ff f0 72 	call  4001cb48 <rtems_rfs_buffers_release>     
40020984:	90 10 00 1d 	mov  %i5, %o0                                  
 */                                                                   
static inline int                                                     
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)                       
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_release (*mutex);            
40020988:	7f ff b1 27 	call  4000ce24 <rtems_semaphore_release>       
4002098c:	d0 07 00 00 	ld  [ %i4 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
40020990:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40020994:	12 80 00 04 	bne  400209a4 <rtems_rfs_rtems_dir_open+0xac>  <== NEVER TAKEN
40020998:	90 10 20 00 	clr  %o0                                       
  rtems_rfs_rtems_unlock (fs);                                        
  return 0;                                                           
}                                                                     
4002099c:	81 c7 e0 08 	ret                                            
400209a0:	91 e8 20 00 	restore  %g0, 0, %o0                           
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
400209a4:	7f ff cd 40 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
400209a8:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
400209ac:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
400209b0:	02 bf ff fb 	be  4002099c <rtems_rfs_rtems_dir_open+0xa4>   <== NOT EXECUTED
400209b4:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: release failed: %s\n",               
400209b8:	7f ff db 96 	call  40017810 <rtems_status_text>             <== NOT EXECUTED
400209bc:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
400209c0:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
400209c4:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
400209c8:	40 00 0d 6d 	call  40023f7c <printf>                        <== NOT EXECUTED
400209cc:	90 12 22 f0 	or  %o0, 0x2f0, %o0	! 40035ef0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
400209d0:	30 bf ff f3 	b,a   4002099c <rtems_rfs_rtems_dir_open+0xa4> <== NOT EXECUTED
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
  if (sc != RTEMS_SUCCESSFUL)                                         
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
400209d4:	7f ff cd 34 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
400209d8:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
400209dc:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
400209e0:	22 bf ff d3 	be,a   4002092c <rtems_rfs_rtems_dir_open+0x34><== NOT EXECUTED
400209e4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
      printf ("rtems-rfs: mutex: obtain failed: %s\n",                
400209e8:	7f ff db 8a 	call  40017810 <rtems_status_text>             <== NOT EXECUTED
400209ec:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
400209f0:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
400209f4:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
400209f8:	40 00 0d 61 	call  40023f7c <printf>                        <== NOT EXECUTED
400209fc:	90 12 23 58 	or  %o0, 0x358, %o0	! 40035f58 <_CPU_Trap_slot_template+0xc70><== NOT EXECUTED
  rtems_rfs_inode_handle inode;                                       
  int                    rc;                                          
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
40020a00:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40020a04:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
40020a08:	94 07 bf d8 	add  %fp, -40, %o2                             <== NOT EXECUTED
40020a0c:	7f ff c6 7f 	call  40012408 <rtems_rfs_inode_open>          <== NOT EXECUTED
40020a10:	96 10 20 01 	mov  1, %o3                                    <== NOT EXECUTED
  if (rc)                                                             
40020a14:	b8 92 20 00 	orcc  %o0, 0, %i4                              <== NOT EXECUTED
40020a18:	02 bf ff cd 	be  4002094c <rtems_rfs_rtems_dir_open+0x54>   <== NOT EXECUTED
40020a1c:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         <== 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);            
40020a20:	f6 07 60 80 	ld  [ %i5 + 0x80 ], %i3                        <== NOT EXECUTED
  rtems_rfs_buffers_release (fs);                                     
40020a24:	7f ff f0 49 	call  4001cb48 <rtems_rfs_buffers_release>     <== NOT EXECUTED
40020a28:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)                       
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_release (*mutex);            
40020a2c:	7f ff b0 fe 	call  4000ce24 <rtems_semaphore_release>       <== NOT EXECUTED
40020a30:	d0 06 c0 00 	ld  [ %i3 ], %o0                               <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL)                                         
40020a34:	ba 92 20 00 	orcc  %o0, 0, %i5                              <== NOT EXECUTED
40020a38:	12 80 00 07 	bne  40020a54 <rtems_rfs_rtems_dir_open+0x15c> <== NOT EXECUTED
40020a3c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
    return rtems_rfs_rtems_error ("dir_open: opening inode", rc);     
40020a40:	40 00 07 be 	call  40022938 <__errno>                       <== NOT EXECUTED
40020a44:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40020a48:	f8 22 00 00 	st  %i4, [ %o0 ]                               <== NOT EXECUTED
40020a4c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40020a50:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
40020a54:	7f ff cd 14 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
40020a58:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40020a5c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40020a60:	02 bf ff f8 	be  40020a40 <rtems_rfs_rtems_dir_open+0x148>  <== NOT EXECUTED
40020a64:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: release failed: %s\n",               
40020a68:	7f ff db 6a 	call  40017810 <rtems_status_text>             <== NOT EXECUTED
40020a6c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40020a70:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40020a74:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
40020a78:	40 00 0d 41 	call  40023f7c <printf>                        <== NOT EXECUTED
40020a7c:	90 12 22 f0 	or  %o0, 0x2f0, %o0	! 40035ef0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
40020a80:	30 bf ff f0 	b,a   40020a40 <rtems_rfs_rtems_dir_open+0x148><== NOT EXECUTED
  }                                                                   
                                                                      
  if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))         
  {                                                                   
    rtems_rfs_inode_close (fs, &inode);                               
40020a84:	7f ff c6 d9 	call  400125e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
40020a88:	90 10 00 1d 	mov  %i5, %o0                                  <== 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);            
40020a8c:	f8 07 60 80 	ld  [ %i5 + 0x80 ], %i4                        <== NOT EXECUTED
  rtems_rfs_buffers_release (fs);                                     
40020a90:	7f ff f0 2e 	call  4001cb48 <rtems_rfs_buffers_release>     <== NOT EXECUTED
40020a94:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)                       
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_release (*mutex);            
40020a98:	7f ff b0 e3 	call  4000ce24 <rtems_semaphore_release>       <== NOT EXECUTED
40020a9c:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL)                                         
40020aa0:	ba 92 20 00 	orcc  %o0, 0, %i5                              <== NOT EXECUTED
40020aa4:	12 80 00 08 	bne  40020ac4 <rtems_rfs_rtems_dir_open+0x1cc> <== NOT EXECUTED
40020aa8:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
    rtems_rfs_rtems_unlock (fs);                                      
    return rtems_rfs_rtems_error ("dir_open: not dir", ENOTDIR);      
40020aac:	40 00 07 a3 	call  40022938 <__errno>                       <== NOT EXECUTED
40020ab0:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40020ab4:	82 10 20 14 	mov  0x14, %g1                                 <== NOT EXECUTED
40020ab8:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
40020abc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40020ac0:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
40020ac4:	7f ff cc f8 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
40020ac8:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40020acc:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40020ad0:	02 bf ff f7 	be  40020aac <rtems_rfs_rtems_dir_open+0x1b4>  <== NOT EXECUTED
40020ad4:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: release failed: %s\n",               
40020ad8:	7f ff db 4e 	call  40017810 <rtems_status_text>             <== NOT EXECUTED
40020adc:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40020ae0:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40020ae4:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
40020ae8:	40 00 0d 25 	call  40023f7c <printf>                        <== NOT EXECUTED
40020aec:	90 12 22 f0 	or  %o0, 0x2f0, %o0	! 40035ef0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
40020af0:	30 bf ff ef 	b,a   40020aac <rtems_rfs_rtems_dir_open+0x1b4><== NOT EXECUTED
                                                                      

40020af4 <rtems_rfs_rtems_dir_read>: */ static ssize_t rtems_rfs_rtems_dir_read (rtems_libio_t* iop, void* buffer, size_t count) {
40020af4:	9d e3 bf 70 	save  %sp, -144, %sp                           
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
40020af8:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
  rtems_rfs_ino          ino = rtems_rfs_rtems_get_iop_ino (iop);     
40020afc:	f8 06 20 1c 	ld  [ %i0 + 0x1c ], %i4                        
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);
40020b00:	e0 00 60 08 	ld  [ %g1 + 8 ], %l0                           
 */                                                                   
static inline int                                                     
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)                         
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
40020b04:	92 10 20 00 	clr  %o1                                       
  .fstat_h     = rtems_rfs_rtems_fstat,                               
  .ftruncate_h = rtems_filesystem_default_ftruncate_directory,        
  .fsync_h     = rtems_filesystem_default_fsync_or_fdatasync,         
  .fdatasync_h = rtems_rfs_rtems_fdatasync,                           
  .fcntl_h     = rtems_filesystem_default_fcntl                       
};                                                                    
40020b08:	c2 04 20 80 	ld  [ %l0 + 0x80 ], %g1                        
40020b0c:	94 10 20 00 	clr  %o2                                       
40020b10:	7f ff b0 76 	call  4000cce8 <rtems_semaphore_obtain>        
40020b14:	d0 00 40 00 	ld  [ %g1 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
40020b18:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40020b1c:	12 80 00 41 	bne  40020c20 <rtems_rfs_rtems_dir_read+0x12c> <== NEVER TAKEN
40020b20:	90 10 20 00 	clr  %o0                                       
  count  = count / sizeof (struct dirent);                            
  dirent = buffer;                                                    
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
40020b24:	92 10 00 1c 	mov  %i4, %o1                                  
40020b28:	90 10 00 10 	mov  %l0, %o0                                  
40020b2c:	94 07 bf d8 	add  %fp, -40, %o2                             
40020b30:	7f ff c6 36 	call  40012408 <rtems_rfs_inode_open>          
40020b34:	96 10 20 01 	mov  1, %o3                                    
  if (rc)                                                             
40020b38:	b8 92 20 00 	orcc  %o0, 0, %i4                              
40020b3c:	32 80 00 4d 	bne,a   40020c70 <rtems_rfs_rtems_dir_read+0x17c><== NEVER TAKEN
40020b40:	fa 04 20 80 	ld  [ %l0 + 0x80 ], %i5                        <== NOT EXECUTED
  struct dirent*         dirent;                                      
  ssize_t                bytes_transferred;                           
  int                    d;                                           
  int                    rc;                                          
                                                                      
  count  = count / sizeof (struct dirent);                            
40020b44:	90 10 00 1a 	mov  %i2, %o0                                  
40020b48:	92 10 21 18 	mov  0x118, %o1                                
40020b4c:	7f ff 86 d5 	call  400026a0 <.udiv>                         
40020b50:	ba 10 20 00 	clr  %i5                                       
    return rtems_rfs_rtems_error ("dir_read: read inode", rc);        
  }                                                                   
                                                                      
  bytes_transferred = 0;                                              
                                                                      
  for (d = 0; d < count; d++, dirent++)                               
40020b54:	b4 92 20 00 	orcc  %o0, 0, %i2                              
40020b58:	02 80 00 1a 	be  40020bc0 <rtems_rfs_rtems_dir_read+0xcc>   <== NEVER TAKEN
40020b5c:	92 07 bf d8 	add  %fp, -40, %o1                             
40020b60:	d4 1e 20 08 	ldd  [ %i0 + 8 ], %o2                          
 * 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,                         
40020b64:	b6 10 20 00 	clr  %i3                                       
40020b68:	10 80 00 0d 	b  40020b9c <rtems_rfs_rtems_dir_read+0xa8>    
40020b6c:	ba 10 20 00 	clr  %i5                                       
    if (rc == ENOENT)                                                 
    {                                                                 
      rc = 0;                                                         
      break;                                                          
    }                                                                 
    if (rc > 0)                                                       
40020b70:	80 a2 20 00 	cmp  %o0, 0                                    
40020b74:	14 80 00 4b 	bg  40020ca0 <rtems_rfs_rtems_dir_read+0x1ac>  <== NEVER TAKEN
40020b78:	d4 07 bf d4 	ld  [ %fp + -44 ], %o2                         
    {                                                                 
      bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
      break;                                                          
    }                                                                 
    iop->offset += size;                                              
40020b7c:	c4 1e 20 08 	ldd  [ %i0 + 8 ], %g2                          
    return rtems_rfs_rtems_error ("dir_read: read inode", rc);        
  }                                                                   
                                                                      
  bytes_transferred = 0;                                              
                                                                      
  for (d = 0; d < count; d++, dirent++)                               
40020b80:	b6 06 e0 01 	inc  %i3                                       
    if (rc > 0)                                                       
    {                                                                 
      bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
      break;                                                          
    }                                                                 
    iop->offset += size;                                              
40020b84:	96 80 c0 0a 	addcc  %g3, %o2, %o3                           
40020b88:	94 40 a0 00 	addx  %g2, 0, %o2                              
40020b8c:	d4 3e 20 08 	std  %o2, [ %i0 + 8 ]                          
    return rtems_rfs_rtems_error ("dir_read: read inode", rc);        
  }                                                                   
                                                                      
  bytes_transferred = 0;                                              
                                                                      
  for (d = 0; d < count; d++, dirent++)                               
40020b90:	80 a6 c0 1a 	cmp  %i3, %i2                                  
40020b94:	02 80 00 0a 	be  40020bbc <rtems_rfs_rtems_dir_read+0xc8>   <== ALWAYS TAKEN
40020b98:	ba 07 61 18 	add  %i5, 0x118, %i5                           
  {                                                                   
    size_t size;                                                      
    rc = rtems_rfs_dir_read (fs, &inode, iop->offset, dirent, &size); 
40020b9c:	98 06 40 1d 	add  %i1, %i5, %o4                             
40020ba0:	90 10 00 10 	mov  %l0, %o0                                  
40020ba4:	92 07 bf d8 	add  %fp, -40, %o1                             
40020ba8:	7f ff f3 fe 	call  4001dba0 <rtems_rfs_dir_read>            
40020bac:	9a 07 bf d4 	add  %fp, -44, %o5                             
    if (rc == ENOENT)                                                 
40020bb0:	80 a2 20 02 	cmp  %o0, 2                                    
40020bb4:	12 bf ff ef 	bne  40020b70 <rtems_rfs_rtems_dir_read+0x7c>  
40020bb8:	b8 10 00 08 	mov  %o0, %i4                                  
    }                                                                 
    iop->offset += size;                                              
    bytes_transferred += sizeof (struct dirent);                      
  }                                                                   
                                                                      
  rtems_rfs_inode_close (fs, &inode);                                 
40020bbc:	92 07 bf d8 	add  %fp, -40, %o1                             
40020bc0:	7f ff c6 8a 	call  400125e8 <rtems_rfs_inode_close>         
40020bc4:	90 10 00 10 	mov  %l0, %o0                                  
 * 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);            
40020bc8:	f8 04 20 80 	ld  [ %l0 + 0x80 ], %i4                        
  rtems_rfs_buffers_release (fs);                                     
40020bcc:	7f ff ef df 	call  4001cb48 <rtems_rfs_buffers_release>     
40020bd0:	90 10 00 10 	mov  %l0, %o0                                  
 */                                                                   
static inline int                                                     
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)                       
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_release (*mutex);            
40020bd4:	7f ff b0 94 	call  4000ce24 <rtems_semaphore_release>       
40020bd8:	d0 07 00 00 	ld  [ %i4 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
40020bdc:	b8 92 20 00 	orcc  %o0, 0, %i4                              
40020be0:	12 80 00 04 	bne  40020bf0 <rtems_rfs_rtems_dir_read+0xfc>  <== NEVER TAKEN
40020be4:	90 10 20 00 	clr  %o0                                       
  rtems_rfs_rtems_unlock (fs);                                        
                                                                      
  return bytes_transferred;                                           
}                                                                     
40020be8:	81 c7 e0 08 	ret                                            
40020bec:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
40020bf0:	7f ff cc ad 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
40020bf4:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40020bf8:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40020bfc:	02 bf ff fb 	be  40020be8 <rtems_rfs_rtems_dir_read+0xf4>   <== NOT EXECUTED
40020c00:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: release failed: %s\n",               
40020c04:	7f ff db 03 	call  40017810 <rtems_status_text>             <== NOT EXECUTED
40020c08:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
40020c0c:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40020c10:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
40020c14:	40 00 0c da 	call  40023f7c <printf>                        <== NOT EXECUTED
40020c18:	90 12 22 f0 	or  %o0, 0x2f0, %o0	! 40035ef0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
40020c1c:	30 bf ff f3 	b,a   40020be8 <rtems_rfs_rtems_dir_read+0xf4> <== NOT EXECUTED
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
  if (sc != RTEMS_SUCCESSFUL)                                         
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
40020c20:	7f ff cc a1 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
40020c24:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40020c28:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40020c2c:	02 bf ff bf 	be  40020b28 <rtems_rfs_rtems_dir_read+0x34>   <== NOT EXECUTED
40020c30:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
      printf ("rtems-rfs: mutex: obtain failed: %s\n",                
40020c34:	7f ff da f7 	call  40017810 <rtems_status_text>             <== NOT EXECUTED
40020c38:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40020c3c:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40020c40:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
40020c44:	40 00 0c ce 	call  40023f7c <printf>                        <== NOT EXECUTED
40020c48:	90 12 23 58 	or  %o0, 0x358, %o0	! 40035f58 <_CPU_Trap_slot_template+0xc70><== NOT EXECUTED
  count  = count / sizeof (struct dirent);                            
  dirent = buffer;                                                    
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
40020c4c:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
40020c50:	90 10 00 10 	mov  %l0, %o0                                  <== NOT EXECUTED
40020c54:	94 07 bf d8 	add  %fp, -40, %o2                             <== NOT EXECUTED
40020c58:	7f ff c5 ec 	call  40012408 <rtems_rfs_inode_open>          <== NOT EXECUTED
40020c5c:	96 10 20 01 	mov  1, %o3                                    <== NOT EXECUTED
  if (rc)                                                             
40020c60:	b8 92 20 00 	orcc  %o0, 0, %i4                              <== NOT EXECUTED
40020c64:	02 bf ff b9 	be  40020b48 <rtems_rfs_rtems_dir_read+0x54>   <== NOT EXECUTED
40020c68:	90 10 00 1a 	mov  %i2, %o0                                  <== 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);            
40020c6c:	fa 04 20 80 	ld  [ %l0 + 0x80 ], %i5                        <== NOT EXECUTED
  rtems_rfs_buffers_release (fs);                                     
40020c70:	7f ff ef b6 	call  4001cb48 <rtems_rfs_buffers_release>     <== NOT EXECUTED
40020c74:	90 10 00 10 	mov  %l0, %o0                                  <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)                       
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_release (*mutex);            
40020c78:	7f ff b0 6b 	call  4000ce24 <rtems_semaphore_release>       <== NOT EXECUTED
40020c7c:	d0 07 40 00 	ld  [ %i5 ], %o0                               <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL)                                         
40020c80:	ba 92 20 00 	orcc  %o0, 0, %i5                              <== NOT EXECUTED
40020c84:	12 80 00 16 	bne  40020cdc <rtems_rfs_rtems_dir_read+0x1e8> <== NOT EXECUTED
40020c88:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
    return rtems_rfs_rtems_error ("dir_read: read inode", rc);        
40020c8c:	40 00 07 2b 	call  40022938 <__errno>                       <== NOT EXECUTED
40020c90:	ba 10 3f ff 	mov  -1, %i5                                   <== NOT EXECUTED
40020c94:	f8 22 00 00 	st  %i4, [ %o0 ]                               <== NOT EXECUTED
                                                                      
  rtems_rfs_inode_close (fs, &inode);                                 
  rtems_rfs_rtems_unlock (fs);                                        
                                                                      
  return bytes_transferred;                                           
}                                                                     
40020c98:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40020c9c:	91 e8 00 1d 	restore  %g0, %i5, %o0                         <== NOT EXECUTED
      rc = 0;                                                         
      break;                                                          
    }                                                                 
    if (rc > 0)                                                       
    {                                                                 
      bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
40020ca0:	40 00 07 26 	call  40022938 <__errno>                       <== NOT EXECUTED
40020ca4:	ba 10 3f ff 	mov  -1, %i5                                   <== NOT EXECUTED
    }                                                                 
    iop->offset += size;                                              
    bytes_transferred += sizeof (struct dirent);                      
  }                                                                   
                                                                      
  rtems_rfs_inode_close (fs, &inode);                                 
40020ca8:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
      rc = 0;                                                         
      break;                                                          
    }                                                                 
    if (rc > 0)                                                       
    {                                                                 
      bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
40020cac:	f8 22 00 00 	st  %i4, [ %o0 ]                               <== NOT EXECUTED
    }                                                                 
    iop->offset += size;                                              
    bytes_transferred += sizeof (struct dirent);                      
  }                                                                   
                                                                      
  rtems_rfs_inode_close (fs, &inode);                                 
40020cb0:	7f ff c6 4e 	call  400125e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
40020cb4:	90 10 00 10 	mov  %l0, %o0                                  <== 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);            
40020cb8:	f8 04 20 80 	ld  [ %l0 + 0x80 ], %i4                        <== NOT EXECUTED
  rtems_rfs_buffers_release (fs);                                     
40020cbc:	7f ff ef a3 	call  4001cb48 <rtems_rfs_buffers_release>     <== NOT EXECUTED
40020cc0:	90 10 00 10 	mov  %l0, %o0                                  <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)                       
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_release (*mutex);            
40020cc4:	7f ff b0 58 	call  4000ce24 <rtems_semaphore_release>       <== NOT EXECUTED
40020cc8:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL)                                         
40020ccc:	b8 92 20 00 	orcc  %o0, 0, %i4                              <== NOT EXECUTED
40020cd0:	02 bf ff c6 	be  40020be8 <rtems_rfs_rtems_dir_read+0xf4>   <== NOT EXECUTED
40020cd4:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
40020cd8:	30 bf ff c6 	b,a   40020bf0 <rtems_rfs_rtems_dir_read+0xfc> <== NOT EXECUTED
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
40020cdc:	7f ff cc 72 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
40020ce0:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40020ce4:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40020ce8:	02 bf ff e9 	be  40020c8c <rtems_rfs_rtems_dir_read+0x198>  <== NOT EXECUTED
40020cec:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: release failed: %s\n",               
40020cf0:	7f ff da c8 	call  40017810 <rtems_status_text>             <== NOT EXECUTED
40020cf4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40020cf8:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40020cfc:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
40020d00:	40 00 0c 9f 	call  40023f7c <printf>                        <== NOT EXECUTED
40020d04:	90 12 22 f0 	or  %o0, 0x2f0, %o0	! 40035ef0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
40020d08:	30 bf ff e1 	b,a   40020c8c <rtems_rfs_rtems_dir_read+0x198><== NOT EXECUTED
                                                                      

40013488 <rtems_rfs_rtems_eval_path>: .eval_token = rtems_rfs_rtems_eval_token }; static void rtems_rfs_rtems_eval_path (rtems_filesystem_eval_path_context_t *ctx) {
40013488:	9d e3 bf 78 	save  %sp, -136, %sp                           
  rtems_filesystem_location_info_t *currentloc =                      
    rtems_filesystem_eval_path_get_currentloc (ctx);                  
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (currentloc);
4001348c:	c2 06 20 2c 	ld  [ %i0 + 0x2c ], %g1                        
  rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (currentloc);   
  rtems_rfs_inode_handle inode;                                       
  int rc;                                                             
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
40013490:	d2 06 20 20 	ld  [ %i0 + 0x20 ], %o1                        
static void                                                           
rtems_rfs_rtems_eval_path (rtems_filesystem_eval_path_context_t *ctx) 
{                                                                     
  rtems_filesystem_location_info_t *currentloc =                      
    rtems_filesystem_eval_path_get_currentloc (ctx);                  
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (currentloc);
40013494:	fa 00 60 08 	ld  [ %g1 + 8 ], %i5                           
  rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (currentloc);   
  rtems_rfs_inode_handle inode;                                       
  int rc;                                                             
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
40013498:	94 07 bf d8 	add  %fp, -40, %o2                             
4001349c:	90 10 00 1d 	mov  %i5, %o0                                  
400134a0:	7f ff fb da 	call  40012408 <rtems_rfs_inode_open>          
400134a4:	96 10 20 01 	mov  1, %o3                                    
  if (rc == 0) {                                                      
400134a8:	b8 92 20 00 	orcc  %o0, 0, %i4                              
400134ac:	12 80 00 0e 	bne  400134e4 <rtems_rfs_rtems_eval_path+0x5c> <== NEVER TAKEN
400134b0:	92 07 bf d8 	add  %fp, -40, %o1                             
    rtems_filesystem_eval_path_generic (                              
400134b4:	90 10 00 18 	mov  %i0, %o0                                  
400134b8:	15 10 00 d8 	sethi  %hi(0x40036000), %o2                    
400134bc:	40 00 12 d9 	call  40018020 <rtems_filesystem_eval_path_generic>
400134c0:	94 12 a0 00 	mov  %o2, %o2	! 40036000 <rtems_rfs_rtems_eval_config>
      ctx,                                                            
      &inode,                                                         
      &rtems_rfs_rtems_eval_config                                    
    );                                                                
    rc = rtems_rfs_inode_close (fs, &inode);                          
400134c4:	90 10 00 1d 	mov  %i5, %o0                                  
400134c8:	7f ff fc 48 	call  400125e8 <rtems_rfs_inode_close>         
400134cc:	92 07 bf d8 	add  %fp, -40, %o1                             
    if (rc != 0) {                                                    
400134d0:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400134d4:	12 80 00 0c 	bne  40013504 <rtems_rfs_rtems_eval_path+0x7c> <== NEVER TAKEN
400134d8:	01 00 00 00 	nop                                            
400134dc:	81 c7 e0 08 	ret                                            
400134e0:	81 e8 00 00 	restore                                        
      );                                                              
    }                                                                 
  } else {                                                            
    rtems_filesystem_eval_path_error (                                
      ctx,                                                            
      rtems_rfs_rtems_error ("eval_path: opening inode", rc)          
400134e4:	40 00 3d 15 	call  40022938 <__errno>                       <== NOT EXECUTED
400134e8:	01 00 00 00 	nop                                            <== NOT EXECUTED
        ctx,                                                          
        rtems_rfs_rtems_error ("eval_path: closing inode", rc)        
      );                                                              
    }                                                                 
  } else {                                                            
    rtems_filesystem_eval_path_error (                                
400134ec:	92 10 3f ff 	mov  -1, %o1	! ffffffff <LEON_REG+0x7fffffff>  <== NOT EXECUTED
      ctx,                                                            
      rtems_rfs_rtems_error ("eval_path: opening inode", rc)          
400134f0:	f8 22 00 00 	st  %i4, [ %o0 ]                               <== NOT EXECUTED
        ctx,                                                          
        rtems_rfs_rtems_error ("eval_path: closing inode", rc)        
      );                                                              
    }                                                                 
  } else {                                                            
    rtems_filesystem_eval_path_error (                                
400134f4:	7f ff d8 4d 	call  40009628 <rtems_filesystem_eval_path_error><== NOT EXECUTED
400134f8:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
400134fc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40013500:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    );                                                                
    rc = rtems_rfs_inode_close (fs, &inode);                          
    if (rc != 0) {                                                    
      rtems_filesystem_eval_path_error (                              
        ctx,                                                          
        rtems_rfs_rtems_error ("eval_path: closing inode", rc)        
40013504:	40 00 3d 0d 	call  40022938 <__errno>                       <== NOT EXECUTED
40013508:	01 00 00 00 	nop                                            <== NOT EXECUTED
      &inode,                                                         
      &rtems_rfs_rtems_eval_config                                    
    );                                                                
    rc = rtems_rfs_inode_close (fs, &inode);                          
    if (rc != 0) {                                                    
      rtems_filesystem_eval_path_error (                              
4001350c:	92 10 3f ff 	mov  -1, %o1	! ffffffff <LEON_REG+0x7fffffff>  <== NOT EXECUTED
        ctx,                                                          
        rtems_rfs_rtems_error ("eval_path: closing inode", rc)        
40013510:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
      &inode,                                                         
      &rtems_rfs_rtems_eval_config                                    
    );                                                                
    rc = rtems_rfs_inode_close (fs, &inode);                          
    if (rc != 0) {                                                    
      rtems_filesystem_eval_path_error (                              
40013514:	7f ff d8 45 	call  40009628 <rtems_filesystem_eval_path_error><== NOT EXECUTED
40013518:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001351c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40013520:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40013830 <rtems_rfs_rtems_eval_token>: rtems_filesystem_eval_path_context_t *ctx, void *arg, const char *token, size_t tokenlen ) {
40013830:	9d e3 bf 90 	save  %sp, -112, %sp                           
 * @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);                    
40013834:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
static bool                                                           
rtems_rfs_rtems_eval_perms (rtems_filesystem_eval_path_context_t *ctx,
                            int eval_flags,                           
                            rtems_rfs_inode_handle* inode)            
{                                                                     
  return rtems_filesystem_eval_path_check_access(                     
40013838:	90 10 00 18 	mov  %i0, %o0                                  
 * @return uint16_t The user id (uid).                                
 */                                                                   
static inline uint16_t                                                
rtems_rfs_inode_get_uid (rtems_rfs_inode_handle* handle)              
{                                                                     
  return rtems_rfs_read_u32 (&handle->node->owner) & 0xffff;          
4001383c:	c6 08 60 06 	ldub  [ %g1 + 6 ], %g3                         
 * @return uint16_t The group id (gid).                               
 */                                                                   
static inline uint16_t                                                
rtems_rfs_inode_get_gid (rtems_rfs_inode_handle* handle)              
{                                                                     
  return (rtems_rfs_read_u32 (&handle->node->owner) >> 16) & 0xffff;  
40013840:	c4 08 60 05 	ldub  [ %g1 + 5 ], %g2                         
 * @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);                    
40013844:	c8 08 60 02 	ldub  [ %g1 + 2 ], %g4                         
 * @return uint16_t The user id (uid).                                
 */                                                                   
static inline uint16_t                                                
rtems_rfs_inode_get_uid (rtems_rfs_inode_handle* handle)              
{                                                                     
  return rtems_rfs_read_u32 (&handle->node->owner) & 0xffff;          
40013848:	d6 08 60 07 	ldub  [ %g1 + 7 ], %o3                         
4001384c:	d4 08 60 03 	ldub  [ %g1 + 3 ], %o2                         
 * @return uint16_t The group id (gid).                               
 */                                                                   
static inline uint16_t                                                
rtems_rfs_inode_get_gid (rtems_rfs_inode_handle* handle)              
{                                                                     
  return (rtems_rfs_read_u32 (&handle->node->owner) >> 16) & 0xffff;  
40013850:	d8 08 60 04 	ldub  [ %g1 + 4 ], %o4                         
 * @return uint16_t The user id (uid).                                
 */                                                                   
static inline uint16_t                                                
rtems_rfs_inode_get_uid (rtems_rfs_inode_handle* handle)              
{                                                                     
  return rtems_rfs_read_u32 (&handle->node->owner) & 0xffff;          
40013854:	87 28 e0 08 	sll  %g3, 8, %g3                               
 * @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);                    
40013858:	83 29 20 08 	sll  %g4, 8, %g1                               
 * @return uint16_t The group id (gid).                               
 */                                                                   
static inline uint16_t                                                
rtems_rfs_inode_get_gid (rtems_rfs_inode_handle* handle)              
{                                                                     
  return (rtems_rfs_read_u32 (&handle->node->owner) >> 16) & 0xffff;  
4001385c:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
 * @return uint16_t The user id (uid).                                
 */                                                                   
static inline uint16_t                                                
rtems_rfs_inode_get_uid (rtems_rfs_inode_handle* handle)              
{                                                                     
  return rtems_rfs_read_u32 (&handle->node->owner) & 0xffff;          
40013860:	96 10 c0 0b 	or  %g3, %o3, %o3                              
  rtems_filesystem_eval_path_context_t *ctx,                          
  void *arg,                                                          
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
40013864:	ba 10 00 18 	mov  %i0, %i5                                  
 * @return uint16_t The group id (gid).                               
 */                                                                   
static inline uint16_t                                                
rtems_rfs_inode_get_gid (rtems_rfs_inode_handle* handle)              
{                                                                     
  return (rtems_rfs_read_u32 (&handle->node->owner) >> 16) & 0xffff;  
40013868:	99 2b 20 18 	sll  %o4, 0x18, %o4                            
static bool                                                           
rtems_rfs_rtems_eval_perms (rtems_filesystem_eval_path_context_t *ctx,
                            int eval_flags,                           
                            rtems_rfs_inode_handle* inode)            
{                                                                     
  return rtems_filesystem_eval_path_check_access(                     
4001386c:	97 2a e0 10 	sll  %o3, 0x10, %o3                            
40013870:	98 13 00 02 	or  %o4, %g2, %o4                              
40013874:	92 10 20 01 	mov  1, %o1                                    
40013878:	94 12 80 01 	or  %o2, %g1, %o2                              
4001387c:	97 32 e0 10 	srl  %o3, 0x10, %o3                            
40013880:	99 33 20 10 	srl  %o4, 0x10, %o4                            
40013884:	40 00 11 da 	call  40017fec <rtems_filesystem_eval_path_check_access>
40013888:	b0 10 20 01 	mov  1, %i0                                    
  rtems_filesystem_eval_path_generic_status status =                  
    RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;                          
  rtems_rfs_inode_handle* inode = arg;                                
  bool access_ok = rtems_rfs_rtems_eval_perms (ctx, RTEMS_FS_PERMS_EXEC, inode);
                                                                      
  if (access_ok) {                                                    
4001388c:	80 8a 20 ff 	btst  0xff, %o0                                
40013890:	02 80 00 39 	be  40013974 <rtems_rfs_rtems_eval_token+0x144>
40013894:	80 a6 e0 01 	cmp  %i3, 1                                    
static inline bool rtems_filesystem_is_current_directory(             
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  return tokenlen == 1 && token [0] == '.';                           
40013898:	22 80 00 39 	be,a   4001397c <rtems_rfs_rtems_eval_token+0x14c>
4001389c:	c2 4e 80 00 	ldsb  [ %i2 ], %g1                             
    if (rtems_filesystem_is_current_directory (token, tokenlen)) {    
      rtems_filesystem_eval_path_clear_token (ctx);                   
    } else {                                                          
      rtems_filesystem_location_info_t *currentloc =                  
        rtems_filesystem_eval_path_get_currentloc( ctx );             
      rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (currentloc);
400138a0:	c2 07 60 2c 	ld  [ %i5 + 0x2c ], %g1                        
      rtems_rfs_ino entry_ino;                                        
      uint32_t entry_doff;                                            
      int rc = rtems_rfs_dir_lookup_ino (                             
400138a4:	92 10 00 19 	mov  %i1, %o1                                  
    if (rtems_filesystem_is_current_directory (token, tokenlen)) {    
      rtems_filesystem_eval_path_clear_token (ctx);                   
    } else {                                                          
      rtems_filesystem_location_info_t *currentloc =                  
        rtems_filesystem_eval_path_get_currentloc( ctx );             
      rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (currentloc);
400138a8:	f8 00 60 08 	ld  [ %g1 + 8 ], %i4                           
      rtems_rfs_ino entry_ino;                                        
      uint32_t entry_doff;                                            
      int rc = rtems_rfs_dir_lookup_ino (                             
400138ac:	94 10 00 1a 	mov  %i2, %o2                                  
400138b0:	90 10 00 1c 	mov  %i4, %o0                                  
400138b4:	96 10 00 1b 	mov  %i3, %o3                                  
400138b8:	98 07 bf f4 	add  %fp, -12, %o4                             
400138bc:	40 00 25 4b 	call  4001cde8 <rtems_rfs_dir_lookup_ino>      
400138c0:	9a 07 bf f8 	add  %fp, -8, %o5                              
        tokenlen,                                                     
        &entry_ino,                                                   
        &entry_doff                                                   
      );                                                              
                                                                      
      if (rc == 0) {                                                  
400138c4:	80 a2 20 00 	cmp  %o0, 0                                    
400138c8:	12 80 00 2b 	bne  40013974 <rtems_rfs_rtems_eval_token+0x144>
400138cc:	b0 10 20 02 	mov  2, %i0                                    
        rc = rtems_rfs_inode_close (fs, inode);                       
400138d0:	90 10 00 1c 	mov  %i4, %o0                                  
400138d4:	7f ff fb 45 	call  400125e8 <rtems_rfs_inode_close>         
400138d8:	92 10 00 19 	mov  %i1, %o1                                  
        if (rc == 0) {                                                
400138dc:	80 a2 20 00 	cmp  %o0, 0                                    
400138e0:	12 80 00 2d 	bne  40013994 <rtems_rfs_rtems_eval_token+0x164><== NEVER TAKEN
400138e4:	90 10 00 19 	mov  %i1, %o0                                  
          rc = rtems_rfs_inode_open (fs, entry_ino, inode, true);     
400138e8:	d2 07 bf f4 	ld  [ %fp + -12 ], %o1                         
400138ec:	90 10 00 1c 	mov  %i4, %o0                                  
400138f0:	94 10 00 19 	mov  %i1, %o2                                  
400138f4:	7f ff fa c5 	call  40012408 <rtems_rfs_inode_open>          
400138f8:	96 10 20 01 	mov  1, %o3                                    
        }                                                             
                                                                      
        if (rc != 0) {                                                
400138fc:	80 a2 20 00 	cmp  %o0, 0                                    
40013900:	12 80 00 25 	bne  40013994 <rtems_rfs_rtems_eval_token+0x164><== NEVER TAKEN
40013904:	90 10 00 19 	mov  %i1, %o0                                  
        status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;         
        rc = -1;                                                      
      }                                                               
                                                                      
      if (rc == 0) {                                                  
        bool is_sym_link = rtems_rfs_rtems_node_type_by_inode (inode) 
40013908:	7f ff fd 0a 	call  40012d30 <rtems_rfs_rtems_node_type_by_inode>
4001390c:	90 10 00 19 	mov  %i1, %o0                                  
          == RTEMS_FILESYSTEM_SYM_LINK;                               
        int eval_flags = rtems_filesystem_eval_path_get_flags (ctx);  
        bool follow_sym_link = (eval_flags & RTEMS_FS_FOLLOW_SYM_LINK) != 0;
        bool terminal = !rtems_filesystem_eval_path_has_path (ctx);   
40013910:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
                                                                      
      if (rc == 0) {                                                  
        bool is_sym_link = rtems_rfs_rtems_node_type_by_inode (inode) 
          == RTEMS_FILESYSTEM_SYM_LINK;                               
        int eval_flags = rtems_filesystem_eval_path_get_flags (ctx);  
        bool follow_sym_link = (eval_flags & RTEMS_FS_FOLLOW_SYM_LINK) != 0;
40013914:	c4 07 60 10 	ld  [ %i5 + 0x10 ], %g2                        
        bool terminal = !rtems_filesystem_eval_path_has_path (ctx);   
40013918:	80 a0 00 01 	cmp  %g0, %g1                                  
                                                                      
static inline void rtems_filesystem_eval_path_clear_token(            
  rtems_filesystem_eval_path_context_t *ctx                           
)                                                                     
{                                                                     
  ctx->tokenlen = 0;                                                  
4001391c:	c0 27 60 0c 	clr  [ %i5 + 0xc ]                             
40013920:	82 60 3f ff 	subx  %g0, -1, %g1                             
                                                                      
      if (rc == 0) {                                                  
        bool is_sym_link = rtems_rfs_rtems_node_type_by_inode (inode) 
          == RTEMS_FILESYSTEM_SYM_LINK;                               
        int eval_flags = rtems_filesystem_eval_path_get_flags (ctx);  
        bool follow_sym_link = (eval_flags & RTEMS_FS_FOLLOW_SYM_LINK) != 0;
40013924:	85 30 a0 04 	srl  %g2, 4, %g2                               
        bool terminal = !rtems_filesystem_eval_path_has_path (ctx);   
40013928:	b0 10 00 01 	mov  %g1, %i0                                  
                                                                      
        rtems_filesystem_eval_path_clear_token (ctx);                 
                                                                      
        if (is_sym_link && (follow_sym_link || !terminal)) {          
4001392c:	80 a2 20 03 	cmp  %o0, 3                                    
40013930:	12 80 00 07 	bne  4001394c <rtems_rfs_rtems_eval_token+0x11c>
40013934:	84 08 a0 01 	and  %g2, 1, %g2                               
40013938:	80 a0 60 00 	cmp  %g1, 0                                    
4001393c:	02 80 00 25 	be  400139d0 <rtems_rfs_rtems_eval_token+0x1a0>
40013940:	80 88 a0 ff 	btst  0xff, %g2                                
40013944:	12 80 00 24 	bne  400139d4 <rtems_rfs_rtems_eval_token+0x1a4>
40013948:	82 10 24 00 	mov  0x400, %g1                                
          rtems_rfs_rtems_follow_link (ctx, fs, entry_ino);           
        } else {                                                      
          rc = rtems_rfs_rtems_set_handlers (currentloc, inode) ? 0 : EIO;
4001394c:	90 07 60 18 	add  %i5, 0x18, %o0                            
40013950:	40 00 01 16 	call  40013da8 <rtems_rfs_rtems_set_handlers>  
40013954:	92 10 00 19 	mov  %i1, %o1                                  
40013958:	80 8a 20 ff 	btst  0xff, %o0                                
4001395c:	02 80 00 14 	be  400139ac <rtems_rfs_rtems_eval_token+0x17c><== NEVER TAKEN
40013960:	c2 07 bf f4 	ld  [ %fp + -12 ], %g1                         
  void *arg,                                                          
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  rtems_filesystem_eval_path_generic_status status =                  
40013964:	b0 0e 20 ff 	and  %i0, 0xff, %i0                            
        if (is_sym_link && (follow_sym_link || !terminal)) {          
          rtems_rfs_rtems_follow_link (ctx, fs, entry_ino);           
        } else {                                                      
          rc = rtems_rfs_rtems_set_handlers (currentloc, inode) ? 0 : EIO;
          if (rc == 0) {                                              
            rtems_rfs_rtems_set_pathloc_ino (currentloc, entry_ino);  
40013968:	c2 27 60 20 	st  %g1, [ %i5 + 0x20 ]                        
            rtems_rfs_rtems_set_pathloc_doff (currentloc, entry_doff);
4001396c:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
40013970:	c2 27 60 24 	st  %g1, [ %i5 + 0x24 ]                        
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  return status;                                                      
}                                                                     
40013974:	81 c7 e0 08 	ret                                            
40013978:	81 e8 00 00 	restore                                        
static inline bool rtems_filesystem_is_current_directory(             
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  return tokenlen == 1 && token [0] == '.';                           
4001397c:	80 a0 60 2e 	cmp  %g1, 0x2e                                 
40013980:	32 bf ff c9 	bne,a   400138a4 <rtems_rfs_rtems_eval_token+0x74>
40013984:	c2 07 60 2c 	ld  [ %i5 + 0x2c ], %g1                        
                                                                      
static inline void rtems_filesystem_eval_path_clear_token(            
  rtems_filesystem_eval_path_context_t *ctx                           
)                                                                     
{                                                                     
  ctx->tokenlen = 0;                                                  
40013988:	c0 27 60 0c 	clr  [ %i5 + 0xc ]                             
4001398c:	81 c7 e0 08 	ret                                            
40013990:	81 e8 00 00 	restore                                        
        if (rc != 0) {                                                
          /*                                                          
           * This prevents the rtems_rfs_inode_close() from doing something in
           * rtems_rfs_rtems_eval_path().                             
           */                                                         
          memset (inode, 0, sizeof(*inode));                          
40013994:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
40013998:	94 10 20 28 	mov  0x28, %o2                                 <== NOT EXECUTED
4001399c:	40 00 40 fa 	call  40023d84 <memset>                        <== NOT EXECUTED
400139a0:	b0 10 20 01 	mov  1, %i0                                    <== NOT EXECUTED
400139a4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400139a8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
              status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;   
            }                                                         
          } else {                                                    
            rtems_filesystem_eval_path_error (                        
              ctx,                                                    
              rtems_rfs_rtems_error ("eval_path: set handlers", rc)   
400139ac:	40 00 3b e3 	call  40022938 <__errno>                       <== NOT EXECUTED
400139b0:	b0 10 20 01 	mov  1, %i0                                    <== NOT EXECUTED
400139b4:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
                                                                      
            if (!terminal) {                                          
              status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;   
            }                                                         
          } else {                                                    
            rtems_filesystem_eval_path_error (                        
400139b8:	92 10 3f ff 	mov  -1, %o1                                   <== NOT EXECUTED
              ctx,                                                    
              rtems_rfs_rtems_error ("eval_path: set handlers", rc)   
400139bc:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
                                                                      
            if (!terminal) {                                          
              status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;   
            }                                                         
          } else {                                                    
            rtems_filesystem_eval_path_error (                        
400139c0:	7f ff d7 1a 	call  40009628 <rtems_filesystem_eval_path_error><== NOT EXECUTED
400139c4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
400139c8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400139cc:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  rtems_filesystem_eval_path_context_t* ctx,                          
  rtems_rfs_file_system* fs,                                          
  rtems_rfs_ino ino                                                   
)                                                                     
{                                                                     
  size_t len = MAXPATHLEN;                                            
400139d0:	82 10 24 00 	mov  0x400, %g1                                
        bool terminal = !rtems_filesystem_eval_path_has_path (ctx);   
                                                                      
        rtems_filesystem_eval_path_clear_token (ctx);                 
                                                                      
        if (is_sym_link && (follow_sym_link || !terminal)) {          
          rtems_rfs_rtems_follow_link (ctx, fs, entry_ino);           
400139d4:	f4 07 bf f4 	ld  [ %fp + -12 ], %i2                         
  rtems_rfs_file_system* fs,                                          
  rtems_rfs_ino ino                                                   
)                                                                     
{                                                                     
  size_t len = MAXPATHLEN;                                            
  char *link = malloc(len + 1);                                       
400139d8:	90 10 24 01 	mov  0x401, %o0                                
400139dc:	7f ff d2 f8 	call  400085bc <malloc>                        
400139e0:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
                                                                      
  if (link != NULL) {                                                 
400139e4:	b6 92 20 00 	orcc  %o0, 0, %i3                              
400139e8:	02 80 00 14 	be  40013a38 <rtems_rfs_rtems_eval_token+0x208><== NEVER TAKEN
400139ec:	90 10 00 1c 	mov  %i4, %o0                                  
    int rc = rtems_rfs_symlink_read (fs, ino, link, len, &len);       
400139f0:	92 10 00 1a 	mov  %i2, %o1                                  
400139f4:	94 10 00 1b 	mov  %i3, %o2                                  
400139f8:	96 10 24 00 	mov  0x400, %o3                                
400139fc:	40 00 32 82 	call  40020404 <rtems_rfs_symlink_read>        
40013a00:	98 07 bf fc 	add  %fp, -4, %o4                              
                                                                      
    if (rc == 0) {                                                    
40013a04:	80 a2 20 00 	cmp  %o0, 0                                    
40013a08:	12 80 00 09 	bne  40013a2c <rtems_rfs_rtems_eval_token+0x1fc><== NEVER TAKEN
40013a0c:	90 10 00 1d 	mov  %i5, %o0                                  
      rtems_filesystem_eval_path_recursive (ctx, link, len);          
40013a10:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          
40013a14:	7f ff d8 2d 	call  40009ac8 <rtems_filesystem_eval_path_recursive>
40013a18:	92 10 00 1b 	mov  %i3, %o1                                  
    } else {                                                          
      rtems_filesystem_eval_path_error (ctx, 0);                      
    }                                                                 
                                                                      
    free(link);                                                       
40013a1c:	7f ff d1 4b 	call  40007f48 <free>                          
40013a20:	90 10 00 1b 	mov  %i3, %o0                                  
  void *arg,                                                          
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  rtems_filesystem_eval_path_generic_status status =                  
40013a24:	81 c7 e0 08 	ret                                            
40013a28:	91 e8 20 01 	restore  %g0, 1, %o0                           
    int rc = rtems_rfs_symlink_read (fs, ino, link, len, &len);       
                                                                      
    if (rc == 0) {                                                    
      rtems_filesystem_eval_path_recursive (ctx, link, len);          
    } else {                                                          
      rtems_filesystem_eval_path_error (ctx, 0);                      
40013a2c:	7f ff d6 ff 	call  40009628 <rtems_filesystem_eval_path_error><== NOT EXECUTED
40013a30:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
40013a34:	30 bf ff fa 	b,a   40013a1c <rtems_rfs_rtems_eval_token+0x1ec><== NOT EXECUTED
    }                                                                 
                                                                      
    free(link);                                                       
  } else {                                                            
    rtems_filesystem_eval_path_error (ctx, ENOMEM);                   
40013a38:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40013a3c:	7f ff d6 fb 	call  40009628 <rtems_filesystem_eval_path_error><== NOT EXECUTED
40013a40:	92 10 20 0c 	mov  0xc, %o1                                  <== NOT EXECUTED
40013a44:	30 bf ff f8 	b,a   40013a24 <rtems_rfs_rtems_eval_token+0x1f4><== NOT EXECUTED
                                                                      

400131c8 <rtems_rfs_rtems_fchmod>: } static int rtems_rfs_rtems_fchmod (const rtems_filesystem_location_info_t* pathloc, mode_t mode) {
400131c8:	9d e3 bf 78 	save  %sp, -136, %sp                           
  rtems_rfs_file_system*  fs = rtems_rfs_rtems_pathloc_dev (pathloc); 
400131cc:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
                                                                      
  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);                                               
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
400131d0:	d2 06 20 08 	ld  [ %i0 + 8 ], %o1                           
                                                                      
static int                                                            
rtems_rfs_rtems_fchmod (const rtems_filesystem_location_info_t* pathloc,
                        mode_t                                  mode) 
{                                                                     
  rtems_rfs_file_system*  fs = rtems_rfs_rtems_pathloc_dev (pathloc); 
400131d4:	f8 00 60 08 	ld  [ %g1 + 8 ], %i4                           
                                                                      
  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);                                               
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
400131d8:	94 07 bf d8 	add  %fp, -40, %o2                             
400131dc:	90 10 00 1c 	mov  %i4, %o0                                  
400131e0:	7f ff fc 8a 	call  40012408 <rtems_rfs_inode_open>          
400131e4:	96 10 20 01 	mov  1, %o3                                    
  if (rc)                                                             
400131e8:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400131ec:	12 80 00 24 	bne  4001327c <rtems_rfs_rtems_fchmod+0xb4>    <== NEVER TAKEN
400131f0:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
 * @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);                    
400131f4:	c4 08 60 02 	ldub  [ %g1 + 2 ], %g2                         
400131f8:	c2 08 60 03 	ldub  [ %g1 + 3 ], %g1                         
400131fc:	85 28 a0 08 	sll  %g2, 8, %g2                               
                                                                      
  /*                                                                  
   *  Verify I am the owner of the node or the super user.            
   */                                                                 
#if defined (RTEMS_POSIX_API)                                         
  uid = geteuid();                                                    
40013200:	40 00 12 59 	call  40017b64 <geteuid>                       
40013204:	ba 10 80 01 	or  %g2, %g1, %i5                              
 * @return uint16_t The user id (uid).                                
 */                                                                   
static inline uint16_t                                                
rtems_rfs_inode_get_uid (rtems_rfs_inode_handle* handle)              
{                                                                     
  return rtems_rfs_read_u32 (&handle->node->owner) & 0xffff;          
40013208:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
                                                                      
  if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))        
4001320c:	91 2a 20 10 	sll  %o0, 0x10, %o0                            
40013210:	c4 08 60 06 	ldub  [ %g1 + 6 ], %g2                         
40013214:	c6 08 60 07 	ldub  [ %g1 + 7 ], %g3                         
40013218:	85 28 a0 08 	sll  %g2, 8, %g2                               
4001321c:	84 10 80 03 	or  %g2, %g3, %g2                              
40013220:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
40013224:	80 a0 80 08 	cmp  %g2, %o0                                  
40013228:	02 80 00 05 	be  4001323c <rtems_rfs_rtems_fchmod+0x74>     <== ALWAYS TAKEN
4001322c:	89 32 20 10 	srl  %o0, 0x10, %g4                            
40013230:	80 a1 20 00 	cmp  %g4, 0                                    <== NOT EXECUTED
40013234:	12 80 00 17 	bne  40013290 <rtems_rfs_rtems_fchmod+0xc8>    <== NOT EXECUTED
40013238:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
    rtems_rfs_inode_close (fs, &inode);                               
    return rtems_rfs_rtems_error ("fchmod: checking uid", EPERM);     
  }                                                                   
#endif                                                                
                                                                      
  imode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
4001323c:	ba 0f 70 00 	and  %i5, -4096, %i5                           
  imode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
40013240:	b2 0e 6f ff 	and  %i1, 0xfff, %i1                           
40013244:	b2 17 40 19 	or  %i5, %i1, %i1                              
 * @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);                    
40013248:	85 36 60 08 	srl  %i1, 8, %g2                               
4001324c:	c4 28 60 02 	stb  %g2, [ %g1 + 2 ]                          
40013250:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
                                                                      
  rtems_rfs_inode_set_mode (&inode, imode);                           
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
40013254:	90 10 00 1c 	mov  %i4, %o0                                  
40013258:	f2 28 60 03 	stb  %i1, [ %g1 + 3 ]                          
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
4001325c:	82 10 20 01 	mov  1, %g1                                    
40013260:	92 07 bf d8 	add  %fp, -40, %o1                             
40013264:	c2 2f bf e8 	stb  %g1, [ %fp + -24 ]                        
40013268:	7f ff fc e0 	call  400125e8 <rtems_rfs_inode_close>         
4001326c:	b0 10 20 00 	clr  %i0                                       
  if (rc > 0)                                                         
40013270:	80 a2 20 00 	cmp  %o0, 0                                    
40013274:	04 80 00 05 	ble  40013288 <rtems_rfs_rtems_fchmod+0xc0>    <== ALWAYS TAKEN
40013278:	ba 10 00 08 	mov  %o0, %i5                                  
  {                                                                   
    return rtems_rfs_rtems_error ("fchmod: closing inode", rc);       
4001327c:	40 00 3d af 	call  40022938 <__errno>                       <== NOT EXECUTED
40013280:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40013284:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
40013288:	81 c7 e0 08 	ret                                            
4001328c:	81 e8 00 00 	restore                                        
#if defined (RTEMS_POSIX_API)                                         
  uid = geteuid();                                                    
                                                                      
  if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))        
  {                                                                   
    rtems_rfs_inode_close (fs, &inode);                               
40013290:	7f ff fc d6 	call  400125e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
40013294:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
    return rtems_rfs_rtems_error ("fchmod: checking uid", EPERM);     
40013298:	40 00 3d a8 	call  40022938 <__errno>                       <== NOT EXECUTED
4001329c:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
400132a0:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
400132a4:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
400132a8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400132ac:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40013d74 <rtems_rfs_rtems_fdatasync>: * @param iop * @return int */ int rtems_rfs_rtems_fdatasync (rtems_libio_t* iop) {
40013d74:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
  int rc;                                                             
                                                                      
  rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
40013d78:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        <== NOT EXECUTED
  if (rc)                                                             
    return rtems_rfs_rtems_error ("fdatasync: sync", rc);             
                                                                      
  return 0;                                                           
40013d7c:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
int                                                                   
rtems_rfs_rtems_fdatasync (rtems_libio_t* iop)                        
{                                                                     
  int rc;                                                             
                                                                      
  rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
40013d80:	40 00 23 4c 	call  4001cab0 <rtems_rfs_buffer_sync>         <== NOT EXECUTED
40013d84:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           <== NOT EXECUTED
  if (rc)                                                             
40013d88:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40013d8c:	02 80 00 05 	be  40013da0 <rtems_rfs_rtems_fdatasync+0x2c>  <== NOT EXECUTED
40013d90:	ba 10 00 08 	mov  %o0, %i5                                  <== NOT EXECUTED
    return rtems_rfs_rtems_error ("fdatasync: sync", rc);             
40013d94:	40 00 3a e9 	call  40022938 <__errno>                       <== NOT EXECUTED
40013d98:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40013d9c:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
40013da0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40013da4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40020ef8 <rtems_rfs_rtems_file_close>: * @param iop * @return int */ static int rtems_rfs_rtems_file_close (rtems_libio_t* iop) {
40020ef8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
40020efc:	f8 06 20 20 	ld  [ %i0 + 0x20 ], %i4                        
 */                                                                   
static inline int                                                     
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)                         
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
40020f00:	92 10 20 00 	clr  %o1                                       
  rtems_rfs_file_system* fs = rtems_rfs_file_fs (file);               
40020f04:	c2 07 20 1c 	ld  [ %i4 + 0x1c ], %g1                        
40020f08:	94 10 20 00 	clr  %o2                                       
40020f0c:	fa 00 60 98 	ld  [ %g1 + 0x98 ], %i5                        
  .fstat_h     = rtems_rfs_rtems_fstat,                               
  .ftruncate_h = rtems_rfs_rtems_file_ftruncate,                      
  .fsync_h     = rtems_rfs_rtems_fdatasync,                           
  .fdatasync_h = rtems_rfs_rtems_fdatasync,                           
  .fcntl_h     = rtems_filesystem_default_fcntl                       
};                                                                    
40020f10:	c2 07 60 80 	ld  [ %i5 + 0x80 ], %g1                        
40020f14:	7f ff af 75 	call  4000cce8 <rtems_semaphore_obtain>        
40020f18:	d0 00 40 00 	ld  [ %g1 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
40020f1c:	b6 92 20 00 	orcc  %o0, 0, %i3                              
40020f20:	12 80 00 21 	bne  40020fa4 <rtems_rfs_rtems_file_close+0xac><== NEVER TAKEN
40020f24:	90 10 20 00 	clr  %o0                                       
  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);                               
40020f28:	90 10 00 1d 	mov  %i5, %o0                                  
40020f2c:	7f ff f5 7e 	call  4001e524 <rtems_rfs_file_close>          
40020f30:	92 10 00 1c 	mov  %i4, %o1                                  
  if (rc > 0)                                                         
40020f34:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40020f38:	24 80 00 07 	ble,a   40020f54 <rtems_rfs_rtems_file_close+0x5c><== ALWAYS TAKEN
40020f3c:	f8 07 60 80 	ld  [ %i5 + 0x80 ], %i4                        
    rc = rtems_rfs_rtems_error ("file-close: file close", rc);        
40020f40:	40 00 06 7e 	call  40022938 <__errno>                       <== NOT EXECUTED
40020f44:	01 00 00 00 	nop                                            <== NOT EXECUTED
40020f48:	f0 22 00 00 	st  %i0, [ %o0 ]                               <== NOT EXECUTED
40020f4c:	b0 10 3f ff 	mov  -1, %i0                                   <== 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);            
40020f50:	f8 07 60 80 	ld  [ %i5 + 0x80 ], %i4                        <== NOT EXECUTED
  rtems_rfs_buffers_release (fs);                                     
40020f54:	7f ff ee fd 	call  4001cb48 <rtems_rfs_buffers_release>     
40020f58:	90 10 00 1d 	mov  %i5, %o0                                  
 */                                                                   
static inline int                                                     
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)                       
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_release (*mutex);            
40020f5c:	7f ff af b2 	call  4000ce24 <rtems_semaphore_release>       
40020f60:	d0 07 00 00 	ld  [ %i4 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
40020f64:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40020f68:	02 80 00 0d 	be  40020f9c <rtems_rfs_rtems_file_close+0xa4> <== ALWAYS TAKEN
40020f6c:	90 10 20 00 	clr  %o0                                       
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
40020f70:	7f ff cb cd 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
40020f74:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40020f78:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40020f7c:	02 80 00 08 	be  40020f9c <rtems_rfs_rtems_file_close+0xa4> <== NOT EXECUTED
40020f80:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: release failed: %s\n",               
40020f84:	7f ff da 23 	call  40017810 <rtems_status_text>             <== NOT EXECUTED
40020f88:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40020f8c:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40020f90:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
40020f94:	40 00 0b fa 	call  40023f7c <printf>                        <== NOT EXECUTED
40020f98:	90 12 22 f0 	or  %o0, 0x2f0, %o0	! 40035ef0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
                                                                      
  rtems_rfs_rtems_unlock (fs);                                        
  return rc;                                                          
}                                                                     
40020f9c:	81 c7 e0 08 	ret                                            
40020fa0:	81 e8 00 00 	restore                                        
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
  if (sc != RTEMS_SUCCESSFUL)                                         
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
40020fa4:	7f ff cb c0 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
40020fa8:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40020fac:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40020fb0:	22 bf ff df 	be,a   40020f2c <rtems_rfs_rtems_file_close+0x34><== NOT EXECUTED
40020fb4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
      printf ("rtems-rfs: mutex: obtain failed: %s\n",                
40020fb8:	7f ff da 16 	call  40017810 <rtems_status_text>             <== NOT EXECUTED
40020fbc:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
40020fc0:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40020fc4:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
40020fc8:	40 00 0b ed 	call  40023f7c <printf>                        <== NOT EXECUTED
40020fcc:	90 12 23 58 	or  %o0, 0x358, %o0	! 40035f58 <_CPU_Trap_slot_template+0xc70><== 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);                               
40020fd0:	10 bf ff d7 	b  40020f2c <rtems_rfs_rtems_file_close+0x34>  <== NOT EXECUTED
40020fd4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
                                                                      

40020fd8 <rtems_rfs_rtems_file_ftruncate>: * @return int */ static int rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop, off_t length) {
40020fd8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
40020fdc:	f6 06 20 20 	ld  [ %i0 + 0x20 ], %i3                        
 */                                                                   
static inline int                                                     
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)                         
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
40020fe0:	92 10 20 00 	clr  %o1                                       
  int                    rc;                                          
                                                                      
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_FTRUNC))      
    printf("rtems-rfs: file-ftrunc: handle:%p length:%" PRIdoff_t "\n", file, length);
                                                                      
  rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));                    
40020fe4:	c2 06 e0 1c 	ld  [ %i3 + 0x1c ], %g1                        
40020fe8:	94 10 20 00 	clr  %o2                                       
 * Lock the RFS file system.                                          
 */                                                                   
static inline void                                                    
 rtems_rfs_rtems_lock (rtems_rfs_file_system* fs)                     
{                                                                     
  rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);            
40020fec:	c2 00 60 98 	ld  [ %g1 + 0x98 ], %g1                        
 * @return int                                                        
 */                                                                   
static int                                                            
rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,                   
                                off_t          length)                
{                                                                     
40020ff0:	ba 10 00 1a 	mov  %i2, %i5                                  
  .fstat_h     = rtems_rfs_rtems_fstat,                               
  .ftruncate_h = rtems_rfs_rtems_file_ftruncate,                      
  .fsync_h     = rtems_rfs_rtems_fdatasync,                           
  .fdatasync_h = rtems_rfs_rtems_fdatasync,                           
  .fcntl_h     = rtems_filesystem_default_fcntl                       
};                                                                    
40020ff4:	c2 00 60 80 	ld  [ %g1 + 0x80 ], %g1                        
 * @return int                                                        
 */                                                                   
static int                                                            
rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,                   
                                off_t          length)                
{                                                                     
40020ff8:	b8 10 00 19 	mov  %i1, %i4                                  
40020ffc:	7f ff af 3b 	call  4000cce8 <rtems_semaphore_obtain>        
40021000:	d0 00 40 00 	ld  [ %g1 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
40021004:	b4 92 20 00 	orcc  %o0, 0, %i2                              
40021008:	12 80 00 23 	bne  40021094 <rtems_rfs_rtems_file_ftruncate+0xbc><== NEVER TAKEN
4002100c:	90 10 20 00 	clr  %o0                                       
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_FTRUNC))      
    printf("rtems-rfs: file-ftrunc: handle:%p length:%" PRIdoff_t "\n", file, length);
                                                                      
  rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));                    
                                                                      
  rc = rtems_rfs_file_set_size (file, length);                        
40021010:	90 10 00 1b 	mov  %i3, %o0                                  
40021014:	92 10 00 1c 	mov  %i4, %o1                                  
40021018:	7f ff f7 93 	call  4001ee64 <rtems_rfs_file_set_size>       
4002101c:	94 10 00 1d 	mov  %i5, %o2                                  
  if (rc)                                                             
40021020:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40021024:	22 80 00 07 	be,a   40021040 <rtems_rfs_rtems_file_ftruncate+0x68><== ALWAYS TAKEN
40021028:	c2 06 e0 1c 	ld  [ %i3 + 0x1c ], %g1                        
    rc = rtems_rfs_rtems_error ("file_ftruncate: set size", rc);      
4002102c:	40 00 06 43 	call  40022938 <__errno>                       <== NOT EXECUTED
40021030:	01 00 00 00 	nop                                            <== NOT EXECUTED
40021034:	f0 22 00 00 	st  %i0, [ %o0 ]                               <== NOT EXECUTED
40021038:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
                                                                      
  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));                  
4002103c:	c2 06 e0 1c 	ld  [ %i3 + 0x1c ], %g1                        <== NOT EXECUTED
40021040:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
 */                                                                   
static inline void                                                    
 rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)                   
{                                                                     
  rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);            
  rtems_rfs_buffers_release (fs);                                     
40021044:	7f ff ee c1 	call  4001cb48 <rtems_rfs_buffers_release>     
40021048:	fa 02 20 80 	ld  [ %o0 + 0x80 ], %i5                        
 */                                                                   
static inline int                                                     
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)                       
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_release (*mutex);            
4002104c:	7f ff af 76 	call  4000ce24 <rtems_semaphore_release>       
40021050:	d0 07 40 00 	ld  [ %i5 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
40021054:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40021058:	02 80 00 0d 	be  4002108c <rtems_rfs_rtems_file_ftruncate+0xb4><== ALWAYS TAKEN
4002105c:	90 10 20 00 	clr  %o0                                       
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
40021060:	7f ff cb 91 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
40021064:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40021068:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4002106c:	02 80 00 08 	be  4002108c <rtems_rfs_rtems_file_ftruncate+0xb4><== NOT EXECUTED
40021070:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: release failed: %s\n",               
40021074:	7f ff d9 e7 	call  40017810 <rtems_status_text>             <== NOT EXECUTED
40021078:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4002107c:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40021080:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
40021084:	40 00 0b be 	call  40023f7c <printf>                        <== NOT EXECUTED
40021088:	90 12 22 f0 	or  %o0, 0x2f0, %o0	! 40035ef0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
                                                                      
  return rc;                                                          
}                                                                     
4002108c:	81 c7 e0 08 	ret                                            
40021090:	81 e8 00 00 	restore                                        
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
  if (sc != RTEMS_SUCCESSFUL)                                         
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
40021094:	7f ff cb 84 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
40021098:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
4002109c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
400210a0:	22 bf ff dd 	be,a   40021014 <rtems_rfs_rtems_file_ftruncate+0x3c><== NOT EXECUTED
400210a4:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
      printf ("rtems-rfs: mutex: obtain failed: %s\n",                
400210a8:	7f ff d9 da 	call  40017810 <rtems_status_text>             <== NOT EXECUTED
400210ac:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
400210b0:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
400210b4:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
400210b8:	40 00 0b b1 	call  40023f7c <printf>                        <== NOT EXECUTED
400210bc:	90 12 23 58 	or  %o0, 0x358, %o0	! 40035f58 <_CPU_Trap_slot_template+0xc70><== NOT EXECUTED
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_FTRUNC))      
    printf("rtems-rfs: file-ftrunc: handle:%p length:%" PRIdoff_t "\n", file, length);
                                                                      
  rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));                    
                                                                      
  rc = rtems_rfs_file_set_size (file, length);                        
400210c0:	10 bf ff d5 	b  40021014 <rtems_rfs_rtems_file_ftruncate+0x3c><== NOT EXECUTED
400210c4:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
                                                                      

400210c8 <rtems_rfs_rtems_file_lseek>: */ static off_t rtems_rfs_rtems_file_lseek (rtems_libio_t* iop, off_t offset, int whence) {
400210c8:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
400210cc:	e0 06 20 20 	ld  [ %i0 + 0x20 ], %l0                        
 */                                                                   
static inline int                                                     
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)                         
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
400210d0:	92 10 20 00 	clr  %o1                                       
  off_t                  new_offset;                                  
                                                                      
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_LSEEK))       
    printf("rtems-rfs: file-lseek: handle:%p offset:%" PRIdoff_t "\n", file, offset);
                                                                      
  rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));                    
400210d4:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
400210d8:	94 10 20 00 	clr  %o2                                       
 * Lock the RFS file system.                                          
 */                                                                   
static inline void                                                    
 rtems_rfs_rtems_lock (rtems_rfs_file_system* fs)                     
{                                                                     
  rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);            
400210dc:	c2 00 60 98 	ld  [ %g1 + 0x98 ], %g1                        
 */                                                                   
static off_t                                                          
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,                       
                            off_t          offset,                    
                            int            whence)                    
{                                                                     
400210e0:	b8 10 00 19 	mov  %i1, %i4                                  
  .fstat_h     = rtems_rfs_rtems_fstat,                               
  .ftruncate_h = rtems_rfs_rtems_file_ftruncate,                      
  .fsync_h     = rtems_rfs_rtems_fdatasync,                           
  .fdatasync_h = rtems_rfs_rtems_fdatasync,                           
  .fcntl_h     = rtems_filesystem_default_fcntl                       
};                                                                    
400210e4:	c2 00 60 80 	ld  [ %g1 + 0x80 ], %g1                        
 */                                                                   
static off_t                                                          
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,                       
                            off_t          offset,                    
                            int            whence)                    
{                                                                     
400210e8:	ba 10 00 1a 	mov  %i2, %i5                                  
400210ec:	d0 00 40 00 	ld  [ %g1 ], %o0                               
400210f0:	7f ff ae fe 	call  4000cce8 <rtems_semaphore_obtain>        
400210f4:	b2 10 00 1b 	mov  %i3, %i1                                  
  if (sc != RTEMS_SUCCESSFUL)                                         
400210f8:	b4 92 20 00 	orcc  %o0, 0, %i2                              
400210fc:	12 80 00 22 	bne  40021184 <rtems_rfs_rtems_file_lseek+0xbc><== NEVER TAKEN
40021100:	90 10 20 00 	clr  %o0                                       
    printf("rtems-rfs: file-lseek: handle:%p offset:%" PRIdoff_t "\n", file, offset);
                                                                      
  rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));                    
                                                                      
  old_offset = iop->offset;                                           
  new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
40021104:	92 10 00 1c 	mov  %i4, %o1                                  
40021108:	94 10 00 1d 	mov  %i5, %o2                                  
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_LSEEK))       
    printf("rtems-rfs: file-lseek: handle:%p offset:%" PRIdoff_t "\n", file, offset);
                                                                      
  rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));                    
                                                                      
  old_offset = iop->offset;                                           
4002110c:	f4 1e 20 08 	ldd  [ %i0 + 8 ], %i2                          
  new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
40021110:	90 10 00 18 	mov  %i0, %o0                                  
40021114:	40 00 01 99 	call  40021778 <rtems_filesystem_default_lseek_file>
40021118:	96 10 00 19 	mov  %i1, %o3                                  
4002111c:	b8 10 00 08 	mov  %o0, %i4                                  
  if (new_offset != -1)                                               
40021120:	80 a7 3f ff 	cmp  %i4, -1                                   
40021124:	02 80 00 2d 	be  400211d8 <rtems_rfs_rtems_file_lseek+0x110>
40021128:	ba 10 00 09 	mov  %o1, %i5                                  
  {                                                                   
    rtems_rfs_pos pos = iop->offset;                                  
4002112c:	c4 1e 20 08 	ldd  [ %i0 + 8 ], %g2                          
    int           rc = rtems_rfs_file_seek (file, pos, &pos);         
40021130:	90 10 00 10 	mov  %l0, %o0                                  
                                                                      
  old_offset = iop->offset;                                           
  new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
  if (new_offset != -1)                                               
  {                                                                   
    rtems_rfs_pos pos = iop->offset;                                  
40021134:	c4 3f bf f8 	std  %g2, [ %fp + -8 ]                         
    int           rc = rtems_rfs_file_seek (file, pos, &pos);         
40021138:	92 10 00 02 	mov  %g2, %o1                                  
4002113c:	94 10 00 03 	mov  %g3, %o2                                  
40021140:	7f ff f7 06 	call  4001ed58 <rtems_rfs_file_seek>           
40021144:	96 07 bf f8 	add  %fp, -8, %o3                              
                                                                      
    if (rc)                                                           
40021148:	b2 92 20 00 	orcc  %o0, 0, %i1                              
4002114c:	12 80 00 30 	bne  4002120c <rtems_rfs_rtems_file_lseek+0x144><== NEVER TAKEN
40021150:	01 00 00 00 	nop                                            
      iop->offset = old_offset;                                       
      new_offset = -1;                                                
    }                                                                 
  }                                                                   
                                                                      
  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));                  
40021154:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
40021158:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
 */                                                                   
static inline void                                                    
 rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)                   
{                                                                     
  rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);            
  rtems_rfs_buffers_release (fs);                                     
4002115c:	7f ff ee 7b 	call  4001cb48 <rtems_rfs_buffers_release>     
40021160:	f6 02 20 80 	ld  [ %o0 + 0x80 ], %i3                        
 */                                                                   
static inline int                                                     
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)                       
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_release (*mutex);            
40021164:	7f ff af 30 	call  4000ce24 <rtems_semaphore_release>       
40021168:	d0 06 c0 00 	ld  [ %i3 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
4002116c:	b6 92 20 00 	orcc  %o0, 0, %i3                              
40021170:	12 80 00 36 	bne  40021248 <rtems_rfs_rtems_file_lseek+0x180><== NEVER TAKEN
40021174:	90 10 20 00 	clr  %o0                                       
                                                                      
  return new_offset;                                                  
}                                                                     
40021178:	b0 10 00 1c 	mov  %i4, %i0                                  
4002117c:	81 c7 e0 08 	ret                                            
40021180:	93 e8 00 1d 	restore  %g0, %i5, %o1                         
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
  if (sc != RTEMS_SUCCESSFUL)                                         
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
40021184:	7f ff cb 48 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
40021188:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
4002118c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40021190:	02 bf ff de 	be  40021108 <rtems_rfs_rtems_file_lseek+0x40> <== NOT EXECUTED
40021194:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
      printf ("rtems-rfs: mutex: obtain failed: %s\n",                
40021198:	7f ff d9 9e 	call  40017810 <rtems_status_text>             <== NOT EXECUTED
4002119c:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
400211a0:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
400211a4:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
400211a8:	40 00 0b 75 	call  40023f7c <printf>                        <== NOT EXECUTED
400211ac:	90 12 23 58 	or  %o0, 0x358, %o0	! 40035f58 <_CPU_Trap_slot_template+0xc70><== NOT EXECUTED
    printf("rtems-rfs: file-lseek: handle:%p offset:%" PRIdoff_t "\n", file, offset);
                                                                      
  rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));                    
                                                                      
  old_offset = iop->offset;                                           
  new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
400211b0:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
400211b4:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_LSEEK))       
    printf("rtems-rfs: file-lseek: handle:%p offset:%" PRIdoff_t "\n", file, offset);
                                                                      
  rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));                    
                                                                      
  old_offset = iop->offset;                                           
400211b8:	f4 1e 20 08 	ldd  [ %i0 + 8 ], %i2                          <== NOT EXECUTED
  new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
400211bc:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
400211c0:	40 00 01 6e 	call  40021778 <rtems_filesystem_default_lseek_file><== NOT EXECUTED
400211c4:	96 10 00 19 	mov  %i1, %o3                                  <== NOT EXECUTED
400211c8:	b8 10 00 08 	mov  %o0, %i4                                  <== NOT EXECUTED
  if (new_offset != -1)                                               
400211cc:	80 a7 3f ff 	cmp  %i4, -1                                   <== NOT EXECUTED
400211d0:	12 bf ff d7 	bne  4002112c <rtems_rfs_rtems_file_lseek+0x64><== NOT EXECUTED
400211d4:	ba 10 00 09 	mov  %o1, %i5                                  <== NOT EXECUTED
400211d8:	80 a2 7f ff 	cmp  %o1, -1                                   
400211dc:	22 bf ff df 	be,a   40021158 <rtems_rfs_rtems_file_lseek+0x90><== ALWAYS TAKEN
400211e0:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
  {                                                                   
    rtems_rfs_pos pos = iop->offset;                                  
400211e4:	c4 1e 20 08 	ldd  [ %i0 + 8 ], %g2                          <== NOT EXECUTED
    int           rc = rtems_rfs_file_seek (file, pos, &pos);         
400211e8:	90 10 00 10 	mov  %l0, %o0                                  <== NOT EXECUTED
                                                                      
  old_offset = iop->offset;                                           
  new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
  if (new_offset != -1)                                               
  {                                                                   
    rtems_rfs_pos pos = iop->offset;                                  
400211ec:	c4 3f bf f8 	std  %g2, [ %fp + -8 ]                         <== NOT EXECUTED
    int           rc = rtems_rfs_file_seek (file, pos, &pos);         
400211f0:	92 10 00 02 	mov  %g2, %o1                                  <== NOT EXECUTED
400211f4:	94 10 00 03 	mov  %g3, %o2                                  <== NOT EXECUTED
400211f8:	7f ff f6 d8 	call  4001ed58 <rtems_rfs_file_seek>           <== NOT EXECUTED
400211fc:	96 07 bf f8 	add  %fp, -8, %o3                              <== NOT EXECUTED
                                                                      
    if (rc)                                                           
40021200:	b2 92 20 00 	orcc  %o0, 0, %i1                              <== NOT EXECUTED
40021204:	22 bf ff d5 	be,a   40021158 <rtems_rfs_rtems_file_lseek+0x90><== NOT EXECUTED
40021208:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        <== NOT EXECUTED
    {                                                                 
      rtems_rfs_rtems_error ("file_lseek: lseek", rc);                
4002120c:	40 00 05 cb 	call  40022938 <__errno>                       <== NOT EXECUTED
40021210:	39 3f ff ff 	sethi  %hi(0xfffffc00), %i4                    <== NOT EXECUTED
      iop->offset = old_offset;                                       
      new_offset = -1;                                                
    }                                                                 
  }                                                                   
                                                                      
  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));                  
40021214:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        <== NOT EXECUTED
    rtems_rfs_pos pos = iop->offset;                                  
    int           rc = rtems_rfs_file_seek (file, pos, &pos);         
                                                                      
    if (rc)                                                           
    {                                                                 
      rtems_rfs_rtems_error ("file_lseek: lseek", rc);                
40021218:	f2 22 00 00 	st  %i1, [ %o0 ]                               <== NOT EXECUTED
      iop->offset = old_offset;                                       
      new_offset = -1;                                                
    }                                                                 
  }                                                                   
                                                                      
  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));                  
4002121c:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        <== NOT EXECUTED
    int           rc = rtems_rfs_file_seek (file, pos, &pos);         
                                                                      
    if (rc)                                                           
    {                                                                 
      rtems_rfs_rtems_error ("file_lseek: lseek", rc);                
      iop->offset = old_offset;                                       
40021220:	f4 3e 20 08 	std  %i2, [ %i0 + 8 ]                          <== NOT EXECUTED
40021224:	7f ff ee 49 	call  4001cb48 <rtems_rfs_buffers_release>     <== NOT EXECUTED
40021228:	f6 02 20 80 	ld  [ %o0 + 0x80 ], %i3                        <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)                       
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_release (*mutex);            
4002122c:	7f ff ae fe 	call  4000ce24 <rtems_semaphore_release>       <== NOT EXECUTED
40021230:	d0 06 c0 00 	ld  [ %i3 ], %o0                               <== NOT EXECUTED
      new_offset = -1;                                                
40021234:	b8 17 23 ff 	or  %i4, 0x3ff, %i4                            <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL)                                         
40021238:	b6 92 20 00 	orcc  %o0, 0, %i3                              <== NOT EXECUTED
4002123c:	02 bf ff cf 	be  40021178 <rtems_rfs_rtems_file_lseek+0xb0> <== NOT EXECUTED
40021240:	ba 10 00 1c 	mov  %i4, %i5                                  <== NOT EXECUTED
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
40021244:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
40021248:	7f ff cb 17 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4002124c:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40021250:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40021254:	22 bf ff ca 	be,a   4002117c <rtems_rfs_rtems_file_lseek+0xb4><== NOT EXECUTED
40021258:	b0 10 00 1c 	mov  %i4, %i0                                  <== NOT EXECUTED
      printf ("rtems-rfs: mutex: release failed: %s\n",               
4002125c:	7f ff d9 6d 	call  40017810 <rtems_status_text>             <== NOT EXECUTED
40021260:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
  }                                                                   
                                                                      
  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));                  
                                                                      
  return new_offset;                                                  
}                                                                     
40021264:	b0 10 00 1c 	mov  %i4, %i0                                  <== NOT EXECUTED
40021268:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
4002126c:	b2 10 00 1d 	mov  %i5, %i1                                  <== NOT EXECUTED
40021270:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
40021274:	40 00 0b 42 	call  40023f7c <printf>                        <== NOT EXECUTED
40021278:	90 12 22 f0 	or  %o0, 0x2f0, %o0	! 40035ef0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
4002127c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40021280:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40021284 <rtems_rfs_rtems_file_open>: static int rtems_rfs_rtems_file_open (rtems_libio_t* iop, const char* pathname, int oflag, mode_t mode) {
40021284:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
40021288:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
 */                                                                   
static inline int                                                     
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)                         
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
4002128c:	92 10 20 00 	clr  %o1                                       
40021290:	fa 00 60 08 	ld  [ %g1 + 8 ], %i5                           
40021294:	94 10 20 00 	clr  %o2                                       
  .fstat_h     = rtems_rfs_rtems_fstat,                               
  .ftruncate_h = rtems_rfs_rtems_file_ftruncate,                      
  .fsync_h     = rtems_rfs_rtems_fdatasync,                           
  .fdatasync_h = rtems_rfs_rtems_fdatasync,                           
  .fcntl_h     = rtems_filesystem_default_fcntl                       
};                                                                    
40021298:	c2 07 60 80 	ld  [ %i5 + 0x80 ], %g1                        
4002129c:	7f ff ae 93 	call  4000cce8 <rtems_semaphore_obtain>        
400212a0:	d0 00 40 00 	ld  [ %g1 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
400212a4:	b8 92 20 00 	orcc  %o0, 0, %i4                              
400212a8:	12 80 00 23 	bne  40021334 <rtems_rfs_rtems_file_open+0xb0> <== NEVER TAKEN
400212ac:	90 10 20 00 	clr  %o0                                       
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
                                                                      
  ino = rtems_rfs_rtems_get_iop_ino (iop);                            
                                                                      
  rc = rtems_rfs_file_open (fs, ino, flags, &file);                   
400212b0:	d2 06 20 1c 	ld  [ %i0 + 0x1c ], %o1                        
400212b4:	90 10 00 1d 	mov  %i5, %o0                                  
400212b8:	94 10 20 00 	clr  %o2                                       
400212bc:	7f ff f3 c9 	call  4001e1e0 <rtems_rfs_file_open>           
400212c0:	96 07 bf fc 	add  %fp, -4, %o3                              
  if (rc > 0)                                                         
400212c4:	b8 92 20 00 	orcc  %o0, 0, %i4                              
400212c8:	04 80 00 2f 	ble  40021384 <rtems_rfs_rtems_file_open+0x100><== ALWAYS TAKEN
400212cc:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 * 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);            
400212d0:	f6 07 60 80 	ld  [ %i5 + 0x80 ], %i3                        <== NOT EXECUTED
  rtems_rfs_buffers_release (fs);                                     
400212d4:	7f ff ee 1d 	call  4001cb48 <rtems_rfs_buffers_release>     <== NOT EXECUTED
400212d8:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)                       
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_release (*mutex);            
400212dc:	7f ff ae d2 	call  4000ce24 <rtems_semaphore_release>       <== NOT EXECUTED
400212e0:	d0 06 c0 00 	ld  [ %i3 ], %o0                               <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL)                                         
400212e4:	ba 92 20 00 	orcc  %o0, 0, %i5                              <== NOT EXECUTED
400212e8:	12 80 00 07 	bne  40021304 <rtems_rfs_rtems_file_open+0x80> <== NOT EXECUTED
400212ec:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
    return rtems_rfs_rtems_error ("file-open: open", rc);             
400212f0:	40 00 05 92 	call  40022938 <__errno>                       <== NOT EXECUTED
400212f4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
400212f8:	f8 22 00 00 	st  %i4, [ %o0 ]                               <== NOT EXECUTED
400212fc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40021300:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
40021304:	7f ff ca e8 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
40021308:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
4002130c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40021310:	02 bf ff f8 	be  400212f0 <rtems_rfs_rtems_file_open+0x6c>  <== NOT EXECUTED
40021314:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: release failed: %s\n",               
40021318:	7f ff d9 3e 	call  40017810 <rtems_status_text>             <== NOT EXECUTED
4002131c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40021320:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40021324:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
40021328:	40 00 0b 15 	call  40023f7c <printf>                        <== NOT EXECUTED
4002132c:	90 12 22 f0 	or  %o0, 0x2f0, %o0	! 40035ef0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
40021330:	30 bf ff f0 	b,a   400212f0 <rtems_rfs_rtems_file_open+0x6c><== NOT EXECUTED
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
  if (sc != RTEMS_SUCCESSFUL)                                         
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
40021334:	7f ff ca dc 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
40021338:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
4002133c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40021340:	22 bf ff dd 	be,a   400212b4 <rtems_rfs_rtems_file_open+0x30><== NOT EXECUTED
40021344:	d2 06 20 1c 	ld  [ %i0 + 0x1c ], %o1                        <== NOT EXECUTED
      printf ("rtems-rfs: mutex: obtain failed: %s\n",                
40021348:	7f ff d9 32 	call  40017810 <rtems_status_text>             <== NOT EXECUTED
4002134c:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
40021350:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40021354:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
40021358:	40 00 0b 09 	call  40023f7c <printf>                        <== NOT EXECUTED
4002135c:	90 12 23 58 	or  %o0, 0x358, %o0	! 40035f58 <_CPU_Trap_slot_template+0xc70><== NOT EXECUTED
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
                                                                      
  ino = rtems_rfs_rtems_get_iop_ino (iop);                            
                                                                      
  rc = rtems_rfs_file_open (fs, ino, flags, &file);                   
40021360:	d2 06 20 1c 	ld  [ %i0 + 0x1c ], %o1                        <== NOT EXECUTED
40021364:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40021368:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
4002136c:	7f ff f3 9d 	call  4001e1e0 <rtems_rfs_file_open>           <== NOT EXECUTED
40021370:	96 07 bf fc 	add  %fp, -4, %o3                              <== NOT EXECUTED
  if (rc > 0)                                                         
40021374:	b8 92 20 00 	orcc  %o0, 0, %i4                              <== NOT EXECUTED
40021378:	34 bf ff d7 	bg,a   400212d4 <rtems_rfs_rtems_file_open+0x50><== NOT EXECUTED
4002137c:	f6 07 60 80 	ld  [ %i5 + 0x80 ], %i3                        <== NOT EXECUTED
  }                                                                   
                                                                      
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_OPEN))        
    printf("rtems-rfs: file-open: handle:%p\n", file);                
                                                                      
  rtems_rfs_rtems_set_iop_file_handle (iop, file);                    
40021380:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          <== 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);            
40021384:	f8 07 60 80 	ld  [ %i5 + 0x80 ], %i4                        
  rtems_rfs_buffers_release (fs);                                     
40021388:	90 10 00 1d 	mov  %i5, %o0                                  
4002138c:	7f ff ed ef 	call  4001cb48 <rtems_rfs_buffers_release>     
40021390:	c2 26 20 20 	st  %g1, [ %i0 + 0x20 ]                        
 */                                                                   
static inline int                                                     
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)                       
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_release (*mutex);            
40021394:	7f ff ae a4 	call  4000ce24 <rtems_semaphore_release>       
40021398:	d0 07 00 00 	ld  [ %i4 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
4002139c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400213a0:	12 80 00 04 	bne  400213b0 <rtems_rfs_rtems_file_open+0x12c><== NEVER TAKEN
400213a4:	90 10 20 00 	clr  %o0                                       
                                                                      
  rtems_rfs_rtems_unlock (fs);                                        
  return 0;                                                           
}                                                                     
400213a8:	81 c7 e0 08 	ret                                            
400213ac:	91 e8 20 00 	restore  %g0, 0, %o0                           
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
400213b0:	7f ff ca bd 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
400213b4:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
400213b8:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
400213bc:	02 bf ff fb 	be  400213a8 <rtems_rfs_rtems_file_open+0x124> <== NOT EXECUTED
400213c0:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: release failed: %s\n",               
400213c4:	7f ff d9 13 	call  40017810 <rtems_status_text>             <== NOT EXECUTED
400213c8:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
400213cc:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
400213d0:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
400213d4:	40 00 0a ea 	call  40023f7c <printf>                        <== NOT EXECUTED
400213d8:	90 12 22 f0 	or  %o0, 0x2f0, %o0	! 40035ef0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
400213dc:	30 bf ff f3 	b,a   400213a8 <rtems_rfs_rtems_file_open+0x124><== NOT EXECUTED
                                                                      

40020d0c <rtems_rfs_rtems_file_read>: */ static ssize_t rtems_rfs_rtems_file_read (rtems_libio_t* iop, void* buffer, size_t count) {
40020d0c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
40020d10:	e0 06 20 20 	ld  [ %i0 + 0x20 ], %l0                        
 */                                                                   
static inline int                                                     
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)                         
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
40020d14:	92 10 20 00 	clr  %o1                                       
  int                    rc;                                          
                                                                      
  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));                    
40020d18:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
40020d1c:	94 10 20 00 	clr  %o2                                       
 * Lock the RFS file system.                                          
 */                                                                   
static inline void                                                    
 rtems_rfs_rtems_lock (rtems_rfs_file_system* fs)                     
{                                                                     
  rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);            
40020d20:	c2 00 60 98 	ld  [ %g1 + 0x98 ], %g1                        
 */                                                                   
static ssize_t                                                        
rtems_rfs_rtems_file_read (rtems_libio_t* iop,                        
                           void*          buffer,                     
                           size_t         count)                      
{                                                                     
40020d24:	a2 10 00 18 	mov  %i0, %l1                                  
  .fstat_h     = rtems_rfs_rtems_fstat,                               
  .ftruncate_h = rtems_rfs_rtems_file_ftruncate,                      
  .fsync_h     = rtems_rfs_rtems_fdatasync,                           
  .fdatasync_h = rtems_rfs_rtems_fdatasync,                           
  .fcntl_h     = rtems_filesystem_default_fcntl                       
};                                                                    
40020d28:	c2 00 60 80 	ld  [ %g1 + 0x80 ], %g1                        
40020d2c:	7f ff af ef 	call  4000cce8 <rtems_semaphore_obtain>        
40020d30:	d0 00 40 00 	ld  [ %g1 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
40020d34:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40020d38:	12 80 00 5b 	bne  40020ea4 <rtems_rfs_rtems_file_read+0x198><== NEVER TAKEN
40020d3c:	90 10 20 00 	clr  %o0                                       
                                                                      
  rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));                    
                                                                      
  pos = iop->offset;                                                  
                                                                      
  if (pos < rtems_rfs_file_size (file))                               
40020d40:	d2 04 20 1c 	ld  [ %l0 + 0x1c ], %o1                        
  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;                                                  
40020d44:	f8 1c 60 08 	ldd  [ %l1 + 8 ], %i4                          
40020d48:	d0 02 60 98 	ld  [ %o1 + 0x98 ], %o0                        
40020d4c:	7f ff ea 1b 	call  4001b5b8 <rtems_rfs_block_get_size>      
40020d50:	92 02 60 84 	add  %o1, 0x84, %o1                            
                                                                      
  if (pos < rtems_rfs_file_size (file))                               
40020d54:	80 a2 00 1c 	cmp  %o0, %i4                                  
40020d58:	18 80 00 19 	bgu  40020dbc <rtems_rfs_rtems_file_read+0xb0> <== NEVER TAKEN
40020d5c:	80 a6 a0 00 	cmp  %i2, 0                                    
40020d60:	80 a2 00 1c 	cmp  %o0, %i4                                  
40020d64:	02 80 00 13 	be  40020db0 <rtems_rfs_rtems_file_read+0xa4>  <== ALWAYS TAKEN
40020d68:	80 a2 40 1d 	cmp  %o1, %i5                                  
  {                                                                   
    while (count)                                                     
40020d6c:	84 10 20 00 	clr  %g2                                       <== NOT EXECUTED
40020d70:	86 10 20 00 	clr  %g3                                       
                           size_t         count)                      
{                                                                     
  rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
  rtems_rfs_pos          pos;                                         
  uint8_t*               data = buffer;                               
  ssize_t                read = 0;                                    
40020d74:	b0 10 20 00 	clr  %i0                                       
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if (read >= 0)                                                      
    iop->offset = pos + read;                                         
40020d78:	b6 80 c0 1d 	addcc  %g3, %i5, %i3                           
40020d7c:	b4 40 80 1c 	addx  %g2, %i4, %i2                            
40020d80:	f4 3c 60 08 	std  %i2, [ %l1 + 8 ]                          
                                                                      
  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));                  
40020d84:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
40020d88:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
 */                                                                   
static inline void                                                    
 rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)                   
{                                                                     
  rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);            
  rtems_rfs_buffers_release (fs);                                     
40020d8c:	7f ff ef 6f 	call  4001cb48 <rtems_rfs_buffers_release>     
40020d90:	fa 02 20 80 	ld  [ %o0 + 0x80 ], %i5                        
 */                                                                   
static inline int                                                     
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)                       
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_release (*mutex);            
40020d94:	7f ff b0 24 	call  4000ce24 <rtems_semaphore_release>       
40020d98:	d0 07 40 00 	ld  [ %i5 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
40020d9c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40020da0:	12 80 00 2f 	bne  40020e5c <rtems_rfs_rtems_file_read+0x150><== NEVER TAKEN
40020da4:	90 10 20 00 	clr  %o0                                       
                                                                      
  return read;                                                        
}                                                                     
40020da8:	81 c7 e0 08 	ret                                            
40020dac:	81 e8 00 00 	restore                                        
                                                                      
  rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));                    
                                                                      
  pos = iop->offset;                                                  
                                                                      
  if (pos < rtems_rfs_file_size (file))                               
40020db0:	08 bf ff f0 	bleu  40020d70 <rtems_rfs_rtems_file_read+0x64>
40020db4:	84 10 20 00 	clr  %g2                                       
  {                                                                   
    while (count)                                                     
40020db8:	80 a6 a0 00 	cmp  %i2, 0                                    
40020dbc:	02 bf ff ec 	be  40020d6c <rtems_rfs_rtems_file_read+0x60>  <== NEVER TAKEN
40020dc0:	b0 10 20 00 	clr  %i0                                       
    {                                                                 
      size_t size;                                                    
                                                                      
      rc = rtems_rfs_file_io_start (file, &size, true);               
40020dc4:	10 80 00 16 	b  40020e1c <rtems_rfs_rtems_file_read+0x110>  
40020dc8:	92 07 bf fc 	add  %fp, -4, %o1                              
        break;                                                        
                                                                      
      if (size > count)                                               
        size = count;                                                 
                                                                      
      memcpy (data, rtems_rfs_file_data (file), size);                
40020dcc:	c4 04 20 0c 	ld  [ %l0 + 0xc ], %g2                         
40020dd0:	c2 04 20 14 	ld  [ %l0 + 0x14 ], %g1                        
40020dd4:	d2 00 a0 1c 	ld  [ %g2 + 0x1c ], %o1                        
40020dd8:	90 10 00 19 	mov  %i1, %o0                                  
40020ddc:	92 02 40 01 	add  %o1, %g1, %o1                             
40020de0:	40 00 0b 5a 	call  40023b48 <memcpy>                        
40020de4:	94 10 00 1b 	mov  %i3, %o2                                  
                                                                      
      data  += size;                                                  
      count -= size;                                                  
      read  += size;                                                  
                                                                      
      rc = rtems_rfs_file_io_end (file, size, true);                  
40020de8:	90 10 00 10 	mov  %l0, %o0                                  
40020dec:	92 10 00 1b 	mov  %i3, %o1                                  
40020df0:	94 10 20 01 	mov  1, %o2                                    
40020df4:	7f ff f7 1f 	call  4001ea70 <rtems_rfs_file_io_end>         
40020df8:	b2 06 40 1b 	add  %i1, %i3, %i1                             
                                                                      
      memcpy (data, rtems_rfs_file_data (file), size);                
                                                                      
      data  += size;                                                  
      count -= size;                                                  
      read  += size;                                                  
40020dfc:	b0 06 c0 18 	add  %i3, %i0, %i0                             
                                                                      
      rc = rtems_rfs_file_io_end (file, size, true);                  
      if (rc > 0)                                                     
40020e00:	80 a2 20 00 	cmp  %o0, 0                                    
40020e04:	14 80 00 39 	bg  40020ee8 <rtems_rfs_rtems_file_read+0x1dc> <== NEVER TAKEN
40020e08:	a4 10 00 08 	mov  %o0, %l2                                  
                                                                      
  pos = iop->offset;                                                  
                                                                      
  if (pos < rtems_rfs_file_size (file))                               
  {                                                                   
    while (count)                                                     
40020e0c:	80 a6 a0 00 	cmp  %i2, 0                                    
40020e10:	02 80 00 21 	be  40020e94 <rtems_rfs_rtems_file_read+0x188> 
40020e14:	80 a6 20 00 	cmp  %i0, 0                                    
    {                                                                 
      size_t size;                                                    
                                                                      
      rc = rtems_rfs_file_io_start (file, &size, true);               
40020e18:	92 07 bf fc 	add  %fp, -4, %o1                              
40020e1c:	94 10 20 01 	mov  1, %o2                                    
40020e20:	7f ff f6 83 	call  4001e82c <rtems_rfs_file_io_start>       
40020e24:	90 10 00 10 	mov  %l0, %o0                                  
      if (rc > 0)                                                     
40020e28:	b6 92 20 00 	orcc  %o0, 0, %i3                              
40020e2c:	14 80 00 2b 	bg  40020ed8 <rtems_rfs_rtems_file_read+0x1cc> <== NEVER TAKEN
40020e30:	01 00 00 00 	nop                                            
      {                                                               
        read = rtems_rfs_rtems_error ("file-read: read: io-start", rc);
        break;                                                        
      }                                                               
                                                                      
      if (size == 0)                                                  
40020e34:	f6 07 bf fc 	ld  [ %fp + -4 ], %i3                          
40020e38:	80 a6 e0 00 	cmp  %i3, 0                                    
40020e3c:	02 80 00 15 	be  40020e90 <rtems_rfs_rtems_file_read+0x184> 
40020e40:	80 a6 c0 1a 	cmp  %i3, %i2                                  
        break;                                                        
                                                                      
      if (size > count)                                               
40020e44:	28 bf ff e2 	bleu,a   40020dcc <rtems_rfs_rtems_file_read+0xc0>
40020e48:	b4 26 80 1b 	sub  %i2, %i3, %i2                             
        size = count;                                                 
40020e4c:	b6 10 00 1a 	mov  %i2, %i3                                  
40020e50:	f4 27 bf fc 	st  %i2, [ %fp + -4 ]                          
40020e54:	10 bf ff de 	b  40020dcc <rtems_rfs_rtems_file_read+0xc0>   
40020e58:	b4 10 20 00 	clr  %i2                                       
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
40020e5c:	7f ff cc 12 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
40020e60:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40020e64:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40020e68:	02 80 00 08 	be  40020e88 <rtems_rfs_rtems_file_read+0x17c> <== NOT EXECUTED
40020e6c:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: release failed: %s\n",               
40020e70:	7f ff da 68 	call  40017810 <rtems_status_text>             <== NOT EXECUTED
40020e74:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40020e78:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40020e7c:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
40020e80:	40 00 0c 3f 	call  40023f7c <printf>                        <== NOT EXECUTED
40020e84:	90 12 22 f0 	or  %o0, 0x2f0, %o0	! 40035ef0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
    iop->offset = pos + read;                                         
                                                                      
  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));                  
                                                                      
  return read;                                                        
}                                                                     
40020e88:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40020e8c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
        break;                                                        
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if (read >= 0)                                                      
40020e90:	80 a6 20 00 	cmp  %i0, 0                                    
40020e94:	06 bf ff bc 	bl  40020d84 <rtems_rfs_rtems_file_read+0x78>  <== NEVER TAKEN
40020e98:	86 10 00 18 	mov  %i0, %g3                                  
40020e9c:	10 bf ff b7 	b  40020d78 <rtems_rfs_rtems_file_read+0x6c>   
40020ea0:	85 3e 20 1f 	sra  %i0, 0x1f, %g2                            
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
  if (sc != RTEMS_SUCCESSFUL)                                         
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
40020ea4:	7f ff cc 00 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
40020ea8:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40020eac:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40020eb0:	22 bf ff a5 	be,a   40020d44 <rtems_rfs_rtems_file_read+0x38><== NOT EXECUTED
40020eb4:	d2 04 20 1c 	ld  [ %l0 + 0x1c ], %o1                        <== NOT EXECUTED
      printf ("rtems-rfs: mutex: obtain failed: %s\n",                
40020eb8:	7f ff da 56 	call  40017810 <rtems_status_text>             <== NOT EXECUTED
40020ebc:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40020ec0:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40020ec4:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
40020ec8:	40 00 0c 2d 	call  40023f7c <printf>                        <== NOT EXECUTED
40020ecc:	90 12 23 58 	or  %o0, 0x358, %o0	! 40035f58 <_CPU_Trap_slot_template+0xc70><== NOT EXECUTED
                                                                      
  rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));                    
                                                                      
  pos = iop->offset;                                                  
                                                                      
  if (pos < rtems_rfs_file_size (file))                               
40020ed0:	10 bf ff 9d 	b  40020d44 <rtems_rfs_rtems_file_read+0x38>   <== NOT EXECUTED
40020ed4:	d2 04 20 1c 	ld  [ %l0 + 0x1c ], %o1                        <== NOT EXECUTED
      size_t size;                                                    
                                                                      
      rc = rtems_rfs_file_io_start (file, &size, true);               
      if (rc > 0)                                                     
      {                                                               
        read = rtems_rfs_rtems_error ("file-read: read: io-start", rc);
40020ed8:	40 00 06 98 	call  40022938 <__errno>                       <== NOT EXECUTED
40020edc:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40020ee0:	10 bf ff a9 	b  40020d84 <rtems_rfs_rtems_file_read+0x78>   <== NOT EXECUTED
40020ee4:	f6 22 00 00 	st  %i3, [ %o0 ]                               <== 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); 
40020ee8:	40 00 06 94 	call  40022938 <__errno>                       <== NOT EXECUTED
40020eec:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40020ef0:	10 bf ff a5 	b  40020d84 <rtems_rfs_rtems_file_read+0x78>   <== NOT EXECUTED
40020ef4:	e4 22 00 00 	st  %l2, [ %o0 ]                               <== NOT EXECUTED
                                                                      

400213e0 <rtems_rfs_rtems_file_write>: */ static ssize_t rtems_rfs_rtems_file_write (rtems_libio_t* iop, const void* buffer, size_t count) {
400213e0:	9d e3 bf 90 	save  %sp, -112, %sp                           
  rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
400213e4:	e0 06 20 20 	ld  [ %i0 + 0x20 ], %l0                        
 */                                                                   
static inline int                                                     
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)                         
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
400213e8:	92 10 20 00 	clr  %o1                                       
  int                    rc;                                          
                                                                      
  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));                    
400213ec:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
400213f0:	94 10 20 00 	clr  %o2                                       
 * Lock the RFS file system.                                          
 */                                                                   
static inline void                                                    
 rtems_rfs_rtems_lock (rtems_rfs_file_system* fs)                     
{                                                                     
  rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);            
400213f4:	c2 00 60 98 	ld  [ %g1 + 0x98 ], %g1                        
  .fstat_h     = rtems_rfs_rtems_fstat,                               
  .ftruncate_h = rtems_rfs_rtems_file_ftruncate,                      
  .fsync_h     = rtems_rfs_rtems_fdatasync,                           
  .fdatasync_h = rtems_rfs_rtems_fdatasync,                           
  .fcntl_h     = rtems_filesystem_default_fcntl                       
};                                                                    
400213f8:	c2 00 60 80 	ld  [ %g1 + 0x80 ], %g1                        
400213fc:	7f ff ae 3b 	call  4000cce8 <rtems_semaphore_obtain>        
40021400:	d0 00 40 00 	ld  [ %g1 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
40021404:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40021408:	12 80 00 70 	bne  400215c8 <rtems_rfs_rtems_file_write+0x1e8><== NEVER TAKEN
4002140c:	90 10 20 00 	clr  %o0                                       
    printf("rtems-rfs: file-write: handle:%p count:%zd\n", file, count);
                                                                      
  rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));                    
                                                                      
  pos = iop->offset;                                                  
  file_size = rtems_rfs_file_size (file);                             
40021410:	d2 04 20 1c 	ld  [ %l0 + 0x1c ], %o1                        
  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;                                                  
40021414:	c4 1e 20 08 	ldd  [ %i0 + 8 ], %g2                          
40021418:	d0 02 60 98 	ld  [ %o1 + 0x98 ], %o0                        
4002141c:	c4 3f bf f8 	std  %g2, [ %fp + -8 ]                         
40021420:	7f ff e8 66 	call  4001b5b8 <rtems_rfs_block_get_size>      
40021424:	92 02 60 84 	add  %o1, 0x84, %o1                            
40021428:	86 10 00 09 	mov  %o1, %g3                                  
  file_size = rtems_rfs_file_size (file);                             
  if (pos > file_size)                                                
4002142c:	d2 07 bf f8 	ld  [ %fp + -8 ], %o1                          
40021430:	84 10 00 08 	mov  %o0, %g2                                  
40021434:	80 a2 40 02 	cmp  %o1, %g2                                  
40021438:	18 80 00 7b 	bgu  40021624 <rtems_rfs_rtems_file_write+0x244><== NEVER TAKEN
4002143c:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          
40021440:	80 a2 40 02 	cmp  %o1, %g2                                  
40021444:	02 80 00 8b 	be  40021670 <rtems_rfs_rtems_file_write+0x290><== ALWAYS TAKEN
40021448:	80 a2 80 03 	cmp  %o2, %g3                                  
      return rtems_rfs_rtems_error ("file-write: write extend", rc);  
    }                                                                 
                                                                      
    rtems_rfs_file_set_bpos (file, pos);                              
  }                                                                   
  else if (pos < file_size && (iop->flags & LIBIO_FLAGS_APPEND) != 0) 
4002144c:	80 a0 80 09 	cmp  %g2, %o1                                  <== NOT EXECUTED
40021450:	08 80 00 3b 	bleu  4002153c <rtems_rfs_rtems_file_write+0x15c><== ALWAYS TAKEN
40021454:	01 00 00 00 	nop                                            
40021458:	c2 06 20 10 	ld  [ %i0 + 0x10 ], %g1                        <== NOT EXECUTED
4002145c:	80 88 62 00 	btst  0x200, %g1                               
40021460:	32 80 00 8d 	bne,a   40021694 <rtems_rfs_rtems_file_write+0x2b4>
40021464:	c4 3f bf f8 	std  %g2, [ %fp + -8 ]                         
      rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));              
      return rtems_rfs_rtems_error ("file-write: write append seek", rc);
    }                                                                 
  }                                                                   
                                                                      
  while (count)                                                       
40021468:	a2 10 20 00 	clr  %l1                                       
4002146c:	84 10 20 00 	clr  %g2                                       
40021470:	80 a6 a0 00 	cmp  %i2, 0                                    
40021474:	12 80 00 1b 	bne  400214e0 <rtems_rfs_rtems_file_write+0x100><== ALWAYS TAKEN
40021478:	86 10 20 00 	clr  %g3                                       
  }                                                                   
                                                                      
  if (write >= 0)                                                     
    iop->offset = pos + write;                                        
                                                                      
  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));                  
4002147c:	10 80 00 3b 	b  40021568 <rtems_rfs_rtems_file_write+0x188> <== NOT EXECUTED
40021480:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        <== NOT EXECUTED
    {                                                                 
      write = rtems_rfs_rtems_error ("file-write: write open", rc);   
      break;                                                          
    }                                                                 
                                                                      
    if (size > count)                                                 
40021484:	d4 07 bf f4 	ld  [ %fp + -12 ], %o2                         
40021488:	80 a2 80 1a 	cmp  %o2, %i2                                  
4002148c:	28 80 00 05 	bleu,a   400214a0 <rtems_rfs_rtems_file_write+0xc0>
40021490:	c4 04 20 0c 	ld  [ %l0 + 0xc ], %g2                         
      size = count;                                                   
40021494:	f4 27 bf f4 	st  %i2, [ %fp + -12 ]                         
40021498:	94 10 00 1a 	mov  %i2, %o2                                  
                                                                      
    memcpy (rtems_rfs_file_data (file), data, size);                  
4002149c:	c4 04 20 0c 	ld  [ %l0 + 0xc ], %g2                         
400214a0:	c2 04 20 14 	ld  [ %l0 + 0x14 ], %g1                        
400214a4:	d0 00 a0 1c 	ld  [ %g2 + 0x1c ], %o0                        
400214a8:	40 00 09 a8 	call  40023b48 <memcpy>                        
400214ac:	90 02 00 01 	add  %o0, %g1, %o0                             
                                                                      
    data  += size;                                                    
400214b0:	d2 07 bf f4 	ld  [ %fp + -12 ], %o1                         
    count -= size;                                                    
    write  += size;                                                   
                                                                      
    rc = rtems_rfs_file_io_end (file, size, false);                   
400214b4:	90 10 00 10 	mov  %l0, %o0                                  
      size = count;                                                   
                                                                      
    memcpy (rtems_rfs_file_data (file), data, size);                  
                                                                      
    data  += size;                                                    
    count -= size;                                                    
400214b8:	b4 26 80 09 	sub  %i2, %o1, %i2                             
    if (size > count)                                                 
      size = count;                                                   
                                                                      
    memcpy (rtems_rfs_file_data (file), data, size);                  
                                                                      
    data  += size;                                                    
400214bc:	b2 06 40 09 	add  %i1, %o1, %i1                             
    count -= size;                                                    
    write  += size;                                                   
400214c0:	a2 04 40 09 	add  %l1, %o1, %l1                             
                                                                      
    rc = rtems_rfs_file_io_end (file, size, false);                   
400214c4:	7f ff f5 6b 	call  4001ea70 <rtems_rfs_file_io_end>         
400214c8:	94 10 20 00 	clr  %o2                                       
    if (rc)                                                           
400214cc:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400214d0:	12 80 00 0d 	bne  40021504 <rtems_rfs_rtems_file_write+0x124><== NEVER TAKEN
400214d4:	80 a6 a0 00 	cmp  %i2, 0                                    
      rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));              
      return rtems_rfs_rtems_error ("file-write: write append seek", rc);
    }                                                                 
  }                                                                   
                                                                      
  while (count)                                                       
400214d8:	02 80 00 20 	be  40021558 <rtems_rfs_rtems_file_write+0x178>
400214dc:	86 10 00 11 	mov  %l1, %g3                                  
  {                                                                   
    size_t size = count;                                              
                                                                      
    rc = rtems_rfs_file_io_start (file, &size, false);                
400214e0:	92 07 bf f4 	add  %fp, -12, %o1                             
    }                                                                 
  }                                                                   
                                                                      
  while (count)                                                       
  {                                                                   
    size_t size = count;                                              
400214e4:	f4 27 bf f4 	st  %i2, [ %fp + -12 ]                         
                                                                      
    rc = rtems_rfs_file_io_start (file, &size, false);                
400214e8:	94 10 20 00 	clr  %o2                                       
400214ec:	7f ff f4 d0 	call  4001e82c <rtems_rfs_file_io_start>       
400214f0:	90 10 00 10 	mov  %l0, %o0                                  
    }                                                                 
                                                                      
    if (size > count)                                                 
      size = count;                                                   
                                                                      
    memcpy (rtems_rfs_file_data (file), data, size);                  
400214f4:	92 10 00 19 	mov  %i1, %o1                                  
  while (count)                                                       
  {                                                                   
    size_t size = count;                                              
                                                                      
    rc = rtems_rfs_file_io_start (file, &size, false);                
    if (rc)                                                           
400214f8:	80 a2 20 00 	cmp  %o0, 0                                    
400214fc:	02 bf ff e2 	be  40021484 <rtems_rfs_rtems_file_write+0xa4> 
40021500:	ba 10 00 08 	mov  %o0, %i5                                  
    write  += size;                                                   
                                                                      
    rc = rtems_rfs_file_io_end (file, size, false);                   
    if (rc)                                                           
    {                                                                 
      write = rtems_rfs_rtems_error ("file-write: write close", rc);  
40021504:	40 00 05 0d 	call  40022938 <__errno>                       
40021508:	a2 10 3f ff 	mov  -1, %l1                                   
4002150c:	fa 22 00 00 	st  %i5, [ %o0 ]                               
  }                                                                   
                                                                      
  if (write >= 0)                                                     
    iop->offset = pos + write;                                        
                                                                      
  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));                  
40021510:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
40021514:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
 */                                                                   
static inline void                                                    
 rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)                   
{                                                                     
  rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);            
  rtems_rfs_buffers_release (fs);                                     
40021518:	7f ff ed 8c 	call  4001cb48 <rtems_rfs_buffers_release>     
4002151c:	fa 02 20 80 	ld  [ %o0 + 0x80 ], %i5                        
 */                                                                   
static inline int                                                     
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)                       
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_release (*mutex);            
40021520:	7f ff ae 41 	call  4000ce24 <rtems_semaphore_release>       
40021524:	d0 07 40 00 	ld  [ %i5 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
40021528:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4002152c:	12 80 00 1b 	bne  40021598 <rtems_rfs_rtems_file_write+0x1b8><== NEVER TAKEN
40021530:	90 10 20 00 	clr  %o0                                       
                                                                      
  return write;                                                       
}                                                                     
40021534:	81 c7 e0 08 	ret                                            
40021538:	91 e8 00 11 	restore  %g0, %l1, %o0                         
      return rtems_rfs_rtems_error ("file-write: write extend", rc);  
    }                                                                 
                                                                      
    rtems_rfs_file_set_bpos (file, pos);                              
  }                                                                   
  else if (pos < file_size && (iop->flags & LIBIO_FLAGS_APPEND) != 0) 
4002153c:	12 bf ff cc 	bne  4002146c <rtems_rfs_rtems_file_write+0x8c><== NEVER TAKEN
40021540:	a2 10 20 00 	clr  %l1                                       
40021544:	80 a0 c0 0a 	cmp  %g3, %o2                                  
40021548:	28 bf ff ca 	bleu,a   40021470 <rtems_rfs_rtems_file_write+0x90>
4002154c:	84 10 20 00 	clr  %g2                                       
40021550:	10 bf ff c3 	b  4002145c <rtems_rfs_rtems_file_write+0x7c>  
40021554:	c2 06 20 10 	ld  [ %i0 + 0x10 ], %g1                        
      write = rtems_rfs_rtems_error ("file-write: write close", rc);  
      break;                                                          
    }                                                                 
  }                                                                   
                                                                      
  if (write >= 0)                                                     
40021558:	80 a4 60 00 	cmp  %l1, 0                                    
4002155c:	06 bf ff ed 	bl  40021510 <rtems_rfs_rtems_file_write+0x130><== NEVER TAKEN
40021560:	85 3c 60 1f 	sra  %l1, 0x1f, %g2                            
    iop->offset = pos + write;                                        
                                                                      
  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));                  
40021564:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
      break;                                                          
    }                                                                 
  }                                                                   
                                                                      
  if (write >= 0)                                                     
    iop->offset = pos + write;                                        
40021568:	f8 1f bf f8 	ldd  [ %fp + -8 ], %i4                         
                                                                      
  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));                  
4002156c:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
      break;                                                          
    }                                                                 
  }                                                                   
                                                                      
  if (write >= 0)                                                     
    iop->offset = pos + write;                                        
40021570:	b6 80 c0 1d 	addcc  %g3, %i5, %i3                           
 * 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);            
40021574:	fa 02 20 80 	ld  [ %o0 + 0x80 ], %i5                        
40021578:	b4 40 80 1c 	addx  %g2, %i4, %i2                            
  rtems_rfs_buffers_release (fs);                                     
4002157c:	7f ff ed 73 	call  4001cb48 <rtems_rfs_buffers_release>     
40021580:	f4 3e 20 08 	std  %i2, [ %i0 + 8 ]                          
 */                                                                   
static inline int                                                     
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)                       
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_release (*mutex);            
40021584:	7f ff ae 28 	call  4000ce24 <rtems_semaphore_release>       
40021588:	d0 07 40 00 	ld  [ %i5 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
4002158c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40021590:	02 bf ff e9 	be  40021534 <rtems_rfs_rtems_file_write+0x154><== ALWAYS TAKEN
40021594:	90 10 20 00 	clr  %o0                                       
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
40021598:	7f ff ca 43 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4002159c:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
400215a0:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
400215a4:	02 bf ff e4 	be  40021534 <rtems_rfs_rtems_file_write+0x154><== NOT EXECUTED
400215a8:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: release failed: %s\n",               
400215ac:	7f ff d8 99 	call  40017810 <rtems_status_text>             <== NOT EXECUTED
400215b0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
400215b4:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
400215b8:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
400215bc:	40 00 0a 70 	call  40023f7c <printf>                        <== NOT EXECUTED
400215c0:	90 12 22 f0 	or  %o0, 0x2f0, %o0	! 40035ef0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
400215c4:	30 bf ff dc 	b,a   40021534 <rtems_rfs_rtems_file_write+0x154><== NOT EXECUTED
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
  if (sc != RTEMS_SUCCESSFUL)                                         
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
400215c8:	7f ff ca 37 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
400215cc:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
400215d0:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
400215d4:	22 bf ff 90 	be,a   40021414 <rtems_rfs_rtems_file_write+0x34><== NOT EXECUTED
400215d8:	d2 04 20 1c 	ld  [ %l0 + 0x1c ], %o1                        <== NOT EXECUTED
      printf ("rtems-rfs: mutex: obtain failed: %s\n",                
400215dc:	7f ff d8 8d 	call  40017810 <rtems_status_text>             <== NOT EXECUTED
400215e0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
400215e4:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
400215e8:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
400215ec:	40 00 0a 64 	call  40023f7c <printf>                        <== NOT EXECUTED
400215f0:	90 12 23 58 	or  %o0, 0x358, %o0	! 40035f58 <_CPU_Trap_slot_template+0xc70><== NOT EXECUTED
    printf("rtems-rfs: file-write: handle:%p count:%zd\n", file, count);
                                                                      
  rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));                    
                                                                      
  pos = iop->offset;                                                  
  file_size = rtems_rfs_file_size (file);                             
400215f4:	d2 04 20 1c 	ld  [ %l0 + 0x1c ], %o1                        <== 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;                                                  
400215f8:	c4 1e 20 08 	ldd  [ %i0 + 8 ], %g2                          <== NOT EXECUTED
400215fc:	d0 02 60 98 	ld  [ %o1 + 0x98 ], %o0                        <== NOT EXECUTED
40021600:	c4 3f bf f8 	std  %g2, [ %fp + -8 ]                         <== NOT EXECUTED
40021604:	7f ff e7 ed 	call  4001b5b8 <rtems_rfs_block_get_size>      <== NOT EXECUTED
40021608:	92 02 60 84 	add  %o1, 0x84, %o1                            <== NOT EXECUTED
4002160c:	86 10 00 09 	mov  %o1, %g3                                  <== NOT EXECUTED
  file_size = rtems_rfs_file_size (file);                             
  if (pos > file_size)                                                
40021610:	d2 07 bf f8 	ld  [ %fp + -8 ], %o1                          <== NOT EXECUTED
40021614:	84 10 00 08 	mov  %o0, %g2                                  <== NOT EXECUTED
40021618:	80 a2 40 02 	cmp  %o1, %g2                                  <== NOT EXECUTED
4002161c:	08 bf ff 8a 	bleu  40021444 <rtems_rfs_rtems_file_write+0x64><== NOT EXECUTED
40021620:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          <== NOT EXECUTED
    /*                                                                
     * If the iop position is past the physical end of the file we need to set
     * the file size to the new length before writing.  The           
     * rtems_rfs_file_io_end() will grow the file subsequently.       
     */                                                               
    rc = rtems_rfs_file_set_size (file, pos);                         
40021624:	7f ff f6 10 	call  4001ee64 <rtems_rfs_file_set_size>       
40021628:	90 10 00 10 	mov  %l0, %o0                                  
    if (rc)                                                           
    {                                                                 
      rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));              
4002162c:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
    /*                                                                
     * If the iop position is past the physical end of the file we need to set
     * the file size to the new length before writing.  The           
     * rtems_rfs_file_io_end() will grow the file subsequently.       
     */                                                               
    rc = rtems_rfs_file_set_size (file, pos);                         
40021630:	ba 10 00 08 	mov  %o0, %i5                                  
    if (rc)                                                           
40021634:	80 a7 60 00 	cmp  %i5, 0                                    
40021638:	02 80 00 11 	be  4002167c <rtems_rfs_rtems_file_write+0x29c><== ALWAYS TAKEN
4002163c:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
40021640:	7f ff ed 42 	call  4001cb48 <rtems_rfs_buffers_release>     <== NOT EXECUTED
40021644:	f8 02 20 80 	ld  [ %o0 + 0x80 ], %i4                        <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)                       
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_release (*mutex);            
40021648:	7f ff ad f7 	call  4000ce24 <rtems_semaphore_release>       <== NOT EXECUTED
4002164c:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL)                                         
40021650:	b8 92 20 00 	orcc  %o0, 0, %i4                              <== NOT EXECUTED
40021654:	12 80 00 1b 	bne  400216c0 <rtems_rfs_rtems_file_write+0x2e0><== NOT EXECUTED
40021658:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
    pos = file_size;                                                  
    rc = rtems_rfs_file_seek (file, pos, &pos);                       
    if (rc)                                                           
    {                                                                 
      rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));              
      return rtems_rfs_rtems_error ("file-write: write append seek", rc);
4002165c:	40 00 04 b7 	call  40022938 <__errno>                       <== NOT EXECUTED
40021660:	a2 10 3f ff 	mov  -1, %l1                                   <== NOT EXECUTED
40021664:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
    iop->offset = pos + write;                                        
                                                                      
  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));                  
                                                                      
  return write;                                                       
}                                                                     
40021668:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4002166c:	91 e8 00 11 	restore  %g0, %l1, %o0                         <== NOT EXECUTED
                                                                      
  rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));                    
                                                                      
  pos = iop->offset;                                                  
  file_size = rtems_rfs_file_size (file);                             
  if (pos > file_size)                                                
40021670:	08 bf ff 78 	bleu  40021450 <rtems_rfs_rtems_file_write+0x70>
40021674:	80 a0 80 09 	cmp  %g2, %o1                                  
40021678:	30 bf ff eb 	b,a   40021624 <rtems_rfs_rtems_file_write+0x244>
    {                                                                 
      rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));              
      return rtems_rfs_rtems_error ("file-write: write extend", rc);  
    }                                                                 
                                                                      
    rtems_rfs_file_set_bpos (file, pos);                              
4002167c:	d2 07 bf f8 	ld  [ %fp + -8 ], %o1                          
40021680:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          
40021684:	7f ff e7 9e 	call  4001b4fc <rtems_rfs_block_get_bpos>      
40021688:	96 04 20 10 	add  %l0, 0x10, %o3                            
      rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));              
      return rtems_rfs_rtems_error ("file-write: write append seek", rc);
    }                                                                 
  }                                                                   
                                                                      
  while (count)                                                       
4002168c:	10 bf ff 78 	b  4002146c <rtems_rfs_rtems_file_write+0x8c>  
40021690:	a2 10 20 00 	clr  %l1                                       
    rtems_rfs_file_set_bpos (file, pos);                              
  }                                                                   
  else if (pos < file_size && (iop->flags & LIBIO_FLAGS_APPEND) != 0) 
  {                                                                   
    pos = file_size;                                                  
    rc = rtems_rfs_file_seek (file, pos, &pos);                       
40021694:	90 10 00 10 	mov  %l0, %o0                                  
40021698:	92 10 00 02 	mov  %g2, %o1                                  
4002169c:	94 10 00 03 	mov  %g3, %o2                                  
400216a0:	7f ff f5 ae 	call  4001ed58 <rtems_rfs_file_seek>           
400216a4:	96 07 bf f8 	add  %fp, -8, %o3                              
    if (rc)                                                           
400216a8:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400216ac:	02 bf ff 70 	be  4002146c <rtems_rfs_rtems_file_write+0x8c> <== ALWAYS TAKEN
400216b0:	a2 10 20 00 	clr  %l1                                       
    {                                                                 
      rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));              
400216b4:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        <== NOT EXECUTED
400216b8:	10 bf ff e2 	b  40021640 <rtems_rfs_rtems_file_write+0x260> <== NOT EXECUTED
400216bc:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        <== NOT EXECUTED
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
400216c0:	7f ff c9 f9 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
400216c4:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
400216c8:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
400216cc:	02 bf ff e4 	be  4002165c <rtems_rfs_rtems_file_write+0x27c><== NOT EXECUTED
400216d0:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: release failed: %s\n",               
400216d4:	7f ff d8 4f 	call  40017810 <rtems_status_text>             <== NOT EXECUTED
400216d8:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
400216dc:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
400216e0:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
400216e4:	40 00 0a 26 	call  40023f7c <printf>                        <== NOT EXECUTED
400216e8:	90 12 22 f0 	or  %o0, 0x2f0, %o0	! 40035ef0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
400216ec:	30 bf ff dc 	b,a   4002165c <rtems_rfs_rtems_file_write+0x27c><== NOT EXECUTED
                                                                      

40013544 <rtems_rfs_rtems_fstat>: } int rtems_rfs_rtems_fstat (const rtems_filesystem_location_info_t* pathloc, struct stat* buf) {
40013544:	9d e3 bf 78 	save  %sp, -136, %sp                           
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);  
40013548:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
  int                    rc;                                          
                                                                      
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_STAT))             
    printf ("rtems-rfs-rtems: stat: in: ino:%" PRId32 "\n", ino);     
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
4001354c:	d2 06 20 08 	ld  [ %i0 + 8 ], %o1                           
                                                                      
int                                                                   
rtems_rfs_rtems_fstat (const rtems_filesystem_location_info_t* pathloc,
                       struct stat*                            buf)   
{                                                                     
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);  
40013550:	fa 00 60 08 	ld  [ %g1 + 8 ], %i5                           
  int                    rc;                                          
                                                                      
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_STAT))             
    printf ("rtems-rfs-rtems: stat: in: ino:%" PRId32 "\n", ino);     
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
40013554:	94 07 bf d8 	add  %fp, -40, %o2                             
40013558:	90 10 00 1d 	mov  %i5, %o0                                  
4001355c:	7f ff fb ab 	call  40012408 <rtems_rfs_inode_open>          
40013560:	96 10 20 01 	mov  1, %o3                                    
  if (rc)                                                             
40013564:	b8 92 20 00 	orcc  %o0, 0, %i4                              
40013568:	12 80 00 6f 	bne  40013724 <rtems_rfs_rtems_fstat+0x1e0>    <== NEVER TAKEN
4001356c:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
    return rtems_rfs_rtems_error ("stat: opening inode", rc);         
  }                                                                   
                                                                      
  mode = rtems_rfs_inode_get_mode (&inode);                           
                                                                      
  if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))           
40013570:	09 3f ff ec 	sethi  %hi(0xffffb000), %g4                    
 * @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);                    
40013574:	c4 08 60 02 	ldub  [ %g1 + 2 ], %g2                         
40013578:	d0 08 60 03 	ldub  [ %g1 + 3 ], %o0                         
4001357c:	85 28 a0 08 	sll  %g2, 8, %g2                               
40013580:	07 00 00 08 	sethi  %hi(0x2000), %g3                        
40013584:	88 08 80 04 	and  %g2, %g4, %g4                             
40013588:	80 a1 00 03 	cmp  %g4, %g3                                  
4001358c:	02 80 00 4b 	be  400136b8 <rtems_rfs_rtems_fstat+0x174>     <== NEVER TAKEN
40013590:	84 10 80 08 	or  %g2, %o0, %g2                              
    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);                         
40013594:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
  buf->st_ino     = rtems_rfs_inode_ino (&inode);                     
  buf->st_mode    = rtems_rfs_rtems_mode (mode);                      
40013598:	91 28 a0 10 	sll  %g2, 0x10, %o0                            
    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);                         
4001359c:	87 38 60 1f 	sra  %g1, 0x1f, %g3                            
400135a0:	c2 26 60 04 	st  %g1, [ %i1 + 4 ]                           
  buf->st_ino     = rtems_rfs_inode_ino (&inode);                     
400135a4:	c2 07 bf e0 	ld  [ %fp + -32 ], %g1                         
    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);                         
400135a8:	c6 26 40 00 	st  %g3, [ %i1 ]                               
  buf->st_ino     = rtems_rfs_inode_ino (&inode);                     
400135ac:	c2 26 60 08 	st  %g1, [ %i1 + 8 ]                           
  buf->st_mode    = rtems_rfs_rtems_mode (mode);                      
400135b0:	40 00 02 3b 	call  40013e9c <rtems_rfs_rtems_mode>          
400135b4:	91 32 20 10 	srl  %o0, 0x10, %o0                            
 */                                                                   
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);                  
400135b8:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
400135bc:	d0 26 60 0c 	st  %o0, [ %i1 + 0xc ]                         
400135c0:	c6 08 60 01 	ldub  [ %g1 + 1 ], %g3                         
400135c4:	c4 08 40 00 	ldub  [ %g1 ], %g2                             
  if (links == 0xffff)                                                
    links = 0;                                                        
400135c8:	09 3f ff c0 	sethi  %hi(0xffff0000), %g4                    
 */                                                                   
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);                  
400135cc:	85 28 a0 08 	sll  %g2, 8, %g2                               
400135d0:	84 10 80 03 	or  %g2, %g3, %g2                              
  if (links == 0xffff)                                                
400135d4:	87 28 a0 10 	sll  %g2, 0x10, %g3                            
400135d8:	87 30 e0 10 	srl  %g3, 0x10, %g3                            
    links = 0;                                                        
400135dc:	86 39 00 03 	xnor  %g4, %g3, %g3                            
400135e0:	80 a0 00 03 	cmp  %g0, %g3                                  
400135e4:	86 60 20 00 	subx  %g0, 0, %g3                              
400135e8:	84 08 80 03 	and  %g2, %g3, %g2                             
  buf->st_nlink   = rtems_rfs_inode_get_links (&inode);               
400135ec:	c4 36 60 10 	sth  %g2, [ %i1 + 0x10 ]                       
 * @return uint16_t The user id (uid).                                
 */                                                                   
static inline uint16_t                                                
rtems_rfs_inode_get_uid (rtems_rfs_inode_handle* handle)              
{                                                                     
  return rtems_rfs_read_u32 (&handle->node->owner) & 0xffff;          
400135f0:	c4 08 60 06 	ldub  [ %g1 + 6 ], %g2                         
400135f4:	c6 08 60 07 	ldub  [ %g1 + 7 ], %g3                         
400135f8:	85 28 a0 08 	sll  %g2, 8, %g2                               
400135fc:	84 10 80 03 	or  %g2, %g3, %g2                              
  buf->st_uid     = rtems_rfs_inode_get_uid (&inode);                 
40013600:	c4 36 60 12 	sth  %g2, [ %i1 + 0x12 ]                       
 * @return uint16_t The group id (gid).                               
 */                                                                   
static inline uint16_t                                                
rtems_rfs_inode_get_gid (rtems_rfs_inode_handle* handle)              
{                                                                     
  return (rtems_rfs_read_u32 (&handle->node->owner) >> 16) & 0xffff;  
40013604:	c4 08 60 04 	ldub  [ %g1 + 4 ], %g2                         
40013608:	c2 08 60 05 	ldub  [ %g1 + 5 ], %g1                         
                                                                      
  /*                                                                  
   * 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, rtems_rfs_inode_ino (&inode));
4001360c:	d2 07 bf e0 	ld  [ %fp + -32 ], %o1                         
40013610:	85 28 a0 18 	sll  %g2, 0x18, %g2                            
40013614:	83 28 60 10 	sll  %g1, 0x10, %g1                            
40013618:	82 10 80 01 	or  %g2, %g1, %g1                              
4001361c:	83 30 60 10 	srl  %g1, 0x10, %g1                            
40013620:	90 10 00 1d 	mov  %i5, %o0                                  
40013624:	40 00 2e ec 	call  4001f1d4 <rtems_rfs_file_get_shared>     
40013628:	c2 36 60 14 	sth  %g1, [ %i1 + 0x14 ]                       
                                                                      
  if (shared)                                                         
4001362c:	92 92 20 00 	orcc  %o0, 0, %o1                              
40013630:	02 80 00 42 	be  40013738 <rtems_rfs_rtems_fstat+0x1f4>     
40013634:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
  {                                                                   
    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); 
40013638:	c2 02 60 84 	ld  [ %o1 + 0x84 ], %g1                        
   */                                                                 
  shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode));
                                                                      
  if (shared)                                                         
  {                                                                   
    buf->st_atime   = rtems_rfs_file_shared_get_atime (shared);       
4001363c:	f8 02 60 8c 	ld  [ %o1 + 0x8c ], %i4                        
    buf->st_mtime   = rtems_rfs_file_shared_get_mtime (shared);       
40013640:	c8 02 60 90 	ld  [ %o1 + 0x90 ], %g4                        
    buf->st_ctime   = rtems_rfs_file_shared_get_ctime (shared);       
40013644:	c6 02 60 94 	ld  [ %o1 + 0x94 ], %g3                        
    buf->st_blocks  = rtems_rfs_file_shared_get_block_count (shared); 
                                                                      
    if (S_ISLNK (buf->st_mode))                                       
40013648:	c4 06 60 0c 	ld  [ %i1 + 0xc ], %g2                         
  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); 
4001364c:	c2 26 60 44 	st  %g1, [ %i1 + 0x44 ]                        
   */                                                                 
  shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode));
                                                                      
  if (shared)                                                         
  {                                                                   
    buf->st_atime   = rtems_rfs_file_shared_get_atime (shared);       
40013650:	f8 26 60 28 	st  %i4, [ %i1 + 0x28 ]                        
    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); 
                                                                      
    if (S_ISLNK (buf->st_mode))                                       
40013654:	03 00 00 3c 	sethi  %hi(0xf000), %g1                        
  shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode));
                                                                      
  if (shared)                                                         
  {                                                                   
    buf->st_atime   = rtems_rfs_file_shared_get_atime (shared);       
    buf->st_mtime   = rtems_rfs_file_shared_get_mtime (shared);       
40013658:	c8 26 60 30 	st  %g4, [ %i1 + 0x30 ]                        
    buf->st_ctime   = rtems_rfs_file_shared_get_ctime (shared);       
    buf->st_blocks  = rtems_rfs_file_shared_get_block_count (shared); 
                                                                      
    if (S_ISLNK (buf->st_mode))                                       
4001365c:	84 08 80 01 	and  %g2, %g1, %g2                             
40013660:	03 00 00 28 	sethi  %hi(0xa000), %g1                        
40013664:	80 a0 80 01 	cmp  %g2, %g1                                  
40013668:	02 80 00 2b 	be  40013714 <rtems_rfs_rtems_fstat+0x1d0>     <== NEVER TAKEN
4001366c:	c6 26 60 38 	st  %g3, [ %i1 + 0x38 ]                        
 */                                                                   
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);                
40013670:	90 10 00 1d 	mov  %i5, %o0                                  
40013674:	40 00 1f d1 	call  4001b5b8 <rtems_rfs_block_get_size>      
40013678:	92 02 60 84 	add  %o1, 0x84, %o1                            
      buf->st_size = rtems_rfs_file_shared_get_block_offset (shared); 
    else                                                              
      buf->st_size = rtems_rfs_file_shared_get_size (fs, shared);     
4001367c:	d0 3e 60 20 	std  %o0, [ %i1 + 0x20 ]                       
      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);                     
40013680:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
40013684:	90 10 00 1d 	mov  %i5, %o0                                  
      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);                     
40013688:	c2 26 60 40 	st  %g1, [ %i1 + 0x40 ]                        
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
4001368c:	92 07 bf d8 	add  %fp, -40, %o1                             
40013690:	7f ff fb d6 	call  400125e8 <rtems_rfs_inode_close>         
40013694:	b0 10 20 00 	clr  %i0                                       
  if (rc > 0)                                                         
40013698:	80 a2 20 00 	cmp  %o0, 0                                    
4001369c:	04 80 00 05 	ble  400136b0 <rtems_rfs_rtems_fstat+0x16c>    <== ALWAYS TAKEN
400136a0:	ba 10 00 08 	mov  %o0, %i5                                  
  {                                                                   
    return rtems_rfs_rtems_error ("stat: closing inode", rc);         
400136a4:	40 00 3c a5 	call  40022938 <__errno>                       <== NOT EXECUTED
400136a8:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
400136ac:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
400136b0:	81 c7 e0 08 	ret                                            
400136b4:	81 e8 00 00 	restore                                        
 * @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]);      
400136b8:	da 08 60 21 	ldub  [ %g1 + 0x21 ], %o5                      <== NOT EXECUTED
400136bc:	c8 08 60 20 	ldub  [ %g1 + 0x20 ], %g4                      <== NOT EXECUTED
400136c0:	de 08 60 23 	ldub  [ %g1 + 0x23 ], %o7                      <== NOT EXECUTED
400136c4:	f4 08 60 22 	ldub  [ %g1 + 0x22 ], %i2                      <== NOT EXECUTED
400136c8:	f6 08 60 1c 	ldub  [ %g1 + 0x1c ], %i3                      <== NOT EXECUTED
400136cc:	f0 08 60 1d 	ldub  [ %g1 + 0x1d ], %i0                      <== NOT EXECUTED
400136d0:	f8 08 60 1f 	ldub  [ %g1 + 0x1f ], %i4                      <== NOT EXECUTED
400136d4:	c6 08 60 1e 	ldub  [ %g1 + 0x1e ], %g3                      <== NOT EXECUTED
400136d8:	83 2b 60 10 	sll  %o5, 0x10, %g1                            <== NOT EXECUTED
400136dc:	89 29 20 18 	sll  %g4, 0x18, %g4                            <== NOT EXECUTED
400136e0:	b5 2e a0 08 	sll  %i2, 8, %i2                               <== NOT EXECUTED
400136e4:	88 11 00 01 	or  %g4, %g1, %g4                              <== NOT EXECUTED
400136e8:	b7 2e e0 18 	sll  %i3, 0x18, %i3                            <== NOT EXECUTED
400136ec:	88 11 00 0f 	or  %g4, %o7, %g4                              <== NOT EXECUTED
400136f0:	83 2e 20 10 	sll  %i0, 0x10, %g1                            <== NOT EXECUTED
400136f4:	88 11 00 1a 	or  %g4, %i2, %g4                              <== NOT EXECUTED
400136f8:	82 16 c0 01 	or  %i3, %g1, %g1                              <== NOT EXECUTED
400136fc:	87 28 e0 08 	sll  %g3, 8, %g3                               <== NOT EXECUTED
40013700:	82 10 40 1c 	or  %g1, %i4, %g1                              <== NOT EXECUTED
                                                                      
  mode = rtems_rfs_inode_get_mode (&inode);                           
                                                                      
  if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))           
  {                                                                   
    buf->st_rdev =                                                    
40013704:	c8 26 60 1c 	st  %g4, [ %i1 + 0x1c ]                        <== NOT EXECUTED
40013708:	82 10 40 03 	or  %g1, %g3, %g1                              <== NOT EXECUTED
4001370c:	10 bf ff a2 	b  40013594 <rtems_rfs_rtems_fstat+0x50>       <== NOT EXECUTED
40013710:	c2 26 60 18 	st  %g1, [ %i1 + 0x18 ]                        <== NOT EXECUTED
    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); 
                                                                      
    if (S_ISLNK (buf->st_mode))                                       
      buf->st_size = rtems_rfs_file_shared_get_block_offset (shared); 
40013714:	c2 12 60 8a 	lduh  [ %o1 + 0x8a ], %g1                      <== NOT EXECUTED
40013718:	c0 26 60 20 	clr  [ %i1 + 0x20 ]                            <== NOT EXECUTED
4001371c:	10 bf ff d9 	b  40013680 <rtems_rfs_rtems_fstat+0x13c>      <== NOT EXECUTED
40013720:	c2 26 60 24 	st  %g1, [ %i1 + 0x24 ]                        <== NOT EXECUTED
    printf ("rtems-rfs-rtems: stat: in: ino:%" PRId32 "\n", ino);     
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
  if (rc)                                                             
  {                                                                   
    return rtems_rfs_rtems_error ("stat: opening inode", rc);         
40013724:	40 00 3c 85 	call  40022938 <__errno>                       <== NOT EXECUTED
40013728:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4001372c:	f8 22 00 00 	st  %i4, [ %o0 ]                               <== NOT EXECUTED
40013730:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40013734:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    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);       
                                                                      
    if (S_ISLNK (buf->st_mode))                                       
40013738:	c6 06 60 0c 	ld  [ %i1 + 0xc ], %g3                         
 * @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);                   
4001373c:	f8 08 60 13 	ldub  [ %g1 + 0x13 ], %i4                      
40013740:	c4 08 60 10 	ldub  [ %g1 + 0x10 ], %g2                      
40013744:	f6 08 60 11 	ldub  [ %g1 + 0x11 ], %i3                      
40013748:	c8 08 60 12 	ldub  [ %g1 + 0x12 ], %g4                      
4001374c:	b7 2e e0 10 	sll  %i3, 0x10, %i3                            
40013750:	89 29 20 08 	sll  %g4, 8, %g4                               
40013754:	85 28 a0 18 	sll  %g2, 0x18, %g2                            
40013758:	84 10 80 1b 	or  %g2, %i3, %g2                              
4001375c:	84 10 80 1c 	or  %g2, %i4, %g2                              
40013760:	84 10 80 04 	or  %g2, %g4, %g2                              
    else                                                              
      buf->st_size = rtems_rfs_file_shared_get_size (fs, shared);     
  }                                                                   
  else                                                                
  {                                                                   
    buf->st_atime   = rtems_rfs_inode_get_atime (&inode);             
40013764:	c4 26 60 28 	st  %g2, [ %i1 + 0x28 ]                        
 * @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);                   
40013768:	f8 08 60 17 	ldub  [ %g1 + 0x17 ], %i4                      
4001376c:	c4 08 60 14 	ldub  [ %g1 + 0x14 ], %g2                      
40013770:	f6 08 60 15 	ldub  [ %g1 + 0x15 ], %i3                      
40013774:	c8 08 60 16 	ldub  [ %g1 + 0x16 ], %g4                      
40013778:	b7 2e e0 10 	sll  %i3, 0x10, %i3                            
4001377c:	89 29 20 08 	sll  %g4, 8, %g4                               
40013780:	85 28 a0 18 	sll  %g2, 0x18, %g2                            
40013784:	84 10 80 1b 	or  %g2, %i3, %g2                              
40013788:	84 10 80 1c 	or  %g2, %i4, %g2                              
4001378c:	84 10 80 04 	or  %g2, %g4, %g2                              
    buf->st_mtime   = rtems_rfs_inode_get_mtime (&inode);             
40013790:	c4 26 60 30 	st  %g2, [ %i1 + 0x30 ]                        
 * @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);                   
40013794:	f8 08 60 1b 	ldub  [ %g1 + 0x1b ], %i4                      
40013798:	c4 08 60 18 	ldub  [ %g1 + 0x18 ], %g2                      
4001379c:	f6 08 60 19 	ldub  [ %g1 + 0x19 ], %i3                      
400137a0:	c8 08 60 1a 	ldub  [ %g1 + 0x1a ], %g4                      
400137a4:	b7 2e e0 10 	sll  %i3, 0x10, %i3                            
400137a8:	89 29 20 08 	sll  %g4, 8, %g4                               
400137ac:	85 28 a0 18 	sll  %g2, 0x18, %g2                            
400137b0:	84 10 80 1b 	or  %g2, %i3, %g2                              
400137b4:	84 10 80 1c 	or  %g2, %i4, %g2                              
400137b8:	84 10 80 04 	or  %g2, %g4, %g2                              
    buf->st_ctime   = rtems_rfs_inode_get_ctime (&inode);             
400137bc:	c4 26 60 38 	st  %g2, [ %i1 + 0x38 ]                        
 * @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);             
400137c0:	c4 08 60 0c 	ldub  [ %g1 + 0xc ], %g2                       
400137c4:	f6 08 60 0d 	ldub  [ %g1 + 0xd ], %i3                       
400137c8:	f8 08 60 0f 	ldub  [ %g1 + 0xf ], %i4                       
400137cc:	c8 08 60 0e 	ldub  [ %g1 + 0xe ], %g4                       
400137d0:	85 28 a0 18 	sll  %g2, 0x18, %g2                            
400137d4:	b7 2e e0 10 	sll  %i3, 0x10, %i3                            
400137d8:	89 29 20 08 	sll  %g4, 8, %g4                               
400137dc:	84 10 80 1b 	or  %g2, %i3, %g2                              
400137e0:	84 10 80 1c 	or  %g2, %i4, %g2                              
400137e4:	84 10 80 04 	or  %g2, %g4, %g2                              
    buf->st_blocks  = rtems_rfs_inode_get_block_count (&inode);       
400137e8:	c4 26 60 44 	st  %g2, [ %i1 + 0x44 ]                        
                                                                      
    if (S_ISLNK (buf->st_mode))                                       
400137ec:	05 00 00 3c 	sethi  %hi(0xf000), %g2                        
400137f0:	86 08 c0 02 	and  %g3, %g2, %g3                             
400137f4:	05 00 00 28 	sethi  %hi(0xa000), %g2                        
400137f8:	80 a0 c0 02 	cmp  %g3, %g2                                  
400137fc:	12 80 00 09 	bne  40013820 <rtems_rfs_rtems_fstat+0x2dc>    
40013800:	90 10 00 1d 	mov  %i5, %o0                                  
      buf->st_size = rtems_rfs_inode_get_block_offset (&inode);       
40013804:	c4 08 60 0b 	ldub  [ %g1 + 0xb ], %g2                       
 * @return uint32_t The block offset.                                 
 */                                                                   
static inline uint16_t                                                
rtems_rfs_inode_get_block_offset (rtems_rfs_inode_handle* handle)     
{                                                                     
  return rtems_rfs_read_u16 (&handle->node->block_offset);            
40013808:	c6 08 60 0a 	ldub  [ %g1 + 0xa ], %g3                       
4001380c:	c0 26 60 20 	clr  [ %i1 + 0x20 ]                            
40013810:	83 28 e0 08 	sll  %g3, 8, %g1                               
40013814:	82 10 80 01 	or  %g2, %g1, %g1                              
40013818:	10 bf ff 9a 	b  40013680 <rtems_rfs_rtems_fstat+0x13c>      
4001381c:	c2 26 60 24 	st  %g1, [ %i1 + 0x24 ]                        
    else                                                              
      buf->st_size = rtems_rfs_inode_get_size (fs, &inode);           
40013820:	7f ff fd 2c 	call  40012cd0 <rtems_rfs_inode_get_size>      
40013824:	92 07 bf d8 	add  %fp, -40, %o1                             
40013828:	10 bf ff 96 	b  40013680 <rtems_rfs_rtems_fstat+0x13c>      
4001382c:	d0 3e 60 20 	std  %o0, [ %i1 + 0x20 ]                       
                                                                      

40013a9c <rtems_rfs_rtems_initialise>: */ int rtems_rfs_rtems_initialise (rtems_filesystem_mount_table_entry_t* mt_entry, const void* data) {
40013a9c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  int                      rc;                                        
                                                                      
  /*                                                                  
   * Parse the options the user specifiies.                           
   */                                                                 
  while (options)                                                     
40013aa0:	a2 10 20 05 	mov  5, %l1                                    
40013aa4:	80 a6 60 00 	cmp  %i1, 0                                    
40013aa8:	02 80 00 1f 	be  40013b24 <rtems_rfs_rtems_initialise+0x88> <== ALWAYS TAKEN
40013aac:	ba 10 20 00 	clr  %i5                                       
  {                                                                   
    printf ("options=%s\n", options);                                 
40013ab0:	37 10 00 d7 	sethi  %hi(0x40035c00), %i3                    <== NOT EXECUTED
    if (strncmp (options, "hold-bitmaps",                             
40013ab4:	39 10 00 d7 	sethi  %hi(0x40035c00), %i4                    <== NOT EXECUTED
                 sizeof ("hold-bitmaps") - 1) == 0)                   
      flags |= RTEMS_RFS_FS_BITMAPS_HOLD;                             
    else if (strncmp (options, "no-local-cache",                      
40013ab8:	35 10 00 d7 	sethi  %hi(0x40035c00), %i2                    <== NOT EXECUTED
                      sizeof ("no-local-cache") - 1) == 0)            
      flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;                           
    else if (strncmp (options, "max-held-bufs",                       
40013abc:	21 10 00 d7 	sethi  %hi(0x40035c00), %l0                    <== NOT EXECUTED
  /*                                                                  
   * Parse the options the user specifiies.                           
   */                                                                 
  while (options)                                                     
  {                                                                   
    printf ("options=%s\n", options);                                 
40013ac0:	b6 16 e3 18 	or  %i3, 0x318, %i3                            <== NOT EXECUTED
    if (strncmp (options, "hold-bitmaps",                             
40013ac4:	b8 17 23 28 	or  %i4, 0x328, %i4                            <== NOT EXECUTED
                 sizeof ("hold-bitmaps") - 1) == 0)                   
      flags |= RTEMS_RFS_FS_BITMAPS_HOLD;                             
    else if (strncmp (options, "no-local-cache",                      
40013ac8:	b4 16 a3 38 	or  %i2, 0x338, %i2                            <== NOT EXECUTED
                      sizeof ("no-local-cache") - 1) == 0)            
      flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;                           
    else if (strncmp (options, "max-held-bufs",                       
40013acc:	a0 14 23 48 	or  %l0, 0x348, %l0                            <== NOT EXECUTED
  /*                                                                  
   * Parse the options the user specifiies.                           
   */                                                                 
  while (options)                                                     
  {                                                                   
    printf ("options=%s\n", options);                                 
40013ad0:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
40013ad4:	40 00 41 2a 	call  40023f7c <printf>                        <== NOT EXECUTED
40013ad8:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
    if (strncmp (options, "hold-bitmaps",                             
40013adc:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
40013ae0:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
40013ae4:	40 00 45 c9 	call  40025208 <strncmp>                       <== NOT EXECUTED
40013ae8:	94 10 20 0c 	mov  0xc, %o2                                  <== NOT EXECUTED
40013aec:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40013af0:	12 80 00 1e 	bne  40013b68 <rtems_rfs_rtems_initialise+0xcc><== NOT EXECUTED
40013af4:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
                 sizeof ("hold-bitmaps") - 1) == 0)                   
      flags |= RTEMS_RFS_FS_BITMAPS_HOLD;                             
40013af8:	ba 17 60 01 	or  %i5, 1, %i5                                <== NOT EXECUTED
      max_held_buffers = strtoul (options + sizeof ("max-held-bufs"), 0, 0);
    }                                                                 
    else                                                              
      return rtems_rfs_rtems_error ("initialise: invalid option", EINVAL);
                                                                      
    options = strchr (options, ',');                                  
40013afc:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
40013b00:	40 00 43 48 	call  40024820 <strchr>                        <== NOT EXECUTED
40013b04:	92 10 20 2c 	mov  0x2c, %o1                                 <== NOT EXECUTED
    if (options)                                                      
40013b08:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40013b0c:	02 80 00 06 	be  40013b24 <rtems_rfs_rtems_initialise+0x88> <== NOT EXECUTED
40013b10:	01 00 00 00 	nop                                            <== NOT EXECUTED
    {                                                                 
      ++options;                                                      
      if (*options == '\0')                                           
40013b14:	c2 4a 20 01 	ldsb  [ %o0 + 1 ], %g1                         <== NOT EXECUTED
40013b18:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40013b1c:	12 80 00 1b 	bne  40013b88 <rtems_rfs_rtems_initialise+0xec><== NOT EXECUTED
40013b20:	b2 82 20 01 	addcc  %o0, 1, %i1                             <== NOT EXECUTED
        options = NULL;                                               
    }                                                                 
  }                                                                   
                                                                      
  rtems = malloc (sizeof (rtems_rfs_rtems_private));                  
40013b24:	7f ff d2 a6 	call  400085bc <malloc>                        
40013b28:	90 10 20 04 	mov  4, %o0                                    
  if (!rtems)                                                         
40013b2c:	b8 92 20 00 	orcc  %o0, 0, %i4                              
40013b30:	02 80 00 75 	be  40013d04 <rtems_rfs_rtems_initialise+0x268><== NEVER TAKEN
40013b34:	01 00 00 00 	nop                                            
    return rtems_rfs_rtems_error ("initialise: local data", ENOMEM);  
                                                                      
  memset (rtems, 0, sizeof (rtems_rfs_rtems_private));                
                                                                      
  rc = rtems_rfs_mutex_create (&rtems->access);                       
40013b38:	40 00 32 a5 	call  400205cc <rtems_rfs_mutex_create>        
40013b3c:	c0 27 00 00 	clr  [ %i4 ]                                   
  if (rc > 0)                                                         
40013b40:	b6 92 20 00 	orcc  %o0, 0, %i3                              
40013b44:	24 80 00 1f 	ble,a   40013bc0 <rtems_rfs_rtems_initialise+0x124><== ALWAYS TAKEN
40013b48:	d0 07 00 00 	ld  [ %i4 ], %o0                               
  {                                                                   
    free (rtems);                                                     
40013b4c:	7f ff d0 ff 	call  40007f48 <free>                          <== NOT EXECUTED
40013b50:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
    return rtems_rfs_rtems_error ("initialise: cannot create mutex", rc);
40013b54:	40 00 3b 79 	call  40022938 <__errno>                       <== NOT EXECUTED
40013b58:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40013b5c:	f6 22 00 00 	st  %i3, [ %o0 ]                               <== NOT EXECUTED
40013b60:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40013b64:	81 e8 00 00 	restore                                        <== 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",                      
40013b68:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
40013b6c:	40 00 45 a7 	call  40025208 <strncmp>                       <== NOT EXECUTED
40013b70:	94 10 20 0e 	mov  0xe, %o2                                  <== NOT EXECUTED
40013b74:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40013b78:	12 80 00 07 	bne  40013b94 <rtems_rfs_rtems_initialise+0xf8><== NOT EXECUTED
40013b7c:	92 10 00 10 	mov  %l0, %o1                                  <== NOT EXECUTED
                      sizeof ("no-local-cache") - 1) == 0)            
      flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;                           
40013b80:	10 bf ff df 	b  40013afc <rtems_rfs_rtems_initialise+0x60>  <== NOT EXECUTED
40013b84:	ba 17 60 02 	or  %i5, 2, %i5                                <== NOT EXECUTED
  int                      rc;                                        
                                                                      
  /*                                                                  
   * Parse the options the user specifiies.                           
   */                                                                 
  while (options)                                                     
40013b88:	12 bf ff d3 	bne  40013ad4 <rtems_rfs_rtems_initialise+0x38><== NOT EXECUTED
40013b8c:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
40013b90:	30 bf ff e5 	b,a   40013b24 <rtems_rfs_rtems_initialise+0x88><== NOT EXECUTED
                 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;                           
    else if (strncmp (options, "max-held-bufs",                       
40013b94:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
40013b98:	40 00 45 9c 	call  40025208 <strncmp>                       <== NOT EXECUTED
40013b9c:	94 10 20 0d 	mov  0xd, %o2                                  <== NOT EXECUTED
40013ba0:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40013ba4:	12 80 00 2c 	bne  40013c54 <rtems_rfs_rtems_initialise+0x1b8><== NOT EXECUTED
40013ba8:	90 06 60 0e 	add  %i1, 0xe, %o0                             <== NOT EXECUTED
                      sizeof ("max-held-bufs") - 1) == 0)             
    {                                                                 
      max_held_buffers = strtoul (options + sizeof ("max-held-bufs"), 0, 0);
40013bac:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
40013bb0:	40 00 46 75 	call  40025584 <strtoul>                       <== NOT EXECUTED
40013bb4:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
40013bb8:	10 bf ff d1 	b  40013afc <rtems_rfs_rtems_initialise+0x60>  <== NOT EXECUTED
40013bbc:	a2 10 00 08 	mov  %o0, %l1                                  <== 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);
40013bc0:	92 10 20 00 	clr  %o1                                       
40013bc4:	7f ff e4 49 	call  4000cce8 <rtems_semaphore_obtain>        
40013bc8:	94 10 20 00 	clr  %o2                                       
  if (sc != RTEMS_SUCCESSFUL)                                         
40013bcc:	b6 92 20 00 	orcc  %o0, 0, %i3                              
40013bd0:	12 80 00 11 	bne  40013c14 <rtems_rfs_rtems_initialise+0x178><== NEVER TAKEN
40013bd4:	94 10 00 1d 	mov  %i5, %o2                                  
    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);
40013bd8:	d0 06 20 38 	ld  [ %i0 + 0x38 ], %o0                        
40013bdc:	92 10 00 1c 	mov  %i4, %o1                                  
40013be0:	96 10 00 11 	mov  %l1, %o3                                  
40013be4:	40 00 2d a1 	call  4001f268 <rtems_rfs_fs_open>             
40013be8:	98 07 bf fc 	add  %fp, -4, %o4                              
  if (rc)                                                             
40013bec:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40013bf0:	02 80 00 1f 	be  40013c6c <rtems_rfs_rtems_initialise+0x1d0><== ALWAYS TAKEN
40013bf4:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
  {                                                                   
    free (rtems);                                                     
40013bf8:	7f ff d0 d4 	call  40007f48 <free>                          <== NOT EXECUTED
40013bfc:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
    return rtems_rfs_rtems_error ("initialise: open", rc);            
40013c00:	40 00 3b 4e 	call  40022938 <__errno>                       <== NOT EXECUTED
40013c04:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40013c08:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
40013c0c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40013c10:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
40013c14:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
40013c18:	40 00 00 a3 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
40013c1c:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40013c20:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40013c24:	12 80 00 25 	bne  40013cb8 <rtems_rfs_rtems_initialise+0x21c><== NOT EXECUTED
40013c28:	01 00 00 00 	nop                                            <== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_mutex_lock (&rtems->access);                         
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_mutex_destroy (&rtems->access);                         
40013c2c:	40 00 32 83 	call  40020638 <rtems_rfs_mutex_destroy>       <== NOT EXECUTED
40013c30:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
    free (rtems);                                                     
40013c34:	7f ff d0 c5 	call  40007f48 <free>                          <== NOT EXECUTED
40013c38:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
    return rtems_rfs_rtems_error ("initialise: cannot lock access  mutex", rc);
40013c3c:	40 00 3b 3f 	call  40022938 <__errno>                       <== NOT EXECUTED
40013c40:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40013c44:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
40013c48:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
  mt_entry->mt_fs_root->location.handlers    = &rtems_rfs_rtems_dir_handlers;
                                                                      
  rtems_rfs_rtems_unlock (fs);                                        
                                                                      
  return 0;                                                           
}                                                                     
40013c4c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40013c50:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                      sizeof ("max-held-bufs") - 1) == 0)             
    {                                                                 
      max_held_buffers = strtoul (options + sizeof ("max-held-bufs"), 0, 0);
    }                                                                 
    else                                                              
      return rtems_rfs_rtems_error ("initialise: invalid option", EINVAL);
40013c54:	40 00 3b 39 	call  40022938 <__errno>                       <== NOT EXECUTED
40013c58:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40013c5c:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
40013c60:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
40013c64:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40013c68:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    return rtems_rfs_rtems_error ("initialise: open", rc);            
  }                                                                   
                                                                      
  mt_entry->fs_info                          = fs;                    
  mt_entry->ops                              = &rtems_rfs_ops;        
  mt_entry->mt_fs_root->location.node_access = (void*) RTEMS_RFS_ROOT_INO;
40013c6c:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
    free (rtems);                                                     
    return rtems_rfs_rtems_error ("initialise: open", rc);            
  }                                                                   
                                                                      
  mt_entry->fs_info                          = fs;                    
  mt_entry->ops                              = &rtems_rfs_ops;        
40013c70:	05 10 00 d7 	sethi  %hi(0x40035c00), %g2                    
40013c74:	84 10 a3 80 	or  %g2, 0x380, %g2	! 40035f80 <rtems_rfs_ops> 
 * 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);            
40013c78:	fa 02 20 80 	ld  [ %o0 + 0x80 ], %i5                        
  {                                                                   
    free (rtems);                                                     
    return rtems_rfs_rtems_error ("initialise: open", rc);            
  }                                                                   
                                                                      
  mt_entry->fs_info                          = fs;                    
40013c7c:	d0 26 20 08 	st  %o0, [ %i0 + 8 ]                           
  mt_entry->ops                              = &rtems_rfs_ops;        
40013c80:	c4 26 20 0c 	st  %g2, [ %i0 + 0xc ]                         
  mt_entry->mt_fs_root->location.node_access = (void*) RTEMS_RFS_ROOT_INO;
40013c84:	84 10 20 01 	mov  1, %g2                                    
40013c88:	c4 20 60 08 	st  %g2, [ %g1 + 8 ]                           
  mt_entry->mt_fs_root->location.handlers    = &rtems_rfs_rtems_dir_handlers;
40013c8c:	05 10 00 e0 	sethi  %hi(0x40038000), %g2                    
40013c90:	84 10 a2 c8 	or  %g2, 0x2c8, %g2	! 400382c8 <rtems_rfs_rtems_dir_handlers>
  rtems_rfs_buffers_release (fs);                                     
40013c94:	40 00 23 ad 	call  4001cb48 <rtems_rfs_buffers_release>     
40013c98:	c4 20 60 10 	st  %g2, [ %g1 + 0x10 ]                        
 */                                                                   
static inline int                                                     
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)                       
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_release (*mutex);            
40013c9c:	7f ff e4 62 	call  4000ce24 <rtems_semaphore_release>       
40013ca0:	d0 07 40 00 	ld  [ %i5 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
40013ca4:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40013ca8:	12 80 00 0b 	bne  40013cd4 <rtems_rfs_rtems_initialise+0x238><== NEVER TAKEN
40013cac:	90 10 20 00 	clr  %o0                                       
                                                                      
  rtems_rfs_rtems_unlock (fs);                                        
                                                                      
  return 0;                                                           
40013cb0:	81 c7 e0 08 	ret                                            
40013cb4:	91 e8 20 00 	restore  %g0, 0, %o0                           
  rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
  if (sc != RTEMS_SUCCESSFUL)                                         
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
      printf ("rtems-rfs: mutex: obtain failed: %s\n",                
40013cb8:	40 00 0e d6 	call  40017810 <rtems_status_text>             <== NOT EXECUTED
40013cbc:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
40013cc0:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40013cc4:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
40013cc8:	40 00 40 ad 	call  40023f7c <printf>                        <== NOT EXECUTED
40013ccc:	90 12 23 58 	or  %o0, 0x358, %o0	! 40035f58 <_CPU_Trap_slot_template+0xc70><== NOT EXECUTED
40013cd0:	30 bf ff d7 	b,a   40013c2c <rtems_rfs_rtems_initialise+0x190><== NOT EXECUTED
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_release (*mutex);            
  if (sc != RTEMS_SUCCESSFUL)                                         
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
40013cd4:	40 00 00 74 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
40013cd8:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40013cdc:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40013ce0:	02 bf ff f4 	be  40013cb0 <rtems_rfs_rtems_initialise+0x214><== NOT EXECUTED
40013ce4:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: release failed: %s\n",               
40013ce8:	40 00 0e ca 	call  40017810 <rtems_status_text>             <== NOT EXECUTED
40013cec:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40013cf0:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40013cf4:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
40013cf8:	40 00 40 a1 	call  40023f7c <printf>                        <== NOT EXECUTED
40013cfc:	90 12 22 f0 	or  %o0, 0x2f0, %o0	! 40035ef0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
40013d00:	30 bf ff ec 	b,a   40013cb0 <rtems_rfs_rtems_initialise+0x214><== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  rtems = malloc (sizeof (rtems_rfs_rtems_private));                  
  if (!rtems)                                                         
    return rtems_rfs_rtems_error ("initialise: local data", ENOMEM);  
40013d04:	40 00 3b 0d 	call  40022938 <__errno>                       <== NOT EXECUTED
40013d08:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40013d0c:	82 10 20 0c 	mov  0xc, %g1                                  <== NOT EXECUTED
40013d10:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
40013d14:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40013d18:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40012e48 <rtems_rfs_rtems_link>: static int rtems_rfs_rtems_link (const rtems_filesystem_location_info_t *parentloc, const rtems_filesystem_location_info_t *targetloc, const char *name, size_t namelen) {
40012e48:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (targetloc);
40012e4c:	c2 06 60 14 	ld  [ %i1 + 0x14 ], %g1                        
                                                                      
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_LINK))             
    printf ("rtems-rfs-rtems: link: in: parent:%" PRId32 " target:%" PRId32 "\n",
            parent, target);                                          
                                                                      
  rc = rtems_rfs_link (fs, name, namelen, parent, target, false);     
40012e50:	d6 06 20 08 	ld  [ %i0 + 8 ], %o3                           
40012e54:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           
40012e58:	d8 06 60 08 	ld  [ %i1 + 8 ], %o4                           
40012e5c:	92 10 00 1a 	mov  %i2, %o1                                  
40012e60:	94 10 00 1b 	mov  %i3, %o2                                  
40012e64:	9a 10 20 00 	clr  %o5                                       
40012e68:	40 00 33 4c 	call  4001fb98 <rtems_rfs_link>                
40012e6c:	b0 10 20 00 	clr  %i0                                       
  if (rc)                                                             
40012e70:	80 a2 20 00 	cmp  %o0, 0                                    
40012e74:	02 80 00 05 	be  40012e88 <rtems_rfs_rtems_link+0x40>       <== ALWAYS TAKEN
40012e78:	ba 10 00 08 	mov  %o0, %i5                                  
  {                                                                   
    return rtems_rfs_rtems_error ("link: linking", rc);               
40012e7c:	40 00 3e af 	call  40022938 <__errno>                       <== NOT EXECUTED
40012e80:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40012e84:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
	}                                                                    
                                                                      
                                                                      
	return 0;                                                            
}                                                                     
40012e88:	81 c7 e0 08 	ret                                            
40012e8c:	81 e8 00 00 	restore                                        
                                                                      

40013d1c <rtems_rfs_rtems_lock_by_mt_entry>: static void rtems_rfs_rtems_lock_by_mt_entry ( const rtems_filesystem_mount_table_entry_t *mt_entry ) {
40013d1c:	9d e3 bf a0 	save  %sp, -96, %sp                            
 * Lock the RFS file system.                                          
 */                                                                   
static inline void                                                    
 rtems_rfs_rtems_lock (rtems_rfs_file_system* fs)                     
{                                                                     
  rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);            
40013d20:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
 */                                                                   
static inline int                                                     
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)                         
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
40013d24:	92 10 20 00 	clr  %o1                                       
  /* FIXME: Return value? */                                          
  rtems_rfs_fs_close(fs);                                             
                                                                      
  rtems_rfs_mutex_destroy (&rtems->access);                           
  free (rtems);                                                       
}                                                                     
40013d28:	c2 00 60 80 	ld  [ %g1 + 0x80 ], %g1                        
40013d2c:	94 10 20 00 	clr  %o2                                       
40013d30:	7f ff e3 ee 	call  4000cce8 <rtems_semaphore_obtain>        
40013d34:	d0 00 40 00 	ld  [ %g1 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
40013d38:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40013d3c:	12 80 00 04 	bne  40013d4c <rtems_rfs_rtems_lock_by_mt_entry+0x30><== NEVER TAKEN
40013d40:	90 10 20 00 	clr  %o0                                       
40013d44:	81 c7 e0 08 	ret                                            
40013d48:	81 e8 00 00 	restore                                        
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
40013d4c:	40 00 00 56 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
40013d50:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40013d54:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40013d58:	02 bf ff fb 	be  40013d44 <rtems_rfs_rtems_lock_by_mt_entry+0x28><== NOT EXECUTED
40013d5c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
      printf ("rtems-rfs: mutex: obtain failed: %s\n",                
40013d60:	40 00 0e ac 	call  40017810 <rtems_status_text>             <== NOT EXECUTED
40013d64:	31 10 00 d7 	sethi  %hi(0x40035c00), %i0                    <== NOT EXECUTED
40013d68:	b0 16 23 58 	or  %i0, 0x358, %i0	! 40035f58 <_CPU_Trap_slot_template+0xc70><== NOT EXECUTED
40013d6c:	40 00 40 84 	call  40023f7c <printf>                        <== NOT EXECUTED
40013d70:	93 e8 00 08 	restore  %g0, %o0, %o1                         <== NOT EXECUTED
                                                                      

4001331c <rtems_rfs_rtems_mknod>: rtems_rfs_rtems_mknod (const rtems_filesystem_location_info_t *parentloc, const char *name, size_t namelen, mode_t mode, dev_t dev) {
4001331c:	9d e3 bf 60 	save  %sp, -160, %sp                           
  rtems_rfs_file_system*  fs = rtems_rfs_rtems_pathloc_dev (parentloc);
40013320:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
  rtems_rfs_ino           parent = rtems_rfs_rtems_get_pathloc_ino (parentloc);
40013324:	e0 06 20 08 	ld  [ %i0 + 8 ], %l0                           
  uid_t                   uid;                                        
  gid_t                   gid;                                        
  int                     rc;                                         
                                                                      
#if defined(RTEMS_POSIX_API)                                          
  uid = geteuid ();                                                   
40013328:	40 00 12 0f 	call  40017b64 <geteuid>                       
4001332c:	f0 00 60 08 	ld  [ %g1 + 8 ], %i0                           
  gid = getegid ();                                                   
40013330:	40 00 12 09 	call  40017b54 <getegid>                       
40013334:	a2 10 00 08 	mov  %o0, %l1                                  
40013338:	a4 10 00 08 	mov  %o0, %l2                                  
#else                                                                 
  uid = 0;                                                            
  gid = 0;                                                            
#endif                                                                
                                                                      
  rc = rtems_rfs_inode_create (fs, parent, name, namelen,             
4001333c:	40 00 02 d5 	call  40013e90 <rtems_rfs_rtems_imode>         
40013340:	90 10 00 1b 	mov  %i3, %o0                                  
40013344:	82 07 bf d4 	add  %fp, -44, %g1                             
40013348:	99 2a 20 10 	sll  %o0, 0x10, %o4                            
4001334c:	96 10 00 1a 	mov  %i2, %o3                                  
40013350:	a3 2c 60 10 	sll  %l1, 0x10, %l1                            
40013354:	a5 2c a0 10 	sll  %l2, 0x10, %l2                            
40013358:	a3 34 60 10 	srl  %l1, 0x10, %l1                            
4001335c:	a5 34 a0 10 	srl  %l2, 0x10, %l2                            
40013360:	e2 23 a0 5c 	st  %l1, [ %sp + 0x5c ]                        
40013364:	e4 23 a0 60 	st  %l2, [ %sp + 0x60 ]                        
40013368:	90 10 00 18 	mov  %i0, %o0                                  
4001336c:	c2 23 a0 64 	st  %g1, [ %sp + 0x64 ]                        
40013370:	92 10 00 10 	mov  %l0, %o1                                  
40013374:	94 10 00 19 	mov  %i1, %o2                                  
40013378:	99 33 20 10 	srl  %o4, 0x10, %o4                            
4001337c:	7f ff fd 75 	call  40012950 <rtems_rfs_inode_create>        
40013380:	9a 10 20 01 	mov  1, %o5                                    
                               rtems_rfs_rtems_imode (mode),          
                               1, uid, gid, &ino);                    
  if (rc > 0)                                                         
40013384:	b4 92 20 00 	orcc  %o0, 0, %i2                              
40013388:	04 80 00 07 	ble  400133a4 <rtems_rfs_rtems_mknod+0x88>     
4001338c:	d2 07 bf d4 	ld  [ %fp + -44 ], %o1                         
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
  if (rc > 0)                                                         
  {                                                                   
    return rtems_rfs_rtems_error ("mknod: inode open", rc);           
40013390:	40 00 3d 6a 	call  40022938 <__errno>                       
40013394:	b0 10 3f ff 	mov  -1, %i0                                   
40013398:	f4 22 00 00 	st  %i2, [ %o0 ]                               
4001339c:	81 c7 e0 08 	ret                                            
400133a0:	81 e8 00 00 	restore                                        
  if (rc > 0)                                                         
  {                                                                   
    return rtems_rfs_rtems_error ("mknod: inode create", rc);         
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
400133a4:	90 10 00 18 	mov  %i0, %o0                                  
400133a8:	94 07 bf d8 	add  %fp, -40, %o2                             
400133ac:	7f ff fc 17 	call  40012408 <rtems_rfs_inode_open>          
400133b0:	96 10 20 01 	mov  1, %o3                                    
  if (rc > 0)                                                         
400133b4:	b4 92 20 00 	orcc  %o0, 0, %i2                              
400133b8:	14 bf ff f6 	bg  40013390 <rtems_rfs_rtems_mknod+0x74>      <== NEVER TAKEN
400133bc:	03 00 00 3c 	sethi  %hi(0xf000), %g1                        
  {                                                                   
    return rtems_rfs_rtems_error ("mknod: inode open", rc);           
  }                                                                   
                                                                      
  if (S_ISDIR(mode) || S_ISREG(mode))                                 
400133c0:	05 00 00 20 	sethi  %hi(0x8000), %g2                        
400133c4:	82 0e c0 01 	and  %i3, %g1, %g1                             
400133c8:	80 a0 40 02 	cmp  %g1, %g2                                  
400133cc:	02 80 00 1a 	be  40013434 <rtems_rfs_rtems_mknod+0x118>     
400133d0:	05 00 00 10 	sethi  %hi(0x4000), %g2                        
400133d4:	80 a0 40 02 	cmp  %g1, %g2                                  
400133d8:	02 80 00 17 	be  40013434 <rtems_rfs_rtems_mknod+0x118>     <== ALWAYS TAKEN
400133dc:	03 00 00 2c 	sethi  %hi(0xb000), %g1                        
  {                                                                   
  }                                                                   
  else if (S_ISCHR (mode) || S_ISBLK (mode))                          
400133e0:	b6 0e c0 01 	and  %i3, %g1, %i3                             <== NOT EXECUTED
400133e4:	03 00 00 08 	sethi  %hi(0x2000), %g1                        <== NOT EXECUTED
400133e8:	80 a6 c0 01 	cmp  %i3, %g1                                  <== NOT EXECUTED
400133ec:	12 80 00 1e 	bne  40013464 <rtems_rfs_rtems_mknod+0x148>    <== NOT EXECUTED
400133f0:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         <== 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);       
400133f4:	b3 37 20 18 	srl  %i4, 0x18, %i1                            <== NOT EXECUTED
400133f8:	b5 37 20 10 	srl  %i4, 0x10, %i2                            <== NOT EXECUTED
400133fc:	b7 37 20 08 	srl  %i4, 8, %i3                               <== NOT EXECUTED
40013400:	89 37 60 18 	srl  %i5, 0x18, %g4                            <== NOT EXECUTED
40013404:	87 37 60 10 	srl  %i5, 0x10, %g3                            <== NOT EXECUTED
40013408:	85 37 60 08 	srl  %i5, 8, %g2                               <== NOT EXECUTED
4001340c:	f8 28 60 1f 	stb  %i4, [ %g1 + 0x1f ]                       <== NOT EXECUTED
40013410:	f2 28 60 1c 	stb  %i1, [ %g1 + 0x1c ]                       <== NOT EXECUTED
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
40013414:	b8 10 20 01 	mov  1, %i4                                    <== 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);       
40013418:	f4 28 60 1d 	stb  %i2, [ %g1 + 0x1d ]                       <== NOT EXECUTED
4001341c:	f6 28 60 1e 	stb  %i3, [ %g1 + 0x1e ]                       <== NOT EXECUTED
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
40013420:	f8 2f bf e8 	stb  %i4, [ %fp + -24 ]                        <== 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);       
40013424:	c8 28 60 20 	stb  %g4, [ %g1 + 0x20 ]                       <== NOT EXECUTED
40013428:	c6 28 60 21 	stb  %g3, [ %g1 + 0x21 ]                       <== NOT EXECUTED
4001342c:	c4 28 60 22 	stb  %g2, [ %g1 + 0x22 ]                       <== NOT EXECUTED
40013430:	fa 28 60 23 	stb  %i5, [ %g1 + 0x23 ]                       <== NOT EXECUTED
  {                                                                   
    rtems_rfs_inode_close (fs, &inode);                               
    return rtems_rfs_rtems_error ("mknod: bad mode", EINVAL);         
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
40013434:	90 10 00 18 	mov  %i0, %o0                                  
40013438:	92 07 bf d8 	add  %fp, -40, %o1                             
4001343c:	7f ff fc 6b 	call  400125e8 <rtems_rfs_inode_close>         
40013440:	b0 10 20 00 	clr  %i0                                       
  if (rc > 0)                                                         
40013444:	80 a2 20 00 	cmp  %o0, 0                                    
40013448:	04 bf ff d5 	ble  4001339c <rtems_rfs_rtems_mknod+0x80>     <== ALWAYS TAKEN
4001344c:	ba 10 00 08 	mov  %o0, %i5                                  
  {                                                                   
    return rtems_rfs_rtems_error ("mknod: closing inode", rc);        
40013450:	40 00 3d 3a 	call  40022938 <__errno>                       <== NOT EXECUTED
40013454:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40013458:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
4001345c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40013460:	81 e8 00 00 	restore                                        <== 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);                               
40013464:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
40013468:	7f ff fc 60 	call  400125e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
4001346c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
    return rtems_rfs_rtems_error ("mknod: bad mode", EINVAL);         
40013470:	40 00 3d 32 	call  40022938 <__errno>                       <== NOT EXECUTED
40013474:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40013478:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
4001347c:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
40013480:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40013484:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

400132b0 <rtems_rfs_rtems_node_type>: * @return rtems_filesystem_node_types_t */ static rtems_filesystem_node_types_t rtems_rfs_rtems_node_type (const rtems_filesystem_location_info_t* pathloc) {
400132b0:	9d e3 bf 78 	save  %sp, -136, %sp                           
  rtems_rfs_file_system*        fs = rtems_rfs_rtems_pathloc_dev (pathloc);
400132b4:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
  rtems_rfs_ino                 ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
  rtems_filesystem_node_types_t type;                                 
  rtems_rfs_inode_handle        inode;                                
  int                           rc;                                   
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
400132b8:	d2 06 20 08 	ld  [ %i0 + 8 ], %o1                           
 */                                                                   
                                                                      
static rtems_filesystem_node_types_t                                  
rtems_rfs_rtems_node_type (const rtems_filesystem_location_info_t* pathloc)
{                                                                     
  rtems_rfs_file_system*        fs = rtems_rfs_rtems_pathloc_dev (pathloc);
400132bc:	f8 00 60 08 	ld  [ %g1 + 8 ], %i4                           
  rtems_rfs_ino                 ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
  rtems_filesystem_node_types_t type;                                 
  rtems_rfs_inode_handle        inode;                                
  int                           rc;                                   
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
400132c0:	94 07 bf d8 	add  %fp, -40, %o2                             
400132c4:	90 10 00 1c 	mov  %i4, %o0                                  
400132c8:	7f ff fc 50 	call  40012408 <rtems_rfs_inode_open>          
400132cc:	96 10 20 01 	mov  1, %o3                                    
  if (rc > 0)                                                         
400132d0:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400132d4:	04 80 00 07 	ble  400132f0 <rtems_rfs_rtems_node_type+0x40> <== ALWAYS TAKEN
400132d8:	01 00 00 00 	nop                                            
  type = rtems_rfs_rtems_node_type_by_inode (&inode);                 
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
  if (rc > 0)                                                         
  {                                                                   
    return rtems_rfs_rtems_error ("node_type: closing inode", rc);    
400132dc:	40 00 3d 97 	call  40022938 <__errno>                       <== NOT EXECUTED
400132e0:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <LEON_REG+0x7fffffff>  <== NOT EXECUTED
400132e4:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  return type;                                                        
}                                                                     
400132e8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400132ec:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  if (rc > 0)                                                         
  {                                                                   
    return rtems_rfs_rtems_error ("node_type: opening inode", rc);    
  }                                                                   
                                                                      
  type = rtems_rfs_rtems_node_type_by_inode (&inode);                 
400132f0:	7f ff fe 90 	call  40012d30 <rtems_rfs_rtems_node_type_by_inode>
400132f4:	90 07 bf d8 	add  %fp, -40, %o0                             
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
400132f8:	92 07 bf d8 	add  %fp, -40, %o1                             
  if (rc > 0)                                                         
  {                                                                   
    return rtems_rfs_rtems_error ("node_type: opening inode", rc);    
  }                                                                   
                                                                      
  type = rtems_rfs_rtems_node_type_by_inode (&inode);                 
400132fc:	b0 10 00 08 	mov  %o0, %i0                                  
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
40013300:	7f ff fc ba 	call  400125e8 <rtems_rfs_inode_close>         
40013304:	90 10 00 1c 	mov  %i4, %o0                                  
  if (rc > 0)                                                         
40013308:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001330c:	14 bf ff f4 	bg  400132dc <rtems_rfs_rtems_node_type+0x2c>  <== NEVER TAKEN
40013310:	01 00 00 00 	nop                                            
  {                                                                   
    return rtems_rfs_rtems_error ("node_type: closing inode", rc);    
  }                                                                   
                                                                      
  return type;                                                        
}                                                                     
40013314:	81 c7 e0 08 	ret                                            
40013318:	81 e8 00 00 	restore                                        
                                                                      

40012f60 <rtems_rfs_rtems_readlink>: static ssize_t rtems_rfs_rtems_readlink (const rtems_filesystem_location_info_t* pathloc, char* buf, size_t bufsize) {
40012f60:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_rfs_file_system*  fs = rtems_rfs_rtems_pathloc_dev (pathloc); 
40012f64:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
  int                     rc;                                         
                                                                      
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_READLINK))         
    printf ("rtems-rfs-rtems: readlink: in: ino:%" PRId32 "\n", ino); 
                                                                      
  rc = rtems_rfs_symlink_read (fs, ino, buf, bufsize, &length);       
40012f68:	d2 06 20 08 	ld  [ %i0 + 8 ], %o1                           
40012f6c:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           
40012f70:	94 10 00 19 	mov  %i1, %o2                                  
40012f74:	96 10 00 1a 	mov  %i2, %o3                                  
40012f78:	40 00 35 23 	call  40020404 <rtems_rfs_symlink_read>        
40012f7c:	98 07 bf fc 	add  %fp, -4, %o4                              
  if (rc)                                                             
  {                                                                   
    return rtems_rfs_rtems_error ("readlink: reading link", rc);      
  }                                                                   
                                                                      
  return (ssize_t) length;                                            
40012f80:	f0 07 bf fc 	ld  [ %fp + -4 ], %i0                          
                                                                      
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_READLINK))         
    printf ("rtems-rfs-rtems: readlink: in: ino:%" PRId32 "\n", ino); 
                                                                      
  rc = rtems_rfs_symlink_read (fs, ino, buf, bufsize, &length);       
  if (rc)                                                             
40012f84:	80 a2 20 00 	cmp  %o0, 0                                    
40012f88:	02 80 00 05 	be  40012f9c <rtems_rfs_rtems_readlink+0x3c>   <== ALWAYS TAKEN
40012f8c:	ba 10 00 08 	mov  %o0, %i5                                  
  {                                                                   
    return rtems_rfs_rtems_error ("readlink: reading link", rc);      
40012f90:	40 00 3e 6a 	call  40022938 <__errno>                       <== NOT EXECUTED
40012f94:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40012f98:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  return (ssize_t) length;                                            
}                                                                     
40012f9c:	81 c7 e0 08 	ret                                            
40012fa0:	81 e8 00 00 	restore                                        
                                                                      

40012e90 <rtems_rfs_rtems_rename>: rtems_rfs_rtems_rename(const rtems_filesystem_location_info_t* old_parent_loc, const rtems_filesystem_location_info_t* old_loc, const rtems_filesystem_location_info_t* new_parent_loc, const char* new_name, size_t new_name_len) {
40012e90:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
  rtems_rfs_file_system*  fs = rtems_rfs_rtems_pathloc_dev (old_loc); 
40012e94:	c2 06 60 14 	ld  [ %i1 + 0x14 ], %g1                        <== NOT EXECUTED
  int                     rc;                                         
                                                                      
  old_parent = rtems_rfs_rtems_get_pathloc_ino (old_parent_loc);      
  new_parent = rtems_rfs_rtems_get_pathloc_ino (new_parent_loc);      
                                                                      
  ino  = rtems_rfs_rtems_get_pathloc_ino (old_loc);                   
40012e98:	fa 06 60 08 	ld  [ %i1 + 8 ], %i5                           <== NOT EXECUTED
                       const rtems_filesystem_location_info_t* old_loc,
                       const rtems_filesystem_location_info_t* new_parent_loc,
                       const char*                             new_name,
                       size_t                                  new_name_len)
{                                                                     
  rtems_rfs_file_system*  fs = rtems_rfs_rtems_pathloc_dev (old_loc); 
40012e9c:	e0 00 60 08 	ld  [ %g1 + 8 ], %l0                           <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Link to the inode before unlinking so the inode is not erased when
   * unlinked.                                                        
   */                                                                 
  rc = rtems_rfs_link (fs, new_name, new_name_len, new_parent, ino, true);
40012ea0:	d6 06 a0 08 	ld  [ %i2 + 8 ], %o3                           <== NOT EXECUTED
40012ea4:	94 10 00 1c 	mov  %i4, %o2                                  <== 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);      
40012ea8:	f0 06 20 08 	ld  [ %i0 + 8 ], %i0                           <== NOT EXECUTED
  new_parent = rtems_rfs_rtems_get_pathloc_ino (new_parent_loc);      
                                                                      
  ino  = rtems_rfs_rtems_get_pathloc_ino (old_loc);                   
  doff = rtems_rfs_rtems_get_pathloc_doff (old_loc);                  
40012eac:	f4 06 60 0c 	ld  [ %i1 + 0xc ], %i2                         <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Link to the inode before unlinking so the inode is not erased when
   * unlinked.                                                        
   */                                                                 
  rc = rtems_rfs_link (fs, new_name, new_name_len, new_parent, ino, true);
40012eb0:	90 10 00 10 	mov  %l0, %o0                                  <== NOT EXECUTED
40012eb4:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
40012eb8:	98 10 00 1d 	mov  %i5, %o4                                  <== NOT EXECUTED
40012ebc:	40 00 33 37 	call  4001fb98 <rtems_rfs_link>                <== NOT EXECUTED
40012ec0:	9a 10 20 01 	mov  1, %o5                                    <== NOT EXECUTED
  if (rc)                                                             
40012ec4:	b8 92 20 00 	orcc  %o0, 0, %i4                              <== NOT EXECUTED
40012ec8:	02 80 00 07 	be  40012ee4 <rtems_rfs_rtems_rename+0x54>     <== NOT EXECUTED
40012ecc:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
  {                                                                   
    return rtems_rfs_rtems_error ("rename: linking", rc);             
40012ed0:	40 00 3e 9a 	call  40022938 <__errno>                       <== NOT EXECUTED
40012ed4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40012ed8:	f8 22 00 00 	st  %i4, [ %o0 ]                               <== NOT EXECUTED
40012edc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40012ee0:	81 e8 00 00 	restore                                        <== 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,                   
40012ee4:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
40012ee8:	90 10 00 10 	mov  %l0, %o0                                  <== NOT EXECUTED
40012eec:	96 10 00 1a 	mov  %i2, %o3                                  <== NOT EXECUTED
40012ef0:	98 10 20 02 	mov  2, %o4                                    <== NOT EXECUTED
40012ef4:	40 00 33 9d 	call  4001fd68 <rtems_rfs_unlink>              <== NOT EXECUTED
40012ef8:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
                         rtems_rfs_unlink_dir_allowed);               
  if (rc)                                                             
40012efc:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40012f00:	02 bf ff f7 	be  40012edc <rtems_rfs_rtems_rename+0x4c>     <== NOT EXECUTED
40012f04:	ba 10 00 08 	mov  %o0, %i5                                  <== NOT EXECUTED
  {                                                                   
    return rtems_rfs_rtems_error ("rename: unlinking", rc);           
40012f08:	40 00 3e 8c 	call  40022938 <__errno>                       <== NOT EXECUTED
40012f0c:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40012f10:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
40012f14:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40012f18:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40013da8 <rtems_rfs_rtems_set_handlers>: */ bool rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc, rtems_rfs_inode_handle* inode) {
40013da8:	9d e3 bf a0 	save  %sp, -96, %sp                            
 * @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);                    
40013dac:	c4 06 60 0c 	ld  [ %i1 + 0xc ], %g2                         
  uint16_t mode = rtems_rfs_inode_get_mode (inode);                   
  loc->handlers = NULL;                                               
  if (RTEMS_RFS_S_ISDIR (mode))                                       
40013db0:	07 00 00 10 	sethi  %hi(0x4000), %g3                        
40013db4:	c2 08 a0 02 	ldub  [ %g2 + 2 ], %g1                         
40013db8:	c4 08 a0 03 	ldub  [ %g2 + 3 ], %g2                         
40013dbc:	83 28 60 08 	sll  %g1, 8, %g1                               
40013dc0:	82 10 40 02 	or  %g1, %g2, %g1                              
40013dc4:	05 00 00 3c 	sethi  %hi(0xf000), %g2                        
40013dc8:	84 08 40 02 	and  %g1, %g2, %g2                             
40013dcc:	80 a0 80 03 	cmp  %g2, %g3                                  
40013dd0:	02 80 00 1d 	be  40013e44 <rtems_rfs_rtems_set_handlers+0x9c>
40013dd4:	c0 26 20 10 	clr  [ %i0 + 0x10 ]                            
    loc->handlers = rtems_rfs_rtems_handlers (dir);                   
  else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))       
40013dd8:	09 00 00 2c 	sethi  %hi(0xb000), %g4                        
40013ddc:	07 00 00 08 	sethi  %hi(0x2000), %g3                        
40013de0:	88 08 40 04 	and  %g1, %g4, %g4                             
40013de4:	80 a1 00 03 	cmp  %g4, %g3                                  
40013de8:	02 80 00 10 	be  40013e28 <rtems_rfs_rtems_set_handlers+0x80><== NEVER TAKEN
40013dec:	07 00 00 28 	sethi  %hi(0xa000), %g3                        
    loc->handlers = rtems_rfs_rtems_handlers (device);                
  else if (RTEMS_RFS_S_ISLNK (mode))                                  
40013df0:	80 a0 80 03 	cmp  %g2, %g3                                  
40013df4:	02 80 00 22 	be  40013e7c <rtems_rfs_rtems_set_handlers+0xd4>
40013df8:	07 00 00 20 	sethi  %hi(0x8000), %g3                        
    loc->handlers = rtems_rfs_rtems_handlers (link);                  
  else if (RTEMS_RFS_S_ISREG (mode))                                  
40013dfc:	80 a0 80 03 	cmp  %g2, %g3                                  
40013e00:	02 80 00 18 	be  40013e60 <rtems_rfs_rtems_set_handlers+0xb8><== ALWAYS TAKEN
40013e04:	93 28 60 10 	sll  %g1, 0x10, %o1                            
    loc->handlers = rtems_rfs_rtems_handlers (file);                  
  else                                                                
  {                                                                   
    printf ("rtems-rfs: mode type unknown: %04x\n", mode);            
40013e08:	11 10 00 d8 	sethi  %hi(0x40036000), %o0                    <== NOT EXECUTED
40013e0c:	93 32 60 10 	srl  %o1, 0x10, %o1                            <== NOT EXECUTED
40013e10:	40 00 40 5b 	call  40023f7c <printf>                        <== NOT EXECUTED
40013e14:	90 12 20 08 	or  %o0, 8, %o0                                <== NOT EXECUTED
    return false;                                                     
40013e18:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
  }                                                                   
  return true;                                                        
}                                                                     
40013e1c:	b0 08 60 01 	and  %g1, 1, %i0                               
40013e20:	81 c7 e0 08 	ret                                            
40013e24:	81 e8 00 00 	restore                                        
  else                                                                
  {                                                                   
    printf ("rtems-rfs: mode type unknown: %04x\n", mode);            
    return false;                                                     
  }                                                                   
  return true;                                                        
40013e28:	82 10 20 01 	mov  1, %g1                                    <== 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))       
    loc->handlers = rtems_rfs_rtems_handlers (device);                
40013e2c:	05 10 00 e0 	sethi  %hi(0x40038000), %g2                    <== NOT EXECUTED
40013e30:	84 10 a2 9c 	or  %g2, 0x29c, %g2	! 4003829c <rtems_rfs_rtems_device_handlers><== NOT EXECUTED
40013e34:	c4 26 20 10 	st  %g2, [ %i0 + 0x10 ]                        <== NOT EXECUTED
  {                                                                   
    printf ("rtems-rfs: mode type unknown: %04x\n", mode);            
    return false;                                                     
  }                                                                   
  return true;                                                        
}                                                                     
40013e38:	b0 08 60 01 	and  %g1, 1, %i0                               <== NOT EXECUTED
40013e3c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40013e40:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  else                                                                
  {                                                                   
    printf ("rtems-rfs: mode type unknown: %04x\n", mode);            
    return false;                                                     
  }                                                                   
  return true;                                                        
40013e44:	82 10 20 01 	mov  1, %g1                                    
                              rtems_rfs_inode_handle*           inode)
{                                                                     
  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);                   
40013e48:	05 10 00 e0 	sethi  %hi(0x40038000), %g2                    
40013e4c:	84 10 a2 c8 	or  %g2, 0x2c8, %g2	! 400382c8 <rtems_rfs_rtems_dir_handlers>
40013e50:	c4 26 20 10 	st  %g2, [ %i0 + 0x10 ]                        
  {                                                                   
    printf ("rtems-rfs: mode type unknown: %04x\n", mode);            
    return false;                                                     
  }                                                                   
  return true;                                                        
}                                                                     
40013e54:	b0 08 60 01 	and  %g1, 1, %i0                               
40013e58:	81 c7 e0 08 	ret                                            
40013e5c:	81 e8 00 00 	restore                                        
  else                                                                
  {                                                                   
    printf ("rtems-rfs: mode type unknown: %04x\n", mode);            
    return false;                                                     
  }                                                                   
  return true;                                                        
40013e60:	82 10 20 01 	mov  1, %g1                                    
  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))                                  
    loc->handlers = rtems_rfs_rtems_handlers (link);                  
  else if (RTEMS_RFS_S_ISREG (mode))                                  
    loc->handlers = rtems_rfs_rtems_handlers (file);                  
40013e64:	05 10 00 e0 	sethi  %hi(0x40038000), %g2                    
40013e68:	84 10 a2 f4 	or  %g2, 0x2f4, %g2	! 400382f4 <rtems_rfs_rtems_file_handlers>
40013e6c:	c4 26 20 10 	st  %g2, [ %i0 + 0x10 ]                        
  {                                                                   
    printf ("rtems-rfs: mode type unknown: %04x\n", mode);            
    return false;                                                     
  }                                                                   
  return true;                                                        
}                                                                     
40013e70:	b0 08 60 01 	and  %g1, 1, %i0                               
40013e74:	81 c7 e0 08 	ret                                            
40013e78:	81 e8 00 00 	restore                                        
  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))                                  
    loc->handlers = rtems_rfs_rtems_handlers (link);                  
40013e7c:	05 10 00 d7 	sethi  %hi(0x40035c00), %g2                    
  else                                                                
  {                                                                   
    printf ("rtems-rfs: mode type unknown: %04x\n", mode);            
    return false;                                                     
  }                                                                   
  return true;                                                        
40013e80:	82 10 20 01 	mov  1, %g1                                    
  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))                                  
    loc->handlers = rtems_rfs_rtems_handlers (link);                  
40013e84:	84 10 a3 d4 	or  %g2, 0x3d4, %g2                            
40013e88:	10 bf ff e5 	b  40013e1c <rtems_rfs_rtems_set_handlers+0x74>
40013e8c:	c4 26 20 10 	st  %g2, [ %i0 + 0x10 ]                        
                                                                      

40012db4 <rtems_rfs_rtems_statvfs>: * @return int */ static int rtems_rfs_rtems_statvfs (const rtems_filesystem_location_info_t* pathloc, struct statvfs* sb) {
40012db4:	9d e3 bf 98 	save  %sp, -104, %sp                           <== NOT EXECUTED
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);  
40012db8:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        <== NOT EXECUTED
  size_t                 blocks;                                      
  size_t                 inodes;                                      
                                                                      
  rtems_rfs_group_usage (fs, &blocks, &inodes);                       
40012dbc:	92 07 bf f8 	add  %fp, -8, %o1                              <== NOT EXECUTED
 */                                                                   
static int                                                            
rtems_rfs_rtems_statvfs (const rtems_filesystem_location_info_t* pathloc,
                         struct statvfs*                         sb)  
{                                                                     
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);  
40012dc0:	fa 00 60 08 	ld  [ %g1 + 8 ], %i5                           <== NOT EXECUTED
  size_t                 blocks;                                      
  size_t                 inodes;                                      
                                                                      
  rtems_rfs_group_usage (fs, &blocks, &inodes);                       
40012dc4:	94 07 bf fc 	add  %fp, -4, %o2                              <== NOT EXECUTED
40012dc8:	7f ff fd 2e 	call  40012280 <rtems_rfs_group_usage>         <== NOT EXECUTED
40012dcc:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
                                                                      
  sb->f_bsize   = rtems_rfs_fs_block_size (fs);                       
  sb->f_frsize  = rtems_rfs_fs_media_block_size (fs);                 
40012dd0:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        <== NOT EXECUTED
  sb->f_blocks  = rtems_rfs_fs_media_blocks (fs);                     
  sb->f_bfree   = rtems_rfs_fs_blocks (fs) - blocks;                  
40012dd4:	c4 07 60 04 	ld  [ %i5 + 4 ], %g2                           <== NOT EXECUTED
40012dd8:	c6 07 bf f8 	ld  [ %fp + -8 ], %g3                          <== NOT EXECUTED
  size_t                 blocks;                                      
  size_t                 inodes;                                      
                                                                      
  rtems_rfs_group_usage (fs, &blocks, &inodes);                       
                                                                      
  sb->f_bsize   = rtems_rfs_fs_block_size (fs);                       
40012ddc:	f0 07 60 08 	ld  [ %i5 + 8 ], %i0                           <== NOT EXECUTED
  sb->f_frsize  = rtems_rfs_fs_media_block_size (fs);                 
40012de0:	f4 00 60 20 	ld  [ %g1 + 0x20 ], %i2                        <== NOT EXECUTED
  sb->f_blocks  = rtems_rfs_fs_media_blocks (fs);                     
40012de4:	f6 00 60 1c 	ld  [ %g1 + 0x1c ], %i3                        <== 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;                                        
  sb->f_fsid    = RTEMS_RFS_SB_MAGIC;                                 
  sb->f_flag    = rtems_rfs_fs_flags (fs);                            
40012de8:	f8 07 40 00 	ld  [ %i5 ], %i4                               <== 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);                           
40012dec:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        <== NOT EXECUTED
  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);                         
40012df0:	c8 07 60 1c 	ld  [ %i5 + 0x1c ], %g4                        <== 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;                  
40012df4:	86 20 80 03 	sub  %g2, %g3, %g3                             <== 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;                  
40012df8:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          <== NOT EXECUTED
  size_t                 blocks;                                      
  size_t                 inodes;                                      
                                                                      
  rtems_rfs_group_usage (fs, &blocks, &inodes);                       
                                                                      
  sb->f_bsize   = rtems_rfs_fs_block_size (fs);                       
40012dfc:	f0 26 40 00 	st  %i0, [ %i1 ]                               <== 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;                  
40012e00:	84 20 40 02 	sub  %g1, %g2, %g2                             <== 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);                           
40012e04:	c2 26 60 20 	st  %g1, [ %i1 + 0x20 ]                        <== NOT EXECUTED
  size_t                 inodes;                                      
                                                                      
  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);                 
40012e08:	f4 26 60 04 	st  %i2, [ %i1 + 4 ]                           <== NOT EXECUTED
  sb->f_blocks  = rtems_rfs_fs_media_blocks (fs);                     
40012e0c:	c0 26 60 08 	clr  [ %i1 + 8 ]                               <== NOT EXECUTED
40012e10:	f6 26 60 0c 	st  %i3, [ %i1 + 0xc ]                         <== NOT EXECUTED
  sb->f_bfree   = rtems_rfs_fs_blocks (fs) - blocks;                  
40012e14:	c0 26 60 10 	clr  [ %i1 + 0x10 ]                            <== NOT EXECUTED
40012e18:	c6 26 60 14 	st  %g3, [ %i1 + 0x14 ]                        <== NOT EXECUTED
  sb->f_bavail  = sb->f_bfree;                                        
40012e1c:	c0 26 60 18 	clr  [ %i1 + 0x18 ]                            <== NOT EXECUTED
40012e20:	c6 26 60 1c 	st  %g3, [ %i1 + 0x1c ]                        <== NOT EXECUTED
  sb->f_files   = rtems_rfs_fs_inodes (fs);                           
  sb->f_ffree   = rtems_rfs_fs_inodes (fs) - inodes;                  
40012e24:	c4 26 60 24 	st  %g2, [ %i1 + 0x24 ]                        <== NOT EXECUTED
  sb->f_favail  = sb->f_ffree;                                        
40012e28:	c4 26 60 28 	st  %g2, [ %i1 + 0x28 ]                        <== NOT EXECUTED
  sb->f_fsid    = RTEMS_RFS_SB_MAGIC;                                 
40012e2c:	03 0a 02 48 	sethi  %hi(0x28092000), %g1                    <== NOT EXECUTED
  sb->f_flag    = rtems_rfs_fs_flags (fs);                            
40012e30:	f8 26 60 30 	st  %i4, [ %i1 + 0x30 ]                        <== 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;                                 
40012e34:	82 10 60 01 	or  %g1, 1, %g1                                <== NOT EXECUTED
  sb->f_flag    = rtems_rfs_fs_flags (fs);                            
  sb->f_namemax = rtems_rfs_fs_max_name (fs);                         
40012e38:	c8 26 60 34 	st  %g4, [ %i1 + 0x34 ]                        <== 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;                                 
40012e3c:	c2 26 60 2c 	st  %g1, [ %i1 + 0x2c ]                        <== NOT EXECUTED
  sb->f_flag    = rtems_rfs_fs_flags (fs);                            
  sb->f_namemax = rtems_rfs_fs_max_name (fs);                         
                                                                      
  return 0;                                                           
}                                                                     
40012e40:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40012e44:	91 e8 20 00 	restore  %g0, 0, %o0                           <== NOT EXECUTED
                                                                      

40012fa4 <rtems_rfs_rtems_symlink>: static int rtems_rfs_rtems_symlink (const rtems_filesystem_location_info_t* parent_loc, const char* node_name, size_t node_name_len, const char* target) {
40012fa4:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
40012fa8:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
  rtems_rfs_ino          parent = rtems_rfs_rtems_get_pathloc_ino (parent_loc);
  int                    rc;                                          
                                                                      
  rc = rtems_rfs_symlink (fs, node_name, node_name_len,               
                          target, strlen (target),                    
40012fac:	90 10 00 1b 	mov  %i3, %o0                                  
40012fb0:	40 00 48 64 	call  40025140 <strlen>                        
40012fb4:	f8 00 60 08 	ld  [ %g1 + 8 ], %i4                           
                         const char*                             node_name,
                         size_t                                  node_name_len,
                         const char*                             target)
{                                                                     
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
  rtems_rfs_ino          parent = rtems_rfs_rtems_get_pathloc_ino (parent_loc);
40012fb8:	f0 06 20 08 	ld  [ %i0 + 8 ], %i0                           
  int                    rc;                                          
                                                                      
  rc = rtems_rfs_symlink (fs, node_name, node_name_len,               
40012fbc:	40 00 12 ea 	call  40017b64 <geteuid>                       
40012fc0:	ba 10 00 08 	mov  %o0, %i5                                  
40012fc4:	40 00 12 e4 	call  40017b54 <getegid>                       
40012fc8:	a0 10 00 08 	mov  %o0, %l0                                  
40012fcc:	91 2a 20 10 	sll  %o0, 0x10, %o0                            
40012fd0:	91 32 20 10 	srl  %o0, 0x10, %o0                            
40012fd4:	f0 23 a0 60 	st  %i0, [ %sp + 0x60 ]                        
40012fd8:	d0 23 a0 5c 	st  %o0, [ %sp + 0x5c ]                        
40012fdc:	98 10 00 1d 	mov  %i5, %o4                                  
40012fe0:	9b 2c 20 10 	sll  %l0, 0x10, %o5                            
40012fe4:	90 10 00 1c 	mov  %i4, %o0                                  
40012fe8:	92 10 00 19 	mov  %i1, %o1                                  
40012fec:	94 10 00 1a 	mov  %i2, %o2                                  
40012ff0:	96 10 00 1b 	mov  %i3, %o3                                  
40012ff4:	9b 33 60 10 	srl  %o5, 0x10, %o5                            
40012ff8:	40 00 34 68 	call  40020198 <rtems_rfs_symlink>             
40012ffc:	b0 10 20 00 	clr  %i0                                       
                          target, strlen (target),                    
                          geteuid(), getegid(), parent);              
  if (rc)                                                             
40013000:	80 a2 20 00 	cmp  %o0, 0                                    
40013004:	02 80 00 05 	be  40013018 <rtems_rfs_rtems_symlink+0x74>    <== ALWAYS TAKEN
40013008:	ba 10 00 08 	mov  %o0, %i5                                  
  {                                                                   
    return rtems_rfs_rtems_error ("symlink: linking", rc);            
4001300c:	40 00 3e 4b 	call  40022938 <__errno>                       <== NOT EXECUTED
40013010:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40013014:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
40013018:	81 c7 e0 08 	ret                                            
4001301c:	81 e8 00 00 	restore                                        
                                                                      

40013a48 <rtems_rfs_rtems_unlock_by_mt_entry>: static void rtems_rfs_rtems_unlock_by_mt_entry ( const rtems_filesystem_mount_table_entry_t *mt_entry ) {
40013a48:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_rfs_file_system* fs = mt_entry->fs_info;                      
40013a4c:	d0 06 20 08 	ld  [ %i0 + 8 ], %o0                           
 */                                                                   
static inline void                                                    
 rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)                   
{                                                                     
  rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);            
  rtems_rfs_buffers_release (fs);                                     
40013a50:	40 00 24 3e 	call  4001cb48 <rtems_rfs_buffers_release>     
40013a54:	fa 02 20 80 	ld  [ %o0 + 0x80 ], %i5                        
 */                                                                   
static inline int                                                     
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)                       
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_release (*mutex);            
40013a58:	7f ff e4 f3 	call  4000ce24 <rtems_semaphore_release>       
40013a5c:	d0 07 40 00 	ld  [ %i5 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
40013a60:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40013a64:	12 80 00 04 	bne  40013a74 <rtems_rfs_rtems_unlock_by_mt_entry+0x2c><== NEVER TAKEN
40013a68:	90 10 20 00 	clr  %o0                                       
40013a6c:	81 c7 e0 08 	ret                                            
40013a70:	81 e8 00 00 	restore                                        
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
40013a74:	40 00 01 0c 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
40013a78:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40013a7c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40013a80:	02 bf ff fb 	be  40013a6c <rtems_rfs_rtems_unlock_by_mt_entry+0x24><== NOT EXECUTED
40013a84:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
      printf ("rtems-rfs: mutex: release failed: %s\n",               
40013a88:	40 00 0f 62 	call  40017810 <rtems_status_text>             <== NOT EXECUTED
40013a8c:	31 10 00 d7 	sethi  %hi(0x40035c00), %i0                    <== NOT EXECUTED
40013a90:	b0 16 22 f0 	or  %i0, 0x2f0, %i0	! 40035ef0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
40013a94:	40 00 41 3a 	call  40023f7c <printf>                        <== NOT EXECUTED
40013a98:	93 e8 00 08 	restore  %g0, %o0, %o1                         <== NOT EXECUTED
                                                                      

40013020 <rtems_rfs_rtems_utime>: static int rtems_rfs_rtems_utime(const rtems_filesystem_location_info_t* pathloc, time_t atime, time_t mtime) {
40013020:	9d e3 bf 78 	save  %sp, -136, %sp                           <== NOT EXECUTED
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);  
40013024:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        <== NOT EXECUTED
  rtems_rfs_ino          ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
  rtems_rfs_inode_handle inode;                                       
  int                    rc;                                          
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
40013028:	d2 06 20 08 	ld  [ %i0 + 8 ], %o1                           <== NOT EXECUTED
static int                                                            
rtems_rfs_rtems_utime(const rtems_filesystem_location_info_t* pathloc,
                      time_t                                  atime,  
                      time_t                                  mtime)  
{                                                                     
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);  
4001302c:	fa 00 60 08 	ld  [ %g1 + 8 ], %i5                           <== NOT EXECUTED
  rtems_rfs_ino          ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
  rtems_rfs_inode_handle inode;                                       
  int                    rc;                                          
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
40013030:	94 07 bf d8 	add  %fp, -40, %o2                             <== NOT EXECUTED
40013034:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40013038:	7f ff fc f4 	call  40012408 <rtems_rfs_inode_open>          <== NOT EXECUTED
4001303c:	96 10 20 01 	mov  1, %o3                                    <== NOT EXECUTED
  if (rc)                                                             
40013040:	b8 92 20 00 	orcc  %o0, 0, %i4                              <== NOT EXECUTED
40013044:	02 80 00 07 	be  40013060 <rtems_rfs_rtems_utime+0x40>      <== NOT EXECUTED
40013048:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         <== NOT EXECUTED
  {                                                                   
    return rtems_rfs_rtems_error ("utime: read inode", rc);           
4001304c:	40 00 3e 3b 	call  40022938 <__errno>                       <== NOT EXECUTED
40013050:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40013054:	f8 22 00 00 	st  %i4, [ %o0 ]                               <== NOT EXECUTED
40013058:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001305c:	81 e8 00 00 	restore                                        <== 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);                  
40013060:	85 36 60 18 	srl  %i1, 0x18, %g2                            <== NOT EXECUTED
40013064:	87 36 60 10 	srl  %i1, 0x10, %g3                            <== NOT EXECUTED
40013068:	c4 28 60 10 	stb  %g2, [ %g1 + 0x10 ]                       <== NOT EXECUTED
4001306c:	85 36 60 08 	srl  %i1, 8, %g2                               <== NOT EXECUTED
40013070:	c6 28 60 11 	stb  %g3, [ %g1 + 0x11 ]                       <== NOT EXECUTED
40013074:	c4 28 60 12 	stb  %g2, [ %g1 + 0x12 ]                       <== NOT EXECUTED
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
40013078:	86 10 20 01 	mov  1, %g3                                    <== 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);                  
4001307c:	85 36 a0 18 	srl  %i2, 0x18, %g2                            <== 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);                      
40013080:	c6 2f bf e8 	stb  %g3, [ %fp + -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);                  
40013084:	c4 28 60 14 	stb  %g2, [ %g1 + 0x14 ]                       <== NOT EXECUTED
40013088:	87 36 a0 10 	srl  %i2, 0x10, %g3                            <== NOT EXECUTED
4001308c:	85 36 a0 08 	srl  %i2, 8, %g2                               <== NOT EXECUTED
  }                                                                   
                                                                      
  rtems_rfs_inode_set_atime (&inode, atime);                          
  rtems_rfs_inode_set_mtime (&inode, mtime);                          
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
40013090:	90 10 00 1d 	mov  %i5, %o0                                  <== 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);                  
40013094:	f2 28 60 13 	stb  %i1, [ %g1 + 0x13 ]                       <== 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);                  
40013098:	c6 28 60 15 	stb  %g3, [ %g1 + 0x15 ]                       <== NOT EXECUTED
4001309c:	c4 28 60 16 	stb  %g2, [ %g1 + 0x16 ]                       <== NOT EXECUTED
400130a0:	f4 28 60 17 	stb  %i2, [ %g1 + 0x17 ]                       <== NOT EXECUTED
400130a4:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
400130a8:	7f ff fd 50 	call  400125e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
400130ac:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
  if (rc)                                                             
400130b0:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
400130b4:	02 bf ff e9 	be  40013058 <rtems_rfs_rtems_utime+0x38>      <== NOT EXECUTED
400130b8:	ba 10 00 08 	mov  %o0, %i5                                  <== NOT EXECUTED
  {                                                                   
    return rtems_rfs_rtems_error ("utime: closing inode", rc);        
400130bc:	40 00 3e 1f 	call  40022938 <__errno>                       <== NOT EXECUTED
400130c0:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
400130c4:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
400130c8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400130cc:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40010c4c <rtems_rfs_rup_quotient>: * 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) {
40010c4c:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
40010c50:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
  if (dividend == 0)                                                  
40010c54:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40010c58:	02 80 00 06 	be  40010c70 <rtems_rfs_rup_quotient+0x24>     <== NOT EXECUTED
40010c5c:	b0 10 20 01 	mov  1, %i0                                    <== NOT EXECUTED
    return 1;                                                         
  return ((dividend - 1) / divisor) + 1;                              
40010c60:	90 02 3f ff 	add  %o0, -1, %o0                              <== NOT EXECUTED
40010c64:	7f ff c6 8f 	call  400026a0 <.udiv>                         <== NOT EXECUTED
40010c68:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
40010c6c:	b0 02 20 01 	add  %o0, 1, %i0                               <== NOT EXECUTED
}                                                                     
40010c70:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40010c74:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4001c318 <rtems_rfs_scan_chain>: */ static rtems_rfs_buffer* rtems_rfs_scan_chain (rtems_chain_control* chain, uint32_t* count, rtems_rfs_buffer_block block) {
4001c318:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_rfs_buffer* buffer;                                           
  rtems_chain_node* node;                                             
                                                                      
  node = rtems_chain_last (chain);                                    
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))                
4001c31c:	90 10 20 00 	clr  %o0                                       
4001c320:	92 10 20 80 	mov  0x80, %o1                                 
4001c324:	7f ff de e0 	call  40013ea4 <rtems_rfs_trace>               
4001c328:	fa 06 20 08 	ld  [ %i0 + 8 ], %i5                           
4001c32c:	80 8a 20 ff 	btst  0xff, %o0                                
4001c330:	32 80 00 37 	bne,a   4001c40c <rtems_rfs_scan_chain+0xf4>   <== NEVER TAKEN
4001c334:	d2 06 40 00 	ld  [ %i1 ], %o1                               <== NOT EXECUTED
  while (!rtems_chain_is_head (chain, node))                          
  {                                                                   
    buffer = (rtems_rfs_buffer*) node;                                
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))              
      printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));            
4001c338:	39 10 00 db 	sethi  %hi(0x40036c00), %i4                    
  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))                          
4001c33c:	80 a7 40 18 	cmp  %i5, %i0                                  
4001c340:	12 80 00 0b 	bne  4001c36c <rtems_rfs_scan_chain+0x54>      <== ALWAYS TAKEN
4001c344:	b8 17 21 58 	or  %i4, 0x158, %i4                            
      return buffer;                                                  
    }                                                                 
    node = rtems_chain_previous (node);                               
  }                                                                   
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))                
4001c348:	10 80 00 2a 	b  4001c3f0 <rtems_rfs_scan_chain+0xd8>        <== NOT EXECUTED
4001c34c:	90 10 20 00 	clr  %o0                                       <== 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)
4001c350:	80 a0 40 1a 	cmp  %g1, %i2                                  
4001c354:	02 80 00 14 	be  4001c3a4 <rtems_rfs_scan_chain+0x8c>       
4001c358:	90 10 20 00 	clr  %o0                                       
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Previous(                     
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  return the_node->previous;                                          
4001c35c:	fa 07 60 04 	ld  [ %i5 + 4 ], %i5                           
  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))                          
4001c360:	80 a7 40 18 	cmp  %i5, %i0                                  
4001c364:	02 80 00 23 	be  4001c3f0 <rtems_rfs_scan_chain+0xd8>       
4001c368:	90 10 20 00 	clr  %o0                                       
  {                                                                   
    buffer = (rtems_rfs_buffer*) node;                                
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))              
4001c36c:	90 10 20 00 	clr  %o0                                       
4001c370:	7f ff de cd 	call  40013ea4 <rtems_rfs_trace>               
4001c374:	92 10 20 80 	mov  0x80, %o1                                 
4001c378:	80 8a 20 ff 	btst  0xff, %o0                                
4001c37c:	22 bf ff f5 	be,a   4001c350 <rtems_rfs_scan_chain+0x38>    <== ALWAYS TAKEN
4001c380:	c2 07 60 34 	ld  [ %i5 + 0x34 ], %g1                        
      printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));            
4001c384:	d2 07 60 34 	ld  [ %i5 + 0x34 ], %o1                        <== NOT EXECUTED
4001c388:	40 00 1e fd 	call  40023f7c <printf>                        <== NOT EXECUTED
4001c38c:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
                                                                      
    if (((rtems_rfs_buffer_block) ((intptr_t)(buffer->user))) == block)
4001c390:	c2 07 60 34 	ld  [ %i5 + 0x34 ], %g1                        <== NOT EXECUTED
4001c394:	80 a0 40 1a 	cmp  %g1, %i2                                  <== NOT EXECUTED
4001c398:	32 bf ff f2 	bne,a   4001c360 <rtems_rfs_scan_chain+0x48>   <== NOT EXECUTED
4001c39c:	fa 07 60 04 	ld  [ %i5 + 4 ], %i5                           <== NOT EXECUTED
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))            
4001c3a0:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001c3a4:	7f ff de c0 	call  40013ea4 <rtems_rfs_trace>               
4001c3a8:	92 10 20 80 	mov  0x80, %o1                                 
4001c3ac:	80 8a 20 ff 	btst  0xff, %o0                                
4001c3b0:	22 80 00 07 	be,a   4001c3cc <rtems_rfs_scan_chain+0xb4>    <== ALWAYS TAKEN
4001c3b4:	c2 06 40 00 	ld  [ %i1 ], %g1                               
        printf (": found block=%" PRIuPTR "\n",                       
4001c3b8:	d2 07 60 34 	ld  [ %i5 + 0x34 ], %o1                        <== NOT EXECUTED
4001c3bc:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
4001c3c0:	40 00 1e ef 	call  40023f7c <printf>                        <== NOT EXECUTED
4001c3c4:	90 12 21 60 	or  %o0, 0x160, %o0	! 40036d60 <CSWTCH.2+0x170><== NOT EXECUTED
                ((intptr_t)(buffer->user)));                          
                                                                      
      (*count)--;                                                     
4001c3c8:	c2 06 40 00 	ld  [ %i1 ], %g1                               <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void rtems_chain_extract(                        
  rtems_chain_node *the_node                                          
)                                                                     
{                                                                     
  _Chain_Extract( the_node );                                         
4001c3cc:	90 10 00 1d 	mov  %i5, %o0                                  
4001c3d0:	82 00 7f ff 	add  %g1, -1, %g1                              
      rtems_chain_extract (node);                                     
      rtems_chain_set_off_chain (node);                               
      return buffer;                                                  
4001c3d4:	b0 10 00 1d 	mov  %i5, %i0                                  
4001c3d8:	7f ff f3 a1 	call  4001925c <_Chain_Extract>                
4001c3dc:	c2 26 40 00 	st  %g1, [ %i1 ]                               
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(                       
  Chain_Node *node                                                    
)                                                                     
{                                                                     
  node->next = node->previous = NULL;                                 
4001c3e0:	c0 27 60 04 	clr  [ %i5 + 4 ]                               
4001c3e4:	c0 27 40 00 	clr  [ %i5 ]                                   
4001c3e8:	81 c7 e0 08 	ret                                            
4001c3ec:	81 e8 00 00 	restore                                        
    }                                                                 
    node = rtems_chain_previous (node);                               
  }                                                                   
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))                
4001c3f0:	7f ff de ad 	call  40013ea4 <rtems_rfs_trace>               
4001c3f4:	92 10 20 80 	mov  0x80, %o1                                 
4001c3f8:	80 8a 20 ff 	btst  0xff, %o0                                
4001c3fc:	12 80 00 0a 	bne  4001c424 <rtems_rfs_scan_chain+0x10c>     <== NEVER TAKEN
4001c400:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    
    printf (": not found\n");                                         
                                                                      
  return NULL;                                                        
}                                                                     
4001c404:	81 c7 e0 08 	ret                                            
4001c408:	91 e8 20 00 	restore  %g0, 0, %o0                           
  rtems_chain_node* node;                                             
                                                                      
  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);
4001c40c:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
4001c410:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
4001c414:	40 00 1e da 	call  40023f7c <printf>                        <== NOT EXECUTED
4001c418:	90 12 21 28 	or  %o0, 0x128, %o0	! 40036d28 <CSWTCH.2+0x138><== NOT EXECUTED
  while (!rtems_chain_is_head (chain, node))                          
  {                                                                   
    buffer = (rtems_rfs_buffer*) node;                                
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))              
      printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));            
4001c41c:	10 bf ff c8 	b  4001c33c <rtems_rfs_scan_chain+0x24>        <== NOT EXECUTED
4001c420:	39 10 00 db 	sethi  %hi(0x40036c00), %i4                    <== NOT EXECUTED
  }                                                                   
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))                
    printf (": not found\n");                                         
                                                                      
  return NULL;                                                        
4001c424:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
    }                                                                 
    node = rtems_chain_previous (node);                               
  }                                                                   
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))                
    printf (": not found\n");                                         
4001c428:	40 00 1f 6d 	call  400241dc <puts>                          <== NOT EXECUTED
4001c42c:	90 12 21 78 	or  %o0, 0x178, %o0                            <== NOT EXECUTED
                                                                      
  return NULL;                                                        
}                                                                     
4001c430:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001c434:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4001aa08 <rtems_rfs_search_map_for_clear_bit.constprop.1>: return 0; } static int rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
4001aa08:	9d e3 bf 90 	save  %sp, -112, %sp                           
  *found = false;                                                     
                                                                      
  /*                                                                  
   * Load the bitmap.                                                 
   */                                                                 
  rc = rtems_rfs_bitmap_load_map (control, &map);                     
4001aa0c:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
  return 0;                                                           
}                                                                     
                                                                      
static int                                                            
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
4001aa10:	ac 10 00 18 	mov  %i0, %l6                                  
  rtems_rfs_bitmap_element* map_bits;                                 
  int                       map_index;                                
  int                       map_offset;                               
  int                       rc;                                       
                                                                      
  *found = false;                                                     
4001aa14:	c0 2e 80 00 	clrb  [ %i2 ]                                  
                                                                      
  /*                                                                  
   * Load the bitmap.                                                 
   */                                                                 
  rc = rtems_rfs_bitmap_load_map (control, &map);                     
4001aa18:	7f ff ff e7 	call  4001a9b4 <rtems_rfs_bitmap_load_map>     
4001aa1c:	92 07 bf fc 	add  %fp, -4, %o1                              
  if (rc > 0)                                                         
4001aa20:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001aa24:	24 80 00 04 	ble,a   4001aa34 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x2c><== ALWAYS TAKEN
4001aa28:	f8 06 40 00 	ld  [ %i1 ], %i4                               
  }                                                                   
  while (((direction < 0) && (test_bit >= end_bit))                   
         || ((direction > 0) && (test_bit <= end_bit)));              
                                                                      
  return 0;                                                           
}                                                                     
4001aa2c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001aa30:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Calculate the bit we are testing plus the end point we search over.
   */                                                                 
  test_bit = *bit;                                                    
  end_bit  = test_bit + (window * direction);                         
4001aa34:	a1 2e e0 0b 	sll  %i3, 0xb, %l0                             
                                                                      
  if (end_bit < 0)                                                    
4001aa38:	a0 84 00 1c 	addcc  %l0, %i4, %l0                           
4001aa3c:	2c 80 00 06 	bneg,a   4001aa54 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x4c>
4001aa40:	a0 10 20 00 	clr  %l0                                       
    end_bit = 0;                                                      
  else if (end_bit >= control->size)                                  
4001aa44:	c2 05 a0 0c 	ld  [ %l6 + 0xc ], %g1                         
4001aa48:	80 a4 00 01 	cmp  %l0, %g1                                  
4001aa4c:	3a 80 00 02 	bcc,a   4001aa54 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x4c>
4001aa50:	a0 00 7f ff 	add  %g1, -1, %l0                              
  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];                  
4001aa54:	ee 05 a0 14 	ld  [ %l6 + 0x14 ], %l7                        
  map_bits    = &map[map_index];                                      
4001aa58:	e6 07 bf fc 	ld  [ %fp + -4 ], %l3                          
  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);              
4001aa5c:	a5 3f 20 05 	sra  %i4, 5, %l2                               
  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];                  
  map_bits    = &map[map_index];                                      
4001aa60:	83 2c a0 02 	sll  %l2, 2, %g1                               
  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);             
  search_index  = rtems_rfs_bitmap_map_index (map_index);             
4001aa64:	85 3f 20 0a 	sra  %i4, 0xa, %g2                             
                                                                      
        test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
                                                                      
        search_offset += direction;                                   
                                                                      
        if (((direction < 0) && (test_bit <= end_bit))                
4001aa68:	ab 36 e0 1f 	srl  %i3, 0x1f, %l5                            
  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];                  
4001aa6c:	85 28 a0 02 	sll  %g2, 2, %g2                               
        test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
                                                                      
        search_offset += direction;                                   
                                                                      
        if (((direction < 0) && (test_bit <= end_bit))                
            || ((direction > 0) && (test_bit >= end_bit)))            
4001aa70:	a9 3e e0 1f 	sra  %i3, 0x1f, %l4                            
  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];                  
  map_bits    = &map[map_index];                                      
4001aa74:	a6 04 c0 01 	add  %l3, %g1, %l3                             
        test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
                                                                      
        search_offset += direction;                                   
                                                                      
        if (((direction < 0) && (test_bit <= end_bit))                
            || ((direction > 0) && (test_bit >= end_bit)))            
4001aa78:	a8 25 00 1b 	sub  %l4, %i3, %l4                             
                                                                      
        test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
                                                                      
        search_offset += direction;                                   
                                                                      
        if (((direction < 0) && (test_bit <= end_bit))                
4001aa7c:	82 0d 60 ff 	and  %l5, 0xff, %g1                            
    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);             
4001aa80:	ba 0f 20 1f 	and  %i4, 0x1f, %i5                            
  search_index  = rtems_rfs_bitmap_map_index (map_index);             
  search_offset = rtems_rfs_bitmap_map_offset (map_index);            
4001aa84:	92 0c a0 1f 	and  %l2, 0x1f, %o1                            
                                                                      
  search_bits = &control->search_bits[search_index];                  
4001aa88:	ae 05 c0 02 	add  %l7, %g2, %l7                             
            map_offset += direction;                                  
            test_bit   += direction;                                  
          }                                                           
        }                                                             
                                                                      
        map_bits  += direction;                                       
4001aa8c:	b1 2e e0 02 	sll  %i3, 2, %i0                               
                                                                      
  return 0;                                                           
}                                                                     
                                                                      
static int                                                            
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
4001aa90:	97 2e e0 05 	sll  %i3, 5, %o3                               
 */                                                                   
static bool                                                           
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,               
                       rtems_rfs_bitmap_bit     bit)                  
{                                                                     
  return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);                     
4001aa94:	a2 10 20 01 	mov  1, %l1                                    
                                                                      
        test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
                                                                      
        search_offset += direction;                                   
                                                                      
        if (((direction < 0) && (test_bit <= end_bit))                
4001aa98:	c2 27 bf f4 	st  %g1, [ %fp + -12 ]                         
            || ((direction > 0) && (test_bit >= end_bit)))            
4001aa9c:	a9 35 20 1f 	srl  %l4, 0x1f, %l4                            
    /*                                                                
     * 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))
4001aaa0:	c8 05 c0 00 	ld  [ %l7 ], %g4                               
4001aaa4:	80 a1 20 00 	cmp  %g4, 0                                    
4001aaa8:	02 80 00 49 	be  4001abcc <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1c4>
4001aaac:	80 a6 e0 00 	cmp  %i3, 0                                    
                                                                      
  return 0;                                                           
}                                                                     
                                                                      
static int                                                            
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
4001aab0:	86 06 c0 12 	add  %i3, %l2, %g3                             
4001aab4:	87 28 e0 05 	sll  %g3, 5, %g3                               
     * 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)                                     
4001aab8:	80 a2 60 1f 	cmp  %o1, 0x1f                                 
4001aabc:	18 80 00 52 	bgu  4001ac04 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1fc>
4001aac0:	9f 2c 40 09 	sll  %l1, %o1, %o7                             
             && (search_offset < rtems_rfs_bitmap_element_bits ()))   
      {                                                               
        if (!rtems_rfs_bitmap_test (*search_bits, search_offset))     
4001aac4:	80 8b c0 04 	btst  %o7, %g4                                 
4001aac8:	22 80 00 13 	be,a   4001ab14 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x10c>
4001aacc:	a6 04 c0 18 	add  %l3, %i0, %l3                             
           * 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))       
4001aad0:	c4 04 c0 00 	ld  [ %l3 ], %g2                               
 */                                                                   
static bool                                                           
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,               
                       rtems_rfs_bitmap_bit     bit)                  
{                                                                     
  return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);                     
4001aad4:	83 2c 40 1d 	sll  %l1, %i5, %g1                             
           * 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))       
4001aad8:	80 88 40 02 	btst  %g1, %g2                                 
4001aadc:	02 80 00 0b 	be  4001ab08 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x100>
4001aae0:	80 a4 00 1c 	cmp  %l0, %i4                                  
 */                                                                   
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);                    
4001aae4:	10 80 00 55 	b  4001ac38 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x230>
4001aae8:	82 28 80 01 	andn  %g2, %g1, %g1                            
        {                                                             
          /*                                                          
           * 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)                                    
4001aaec:	80 a7 60 1f 	cmp  %i5, 0x1f                                 
4001aaf0:	18 80 00 08 	bgu  4001ab10 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x108><== NEVER TAKEN
4001aaf4:	b8 07 00 1b 	add  %i4, %i3, %i4                             
 */                                                                   
static bool                                                           
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,               
                       rtems_rfs_bitmap_bit     bit)                  
{                                                                     
  return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);                     
4001aaf8:	83 2c 40 1d 	sll  %l1, %i5, %g1                             
           * 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))       
4001aafc:	80 88 80 01 	btst  %g2, %g1                                 
4001ab00:	12 80 00 4d 	bne  4001ac34 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x22c>
4001ab04:	80 a4 00 1c 	cmp  %l0, %i4                                  
              *found = true;                                          
              rtems_rfs_buffer_mark_dirty (control->buffer);          
              return 0;                                               
            }                                                         
                                                                      
            if (test_bit == end_bit)                                  
4001ab08:	32 bf ff f9 	bne,a   4001aaec <rtems_rfs_search_map_for_clear_bit.constprop.1+0xe4>
4001ab0c:	ba 07 40 1b 	add  %i5, %i3, %i5                             
            map_offset += direction;                                  
            test_bit   += direction;                                  
          }                                                           
        }                                                             
                                                                      
        map_bits  += direction;                                       
4001ab10:	a6 04 c0 18 	add  %l3, %i0, %l3                             
        map_index += direction;                                       
        map_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
4001ab14:	80 a6 e0 00 	cmp  %i3, 0                                    
4001ab18:	04 80 00 44 	ble  4001ac28 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x220>
4001ab1c:	a4 04 80 1b 	add  %l2, %i3, %l2                             
4001ab20:	b8 10 20 00 	clr  %i4                                       
4001ab24:	ba 10 20 00 	clr  %i5                                       
                                                                      
        test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
4001ab28:	b8 00 c0 1c 	add  %g3, %i4, %i4                             
                                                                      
        search_offset += direction;                                   
4001ab2c:	92 02 40 1b 	add  %o1, %i3, %o1                             
                                                                      
        if (((direction < 0) && (test_bit <= end_bit))                
4001ab30:	84 10 00 15 	mov  %l5, %g2                                  
4001ab34:	80 a4 00 1c 	cmp  %l0, %i4                                  
4001ab38:	16 80 00 03 	bge  4001ab44 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x13c>
4001ab3c:	82 10 20 01 	mov  1, %g1                                    
4001ab40:	82 10 20 00 	clr  %g1                                       
4001ab44:	80 88 60 ff 	btst  0xff, %g1                                
4001ab48:	32 80 00 5b 	bne,a   4001acb4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x2ac>
4001ab4c:	c2 07 bf f4 	ld  [ %fp + -12 ], %g1                         
4001ab50:	86 00 c0 0b 	add  %g3, %o3, %g3                             
            || ((direction > 0) && (test_bit >= end_bit)))            
4001ab54:	80 a4 00 1c 	cmp  %l0, %i4                                  
4001ab58:	04 80 00 03 	ble  4001ab64 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x15c>
4001ab5c:	82 10 20 01 	mov  1, %g1                                    
4001ab60:	82 10 20 00 	clr  %g1                                       
4001ab64:	80 88 60 ff 	btst  0xff, %g1                                
4001ab68:	02 bf ff d5 	be  4001aabc <rtems_rfs_search_map_for_clear_bit.constprop.1+0xb4>
4001ab6c:	80 a2 60 1f 	cmp  %o1, 0x1f                                 
4001ab70:	80 a5 20 00 	cmp  %l4, 0                                    
4001ab74:	02 bf ff d2 	be  4001aabc <rtems_rfs_search_map_for_clear_bit.constprop.1+0xb4>
4001ab78:	80 a2 60 1f 	cmp  %o1, 0x1f                                 
      }                                                               
      map_bits += direction * bits_skipped;                           
      map_index += direction * bits_skipped;                          
    }                                                                 
                                                                      
    search_bits  += direction;                                        
4001ab7c:	ae 05 c0 18 	add  %l7, %i0, %l7                             
        test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
                                                                      
        search_offset += direction;                                   
                                                                      
        if (((direction < 0) && (test_bit <= end_bit))                
            || ((direction > 0) && (test_bit >= end_bit)))            
4001ab80:	82 10 20 01 	mov  1, %g1                                    
      map_bits += direction * bits_skipped;                           
      map_index += direction * bits_skipped;                          
    }                                                                 
                                                                      
    search_bits  += direction;                                        
    search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
4001ab84:	92 10 20 00 	clr  %o1                                       
  }                                                                   
  while (((direction < 0) && (test_bit >= end_bit))                   
         || ((direction > 0) && (test_bit <= end_bit)));              
4001ab88:	80 88 60 ff 	btst  0xff, %g1                                
4001ab8c:	02 80 00 06 	be  4001aba4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x19c>
4001ab90:	80 a4 00 1c 	cmp  %l0, %i4                                  
4001ab94:	80 88 a0 ff 	btst  0xff, %g2                                
4001ab98:	32 bf ff c3 	bne,a   4001aaa4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x9c>
4001ab9c:	c8 05 c0 00 	ld  [ %l7 ], %g4                               
4001aba0:	80 a4 00 1c 	cmp  %l0, %i4                                  
4001aba4:	16 80 00 03 	bge  4001abb0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1a8>
4001aba8:	82 10 20 01 	mov  1, %g1                                    
4001abac:	82 10 20 00 	clr  %g1                                       
4001abb0:	80 88 60 ff 	btst  0xff, %g1                                
4001abb4:	02 80 00 04 	be  4001abc4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1bc>
4001abb8:	80 a5 20 00 	cmp  %l4, 0                                    
4001abbc:	32 bf ff ba 	bne,a   4001aaa4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x9c>
4001abc0:	c8 05 c0 00 	ld  [ %l7 ], %g4                               
                                                                      
  return 0;                                                           
4001abc4:	81 c7 e0 08 	ret                                            
4001abc8:	91 e8 20 00 	restore  %g0, 0, %o0                           
       * 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)                                              
4001abcc:	04 80 00 34 	ble  4001ac9c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x294>
4001abd0:	b8 0f 3f e0 	and  %i4, -32, %i4                             
      {                                                               
        bits_skipped = rtems_rfs_bitmap_element_bits () - search_offset;
4001abd4:	82 10 20 20 	mov  0x20, %g1                                 
        test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();  
        map_offset = 0;                                               
4001abd8:	ba 10 20 00 	clr  %i5                                       
       */                                                             
      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;
4001abdc:	92 20 40 09 	sub  %g1, %o1, %o1                             
        test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();  
4001abe0:	83 2a 60 05 	sll  %o1, 5, %g1                               
4001abe4:	b8 00 40 1c 	add  %g1, %i4, %i4                             
         * 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;                           
4001abe8:	d6 27 bf f0 	st  %o3, [ %fp + -16 ]                         
4001abec:	7f ff 9e 73 	call  400025b8 <.umul>                         
4001abf0:	90 10 00 1b 	mov  %i3, %o0                                  
4001abf4:	d6 07 bf f0 	ld  [ %fp + -16 ], %o3                         
4001abf8:	83 2a 20 02 	sll  %o0, 2, %g1                               
      map_index += direction * bits_skipped;                          
4001abfc:	a4 04 80 08 	add  %l2, %o0, %l2                             
         * 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;                           
4001ac00:	a6 04 c0 01 	add  %l3, %g1, %l3                             
      map_index += direction * bits_skipped;                          
    }                                                                 
                                                                      
    search_bits  += direction;                                        
    search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
4001ac04:	80 a6 e0 00 	cmp  %i3, 0                                    
4001ac08:	04 80 00 1c 	ble  4001ac78 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x270>
4001ac0c:	ae 05 c0 18 	add  %l7, %i0, %l7                             
4001ac10:	80 a4 00 1c 	cmp  %l0, %i4                                  
4001ac14:	04 80 00 03 	ble  4001ac20 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x218>
4001ac18:	82 10 20 01 	mov  1, %g1                                    
4001ac1c:	82 10 20 00 	clr  %g1                                       
4001ac20:	10 bf ff d9 	b  4001ab84 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x17c>
4001ac24:	84 10 20 00 	clr  %g2                                       
          }                                                           
        }                                                             
                                                                      
        map_bits  += direction;                                       
        map_index += direction;                                       
        map_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
4001ac28:	b8 10 20 1f 	mov  0x1f, %i4                                 
4001ac2c:	10 bf ff bf 	b  4001ab28 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x120>
4001ac30:	ba 10 20 1f 	mov  0x1f, %i5                                 
 */                                                                   
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);                    
4001ac34:	82 28 80 01 	andn  %g2, %g1, %g1                            
                 && (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);
              if (rtems_rfs_bitmap_match(*map_bits,                   
4001ac38:	80 a0 60 00 	cmp  %g1, 0                                    
4001ac3c:	12 80 00 05 	bne  4001ac50 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x248>
4001ac40:	c2 24 c0 00 	st  %g1, [ %l3 ]                               
 */                                                                   
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);                    
4001ac44:	c2 05 c0 00 	ld  [ %l7 ], %g1                               
4001ac48:	9e 28 40 0f 	andn  %g1, %o7, %o7                            
            if (!rtems_rfs_bitmap_test (*map_bits, map_offset))       
            {                                                         
              *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,    
4001ac4c:	de 25 c0 00 	st  %o7, [ %l7 ]                               
                                                     1 << search_offset);
              control->free--;                                        
4001ac50:	c2 05 a0 10 	ld  [ %l6 + 0x10 ], %g1                        
              *bit = test_bit;                                        
              *found = true;                                          
              rtems_rfs_buffer_mark_dirty (control->buffer);          
4001ac54:	c4 05 80 00 	ld  [ %l6 ], %g2                               
              *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--;                                        
4001ac58:	82 00 7f ff 	add  %g1, -1, %g1                              
4001ac5c:	c2 25 a0 10 	st  %g1, [ %l6 + 0x10 ]                        
              *bit = test_bit;                                        
4001ac60:	f8 26 40 00 	st  %i4, [ %i1 ]                               
              *found = true;                                          
4001ac64:	82 10 20 01 	mov  1, %g1                                    
4001ac68:	c2 2e 80 00 	stb  %g1, [ %i2 ]                              
              rtems_rfs_buffer_mark_dirty (control->buffer);          
4001ac6c:	c2 28 80 00 	stb  %g1, [ %g2 ]                              
              return 0;                                               
4001ac70:	81 c7 e0 08 	ret                                            
4001ac74:	91 e8 20 00 	restore  %g0, 0, %o0                           
4001ac78:	84 10 00 15 	mov  %l5, %g2                                  
4001ac7c:	80 a4 00 1c 	cmp  %l0, %i4                                  
4001ac80:	14 80 00 04 	bg  4001ac90 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x288>
4001ac84:	82 10 20 01 	mov  1, %g1                                    
      map_bits += direction * bits_skipped;                           
      map_index += direction * bits_skipped;                          
    }                                                                 
                                                                      
    search_bits  += direction;                                        
    search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
4001ac88:	10 bf ff c0 	b  4001ab88 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x180>
4001ac8c:	92 10 20 1f 	mov  0x1f, %o1                                 
4001ac90:	82 10 20 00 	clr  %g1                                       
4001ac94:	10 bf ff bd 	b  4001ab88 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x180>
4001ac98:	92 10 20 1f 	mov  0x1f, %o1                                 
        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;
4001ac9c:	83 2a 60 05 	sll  %o1, 5, %g1                               
        map_offset = rtems_rfs_bitmap_element_bits () - 1;            
4001aca0:	ba 10 20 1f 	mov  0x1f, %i5                                 
        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;
4001aca4:	82 38 00 01 	xnor  %g0, %g1, %g1                            
        test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();  
        map_offset = 0;                                               
      }                                                               
      else                                                            
      {                                                               
        bits_skipped = search_offset + 1;                             
4001aca8:	92 02 60 01 	inc  %o1                                       
        /*                                                            
         * 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;
4001acac:	10 bf ff cf 	b  4001abe8 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1e0>
4001acb0:	b8 00 40 1c 	add  %g1, %i4, %i4                             
                                                                      
        test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
                                                                      
        search_offset += direction;                                   
                                                                      
        if (((direction < 0) && (test_bit <= end_bit))                
4001acb4:	80 a0 60 00 	cmp  %g1, 0                                    
4001acb8:	22 bf ff a7 	be,a   4001ab54 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x14c>
4001acbc:	86 00 c0 0b 	add  %g3, %o3, %g3                             
      }                                                               
      map_bits += direction * bits_skipped;                           
      map_index += direction * bits_skipped;                          
    }                                                                 
                                                                      
    search_bits  += direction;                                        
4001acc0:	ae 05 c0 18 	add  %l7, %i0, %l7                             
4001acc4:	80 a4 00 1c 	cmp  %l0, %i4                                  
4001acc8:	04 80 00 03 	ble  4001acd4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x2cc><== NEVER TAKEN
4001accc:	82 10 20 01 	mov  1, %g1                                    
4001acd0:	82 10 20 00 	clr  %g1                                       
                                                                      
        test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
                                                                      
        search_offset += direction;                                   
                                                                      
        if (((direction < 0) && (test_bit <= end_bit))                
4001acd4:	84 10 20 01 	mov  1, %g2                                    
      map_bits += direction * bits_skipped;                           
      map_index += direction * bits_skipped;                          
    }                                                                 
                                                                      
    search_bits  += direction;                                        
    search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
4001acd8:	10 bf ff ac 	b  4001ab88 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x180>
4001acdc:	92 10 20 1f 	mov  0x1f, %o1                                 
                                                                      

40020198 <rtems_rfs_symlink>: const char* link, int link_length, uid_t uid, gid_t gid, rtems_rfs_ino parent) {
40020198:	9d e3 bf 00 	save  %sp, -256, %sp                           
  rtems_rfs_inode_handle inode;                                       
  rtems_rfs_ino          ino;                                         
  int                    rc;                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))                      
4002019c:	90 10 20 02 	mov  2, %o0                                    
                   const char*            link,                       
                   int                    link_length,                
                   uid_t                  uid,                        
                   gid_t                  gid,                        
                   rtems_rfs_ino          parent)                     
{                                                                     
400201a0:	e4 17 a0 5e 	lduh  [ %fp + 0x5e ], %l2                      
  rtems_rfs_inode_handle inode;                                       
  rtems_rfs_ino          ino;                                         
  int                    rc;                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))                      
400201a4:	7f ff cf 40 	call  40013ea4 <rtems_rfs_trace>               
400201a8:	92 10 20 00 	clr  %o1                                       
400201ac:	80 8a 20 ff 	btst  0xff, %o0                                
400201b0:	32 80 00 08 	bne,a   400201d0 <rtems_rfs_symlink+0x38>      <== NEVER TAKEN
400201b4:	d2 07 a0 60 	ld  [ %fp + 0x60 ], %o1                        <== NOT EXECUTED
    printf (" link:");                                                
    for (c = 0; c < link_length; c++)                                 
      printf ("%c", link[c]);                                         
  }                                                                   
                                                                      
  if (link_length >= rtems_rfs_fs_block_size (fs))                    
400201b8:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
400201bc:	80 a7 00 01 	cmp  %i4, %g1                                  
400201c0:	0a 80 00 22 	bcs  40020248 <rtems_rfs_symlink+0xb0>         <== ALWAYS TAKEN
400201c4:	b4 10 20 5b 	mov  0x5b, %i2                                 
  rtems_rfs_inode_set_block_offset (&inode, link_length);             
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
                                                                      
  return rc;                                                          
}                                                                     
400201c8:	81 c7 e0 08 	ret                                            
400201cc:	91 e8 00 1a 	restore  %g0, %i2, %o0                         
  int                    rc;                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))                      
  {                                                                   
    int c;                                                            
    printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);  
400201d0:	11 10 00 e0 	sethi  %hi(0x40038000), %o0                    <== NOT EXECUTED
400201d4:	40 00 0f 6a 	call  40023f7c <printf>                        <== NOT EXECUTED
400201d8:	90 12 21 f8 	or  %o0, 0x1f8, %o0	! 400381f8 <CSWTCH.2+0x1608><== NOT EXECUTED
400201dc:	a0 10 00 19 	mov  %i1, %l0                                  <== NOT EXECUTED
    for (c = 0; c < length; c++)                                      
400201e0:	80 a6 a0 00 	cmp  %i2, 0                                    <== NOT EXECUTED
400201e4:	04 80 00 08 	ble  40020204 <rtems_rfs_symlink+0x6c>         <== NOT EXECUTED
400201e8:	a2 06 40 1a 	add  %i1, %i2, %l1                             <== NOT EXECUTED
      printf ("%c", name[c]);                                         
400201ec:	d0 4c 00 00 	ldsb  [ %l0 ], %o0                             <== NOT EXECUTED
400201f0:	40 00 0f cd 	call  40024124 <putchar>                       <== NOT EXECUTED
400201f4:	a0 04 20 01 	inc  %l0                                       <== NOT EXECUTED
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))                      
  {                                                                   
    int c;                                                            
    printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);  
    for (c = 0; c < length; c++)                                      
400201f8:	80 a4 00 11 	cmp  %l0, %l1                                  <== NOT EXECUTED
400201fc:	32 bf ff fd 	bne,a   400201f0 <rtems_rfs_symlink+0x58>      <== NOT EXECUTED
40020200:	d0 4c 00 00 	ldsb  [ %l0 ], %o0                             <== NOT EXECUTED
      printf ("%c", name[c]);                                         
    printf (" link:");                                                
40020204:	11 10 00 e0 	sethi  %hi(0x40038000), %o0                    <== NOT EXECUTED
40020208:	40 00 0f 5d 	call  40023f7c <printf>                        <== NOT EXECUTED
4002020c:	90 12 22 20 	or  %o0, 0x220, %o0	! 40038220 <CSWTCH.2+0x1630><== NOT EXECUTED
40020210:	b4 10 00 1b 	mov  %i3, %i2                                  <== NOT EXECUTED
    for (c = 0; c < link_length; c++)                                 
40020214:	80 a7 20 00 	cmp  %i4, 0                                    <== NOT EXECUTED
40020218:	04 bf ff e8 	ble  400201b8 <rtems_rfs_symlink+0x20>         <== NOT EXECUTED
4002021c:	a0 07 00 1b 	add  %i4, %i3, %l0                             <== NOT EXECUTED
      printf ("%c", link[c]);                                         
40020220:	d0 4e 80 00 	ldsb  [ %i2 ], %o0                             <== NOT EXECUTED
40020224:	40 00 0f c0 	call  40024124 <putchar>                       <== NOT EXECUTED
40020228:	b4 06 a0 01 	inc  %i2                                       <== NOT EXECUTED
    int c;                                                            
    printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);  
    for (c = 0; c < length; c++)                                      
      printf ("%c", name[c]);                                         
    printf (" link:");                                                
    for (c = 0; c < link_length; c++)                                 
4002022c:	80 a6 80 10 	cmp  %i2, %l0                                  <== NOT EXECUTED
40020230:	32 bf ff fd 	bne,a   40020224 <rtems_rfs_symlink+0x8c>      <== NOT EXECUTED
40020234:	d0 4e 80 00 	ldsb  [ %i2 ], %o0                             <== NOT EXECUTED
      printf ("%c", link[c]);                                         
  }                                                                   
                                                                      
  if (link_length >= rtems_rfs_fs_block_size (fs))                    
40020238:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           <== NOT EXECUTED
4002023c:	80 a7 00 01 	cmp  %i4, %g1                                  <== NOT EXECUTED
40020240:	1a bf ff e2 	bcc  400201c8 <rtems_rfs_symlink+0x30>         <== NOT EXECUTED
40020244:	b4 10 20 5b 	mov  0x5b, %i2                                 <== NOT EXECUTED
    return ENAMETOOLONG;                                              
                                                                      
  rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),       
40020248:	40 00 13 be 	call  40025140 <strlen>                        
4002024c:	90 10 00 19 	mov  %i1, %o0                                  
40020250:	d2 07 a0 60 	ld  [ %fp + 0x60 ], %o1                        
40020254:	82 07 bf 74 	add  %fp, -140, %g1                            
40020258:	96 10 00 08 	mov  %o0, %o3                                  
4002025c:	fa 23 a0 5c 	st  %i5, [ %sp + 0x5c ]                        
40020260:	e4 23 a0 60 	st  %l2, [ %sp + 0x60 ]                        
40020264:	90 10 00 18 	mov  %i0, %o0                                  
40020268:	c2 23 a0 64 	st  %g1, [ %sp + 0x64 ]                        
4002026c:	94 10 00 19 	mov  %i1, %o2                                  
40020270:	9a 10 20 01 	mov  1, %o5                                    
40020274:	19 00 00 28 	sethi  %hi(0xa000), %o4                        
40020278:	7f ff c9 b6 	call  40012950 <rtems_rfs_inode_create>        
4002027c:	98 13 21 ff 	or  %o4, 0x1ff, %o4	! a1ff <PROM_START+0xa1ff> 
                               RTEMS_RFS_S_SYMLINK,                   
                               1, uid, gid, &ino);                    
  if (rc > 0)                                                         
40020280:	b4 92 20 00 	orcc  %o0, 0, %i2                              
40020284:	14 bf ff d1 	bg  400201c8 <rtems_rfs_symlink+0x30>          <== NEVER TAKEN
40020288:	d2 07 bf 74 	ld  [ %fp + -140 ], %o1                        
    return rc;                                                        
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
4002028c:	90 10 00 18 	mov  %i0, %o0                                  
40020290:	94 07 bf 88 	add  %fp, -120, %o2                            
40020294:	7f ff c8 5d 	call  40012408 <rtems_rfs_inode_open>          
40020298:	96 10 20 01 	mov  1, %o3                                    
  if (rc > 0)                                                         
4002029c:	b4 92 20 00 	orcc  %o0, 0, %i2                              
400202a0:	14 bf ff ca 	bg  400201c8 <rtems_rfs_symlink+0x30>          <== NEVER TAKEN
400202a4:	80 a7 20 13 	cmp  %i4, 0x13                                 
  /*                                                                  
   * 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)                   
400202a8:	38 80 00 20 	bgu,a   40020328 <rtems_rfs_symlink+0x190>     <== NEVER TAKEN
400202ac:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
  {                                                                   
    memset (inode.node->data.name, 0, RTEMS_RFS_INODE_DATA_NAME_SIZE);
400202b0:	d0 07 bf 94 	ld  [ %fp + -108 ], %o0                        
400202b4:	92 10 20 00 	clr  %o1                                       
400202b8:	94 10 20 14 	mov  0x14, %o2                                 
400202bc:	40 00 0e b2 	call  40023d84 <memset>                        
400202c0:	90 02 20 1c 	add  %o0, 0x1c, %o0                            
    memcpy (inode.node->data.name, link, link_length);                
400202c4:	d0 07 bf 94 	ld  [ %fp + -108 ], %o0                        
400202c8:	92 10 00 1b 	mov  %i3, %o1                                  
400202cc:	90 02 20 1c 	add  %o0, 0x1c, %o0                            
400202d0:	40 00 0e 1e 	call  40023b48 <memcpy>                        
400202d4:	94 10 00 1c 	mov  %i4, %o2                                  
 * @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);      
400202d8:	c2 07 bf 94 	ld  [ %fp + -108 ], %g1                        
400202dc:	c0 28 60 0c 	clrb  [ %g1 + 0xc ]                            
400202e0:	c2 07 bf 94 	ld  [ %fp + -108 ], %g1                        
400202e4:	c0 28 60 0d 	clrb  [ %g1 + 0xd ]                            
400202e8:	c2 07 bf 94 	ld  [ %fp + -108 ], %g1                        
400202ec:	c0 28 60 0e 	clrb  [ %g1 + 0xe ]                            
400202f0:	c2 07 bf 94 	ld  [ %fp + -108 ], %g1                        
400202f4:	c0 28 60 0f 	clrb  [ %g1 + 0xf ]                            
 */                                                                   
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);    
400202f8:	c2 07 bf 94 	ld  [ %fp + -108 ], %g1                        
400202fc:	85 37 20 08 	srl  %i4, 8, %g2                               
40020300:	c4 28 60 0a 	stb  %g2, [ %g1 + 0xa ]                        
40020304:	c2 07 bf 94 	ld  [ %fp + -108 ], %g1                        
    }                                                                 
  }                                                                   
                                                                      
  rtems_rfs_inode_set_block_offset (&inode, link_length);             
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
40020308:	90 10 00 18 	mov  %i0, %o0                                  
4002030c:	f8 28 60 0b 	stb  %i4, [ %g1 + 0xb ]                        
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
40020310:	82 10 20 01 	mov  1, %g1                                    
40020314:	92 07 bf 88 	add  %fp, -120, %o1                            
40020318:	7f ff c8 b4 	call  400125e8 <rtems_rfs_inode_close>         
4002031c:	c2 2f bf 98 	stb  %g1, [ %fp + -104 ]                       
40020320:	10 bf ff aa 	b  400201c8 <rtems_rfs_symlink+0x30>           
40020324:	b4 10 00 08 	mov  %o0, %i2                                  
    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);                 
40020328:	92 07 bf 88 	add  %fp, -120, %o1                            <== NOT EXECUTED
4002032c:	7f ff ec b9 	call  4001b610 <rtems_rfs_block_map_open>      <== NOT EXECUTED
40020330:	94 07 bf b0 	add  %fp, -80, %o2                             <== NOT EXECUTED
40020334:	b4 10 00 08 	mov  %o0, %i2                                  <== NOT EXECUTED
    if (rc > 0)                                                       
40020338:	80 a6 a0 00 	cmp  %i2, 0                                    <== NOT EXECUTED
4002033c:	04 80 00 05 	ble  40020350 <rtems_rfs_symlink+0x1b8>        <== NOT EXECUTED
40020340:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false); 
    if (rc > 0)                                                       
    {                                                                 
      rtems_rfs_block_map_close (fs, &map);                           
      rtems_rfs_inode_close (fs, &inode);                             
40020344:	7f ff c8 a9 	call  400125e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
40020348:	92 07 bf 88 	add  %fp, -120, %o1                            <== NOT EXECUTED
4002034c:	30 bf ff 9f 	b,a   400201c8 <rtems_rfs_symlink+0x30>        <== NOT EXECUTED
    {                                                                 
      rtems_rfs_inode_close (fs, &inode);                             
      return rc;                                                      
    }                                                                 
                                                                      
    rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);              
40020350:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
40020354:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
40020358:	7f ff ee 07 	call  4001bb74 <rtems_rfs_block_map_grow>      <== NOT EXECUTED
4002035c:	96 07 bf 78 	add  %fp, -136, %o3                            <== NOT EXECUTED
    if (rc > 0)                                                       
40020360:	b4 92 20 00 	orcc  %o0, 0, %i2                              <== NOT EXECUTED
40020364:	04 80 00 07 	ble  40020380 <rtems_rfs_symlink+0x1e8>        <== NOT EXECUTED
40020368:	d4 07 bf 78 	ld  [ %fp + -136 ], %o2                        <== NOT EXECUTED
    }                                                                 
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false); 
    if (rc > 0)                                                       
    {                                                                 
      rtems_rfs_block_map_close (fs, &map);                           
4002036c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40020370:	7f ff ed 09 	call  4001b794 <rtems_rfs_block_map_close>     <== NOT EXECUTED
40020374:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
      rtems_rfs_inode_close (fs, &inode);                             
40020378:	10 bf ff f3 	b  40020344 <rtems_rfs_symlink+0x1ac>          <== NOT EXECUTED
4002037c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
40020380:	c0 2f bf 7c 	clrb  [ %fp + -132 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
40020384:	c0 27 bf 80 	clr  [ %fp + -128 ]                            <== NOT EXECUTED
  handle->buffer = NULL;                                              
40020388:	c0 27 bf 84 	clr  [ %fp + -124 ]                            <== 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); 
4002038c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40020390:	92 07 bf 7c 	add  %fp, -132, %o1                            <== NOT EXECUTED
40020394:	7f ff f0 a3 	call  4001c620 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
40020398:	96 10 20 00 	clr  %o3                                       <== NOT EXECUTED
    if (rc > 0)                                                       
4002039c:	b4 92 20 00 	orcc  %o0, 0, %i2                              <== NOT EXECUTED
400203a0:	14 bf ff f4 	bg  40020370 <rtems_rfs_symlink+0x1d8>         <== NOT EXECUTED
400203a4:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
      rtems_rfs_block_map_close (fs, &map);                           
      rtems_rfs_inode_close (fs, &inode);                             
      return rc;                                                      
    }                                                                 
                                                                      
    data = rtems_rfs_buffer_data (&buffer);                           
400203a8:	c2 07 bf 84 	ld  [ %fp + -124 ], %g1                        <== NOT EXECUTED
                                                                      
    memset (data, 0xff, rtems_rfs_fs_block_size (fs));                
400203ac:	d4 06 20 08 	ld  [ %i0 + 8 ], %o2                           <== NOT EXECUTED
      rtems_rfs_block_map_close (fs, &map);                           
      rtems_rfs_inode_close (fs, &inode);                             
      return rc;                                                      
    }                                                                 
                                                                      
    data = rtems_rfs_buffer_data (&buffer);                           
400203b0:	fa 00 60 1c 	ld  [ %g1 + 0x1c ], %i5                        <== NOT EXECUTED
                                                                      
    memset (data, 0xff, rtems_rfs_fs_block_size (fs));                
400203b4:	92 10 20 ff 	mov  0xff, %o1                                 <== NOT EXECUTED
400203b8:	40 00 0e 73 	call  40023d84 <memset>                        <== NOT EXECUTED
400203bc:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
    memcpy (data, link, link_length);                                 
400203c0:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
400203c4:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
400203c8:	40 00 0d e0 	call  40023b48 <memcpy>                        <== NOT EXECUTED
400203cc:	90 10 00 1d 	mov  %i5, %o0                                  <== 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);                       
400203d0:	92 07 bf 7c 	add  %fp, -132, %o1                            <== NOT EXECUTED
400203d4:	7f ff f0 19 	call  4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
400203d8:	90 10 00 18 	mov  %i0, %o0                                  <== 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);                        
400203dc:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
400203e0:	c0 2f bf 7c 	clrb  [ %fp + -132 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
400203e4:	c0 27 bf 80 	clr  [ %fp + -128 ]                            <== NOT EXECUTED
  handle->buffer = NULL;                                              
400203e8:	c0 27 bf 84 	clr  [ %fp + -124 ]                            <== NOT EXECUTED
400203ec:	7f ff ec ea 	call  4001b794 <rtems_rfs_block_map_close>     <== NOT EXECUTED
400203f0:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
    if (rc > 0)                                                       
400203f4:	b4 92 20 00 	orcc  %o0, 0, %i2                              <== NOT EXECUTED
400203f8:	04 bf ff c0 	ble  400202f8 <rtems_rfs_symlink+0x160>        <== NOT EXECUTED
400203fc:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40020400:	30 bf ff d1 	b,a   40020344 <rtems_rfs_symlink+0x1ac>       <== NOT EXECUTED
                                                                      

40020404 <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) {
40020404:	9d e3 bf 18 	save  %sp, -232, %sp                           
  rtems_rfs_inode_handle inode;                                       
  int                    rc;                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))                 
40020408:	90 10 20 04 	mov  4, %o0                                    
4002040c:	7f ff ce a6 	call  40013ea4 <rtems_rfs_trace>               
40020410:	92 10 20 00 	clr  %o1                                       
40020414:	80 8a 20 ff 	btst  0xff, %o0                                
40020418:	12 80 00 17 	bne  40020474 <rtems_rfs_symlink_read+0x70>    <== NEVER TAKEN
4002041c:	92 10 00 19 	mov  %i1, %o1                                  
    printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);     
                                                                      
  rc = rtems_rfs_inode_open (fs, link, &inode, true);                 
40020420:	90 10 00 18 	mov  %i0, %o0                                  
40020424:	92 10 00 19 	mov  %i1, %o1                                  
40020428:	94 07 bf 88 	add  %fp, -120, %o2                            
4002042c:	7f ff c7 f7 	call  40012408 <rtems_rfs_inode_open>          
40020430:	96 10 20 01 	mov  1, %o3                                    
  if (rc)                                                             
40020434:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40020438:	12 80 00 0d 	bne  4002046c <rtems_rfs_symlink_read+0x68>    <== NEVER TAKEN
4002043c:	d2 07 bf 94 	ld  [ %fp + -108 ], %o1                        
    return rc;                                                        
                                                                      
  if (!RTEMS_RFS_S_ISLNK (rtems_rfs_inode_get_mode (&inode)))         
40020440:	03 00 00 3c 	sethi  %hi(0xf000), %g1                        
 * @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);                    
40020444:	c4 0a 60 02 	ldub  [ %o1 + 2 ], %g2                         
40020448:	85 28 a0 08 	sll  %g2, 8, %g2                               
4002044c:	84 08 80 01 	and  %g2, %g1, %g2                             
40020450:	03 00 00 28 	sethi  %hi(0xa000), %g1                        
40020454:	80 a0 80 01 	cmp  %g2, %g1                                  
40020458:	02 80 00 0c 	be  40020488 <rtems_rfs_symlink_read+0x84>     <== ALWAYS TAKEN
4002045c:	90 10 00 18 	mov  %i0, %o0                                  
  {                                                                   
    rtems_rfs_inode_close (fs, &inode);                               
40020460:	92 07 bf 88 	add  %fp, -120, %o1                            <== NOT EXECUTED
40020464:	7f ff c8 61 	call  400125e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
40020468:	ba 10 20 16 	mov  0x16, %i5                                 <== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
                                                                      
  return rc;                                                          
}                                                                     
4002046c:	81 c7 e0 08 	ret                                            
40020470:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
{                                                                     
  rtems_rfs_inode_handle inode;                                       
  int                    rc;                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))                 
    printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);     
40020474:	11 10 00 e0 	sethi  %hi(0x40038000), %o0                    <== NOT EXECUTED
40020478:	40 00 0e c1 	call  40023f7c <printf>                        <== NOT EXECUTED
4002047c:	90 12 22 28 	or  %o0, 0x228, %o0	! 40038228 <CSWTCH.2+0x1638><== NOT EXECUTED
                                                                      
  rc = rtems_rfs_inode_open (fs, link, &inode, true);                 
40020480:	10 bf ff e9 	b  40020424 <rtems_rfs_symlink_read+0x20>      <== NOT EXECUTED
40020484:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 * @return uint32_t The block offset.                                 
 */                                                                   
static inline uint16_t                                                
rtems_rfs_inode_get_block_offset (rtems_rfs_inode_handle* handle)     
{                                                                     
  return rtems_rfs_read_u16 (&handle->node->block_offset);            
40020488:	d4 0a 60 0a 	ldub  [ %o1 + 0xa ], %o2                       
  {                                                                   
    rtems_rfs_inode_close (fs, &inode);                               
    return EINVAL;                                                    
  }                                                                   
                                                                      
  *length = rtems_rfs_inode_get_block_offset (&inode);                
4002048c:	c2 0a 60 0b 	ldub  [ %o1 + 0xb ], %g1                       
40020490:	95 2a a0 08 	sll  %o2, 8, %o2                               
40020494:	94 10 40 0a 	or  %g1, %o2, %o2                              
40020498:	80 a2 80 1b 	cmp  %o2, %i3                                  
4002049c:	38 80 00 02 	bgu,a   400204a4 <rtems_rfs_symlink_read+0xa0> 
400204a0:	94 10 00 1b 	mov  %i3, %o2                                  
400204a4:	d4 27 00 00 	st  %o2, [ %i4 ]                               
 * @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);             
400204a8:	c8 0a 60 0c 	ldub  [ %o1 + 0xc ], %g4                       
400204ac:	c4 0a 60 0d 	ldub  [ %o1 + 0xd ], %g2                       
400204b0:	c6 0a 60 0f 	ldub  [ %o1 + 0xf ], %g3                       
400204b4:	c2 0a 60 0e 	ldub  [ %o1 + 0xe ], %g1                       
400204b8:	89 29 20 18 	sll  %g4, 0x18, %g4                            
400204bc:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
400204c0:	83 28 60 08 	sll  %g1, 8, %g1                               
400204c4:	84 11 00 02 	or  %g4, %g2, %g2                              
400204c8:	84 10 80 03 	or  %g2, %g3, %g2                              
  if (size < *length)                                                 
  {                                                                   
    *length = size;                                                   
  }                                                                   
                                                                      
  if (rtems_rfs_inode_get_block_count (&inode) == 0)                  
400204cc:	80 90 80 01 	orcc  %g2, %g1, %g0                            
400204d0:	12 80 00 0a 	bne  400204f8 <rtems_rfs_symlink_read+0xf4>    <== NEVER TAKEN
400204d4:	90 10 00 18 	mov  %i0, %o0                                  
  {                                                                   
    memcpy (path, inode.node->data.name, *length);                    
400204d8:	90 10 00 1a 	mov  %i2, %o0                                  
400204dc:	40 00 0d 9b 	call  40023b48 <memcpy>                        
400204e0:	92 02 60 1c 	add  %o1, 0x1c, %o1                            
      rtems_rfs_inode_close (fs, &inode);                             
      return rc;                                                      
    }                                                                 
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
400204e4:	90 10 00 18 	mov  %i0, %o0                                  
400204e8:	7f ff c8 40 	call  400125e8 <rtems_rfs_inode_close>         
400204ec:	92 07 bf 88 	add  %fp, -120, %o1                            
400204f0:	10 bf ff df 	b  4002046c <rtems_rfs_symlink_read+0x68>      
400204f4:	ba 10 00 08 	mov  %o0, %i5                                  
    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);                 
400204f8:	92 07 bf 88 	add  %fp, -120, %o1                            <== NOT EXECUTED
400204fc:	7f ff ec 45 	call  4001b610 <rtems_rfs_block_map_open>      <== NOT EXECUTED
40020500:	94 07 bf b0 	add  %fp, -80, %o2                             <== NOT EXECUTED
40020504:	ba 10 00 08 	mov  %o0, %i5                                  <== NOT EXECUTED
    if (rc > 0)                                                       
40020508:	80 a7 60 00 	cmp  %i5, 0                                    <== NOT EXECUTED
4002050c:	04 80 00 05 	ble  40020520 <rtems_rfs_symlink_read+0x11c>   <== NOT EXECUTED
40020510:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
    }                                                                 
                                                                      
    rc = rtems_rfs_block_map_close (fs, &map);                        
    if (rc > 0)                                                       
    {                                                                 
      rtems_rfs_inode_close (fs, &inode);                             
40020514:	7f ff c8 35 	call  400125e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
40020518:	92 07 bf 88 	add  %fp, -120, %o1                            <== NOT EXECUTED
4002051c:	30 bf ff d4 	b,a   4002046c <rtems_rfs_symlink_read+0x68>   <== NOT EXECUTED
    {                                                                 
      rtems_rfs_inode_close (fs, &inode);                             
      return rc;                                                      
    }                                                                 
                                                                      
    rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);              
40020520:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
40020524:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
40020528:	96 10 20 00 	clr  %o3                                       <== NOT EXECUTED
4002052c:	7f ff ed 68 	call  4001bacc <rtems_rfs_block_map_seek>      <== NOT EXECUTED
40020530:	98 07 bf 78 	add  %fp, -136, %o4                            <== NOT EXECUTED
    if (rc > 0)                                                       
40020534:	ba 92 20 00 	orcc  %o0, 0, %i5                              <== NOT EXECUTED
40020538:	04 80 00 09 	ble  4002055c <rtems_rfs_symlink_read+0x158>   <== NOT EXECUTED
4002053c:	d4 07 bf 78 	ld  [ %fp + -136 ], %o2                        <== NOT EXECUTED
    }                                                                 
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false); 
    if (rc > 0)                                                       
    {                                                                 
      rtems_rfs_block_map_close (fs, &map);                           
40020540:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
40020544:	7f ff ec 94 	call  4001b794 <rtems_rfs_block_map_close>     <== NOT EXECUTED
40020548:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
      rtems_rfs_inode_close (fs, &inode);                             
4002054c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40020550:	7f ff c8 26 	call  400125e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
40020554:	92 07 bf 88 	add  %fp, -120, %o1                            <== NOT EXECUTED
40020558:	30 bf ff c5 	b,a   4002046c <rtems_rfs_symlink_read+0x68>   <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
4002055c:	c0 2f bf 7c 	clrb  [ %fp + -132 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
40020560:	c0 27 bf 80 	clr  [ %fp + -128 ]                            <== NOT EXECUTED
  handle->buffer = NULL;                                              
40020564:	c0 27 bf 84 	clr  [ %fp + -124 ]                            <== 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); 
40020568:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4002056c:	92 07 bf 7c 	add  %fp, -132, %o1                            <== NOT EXECUTED
40020570:	7f ff f0 2c 	call  4001c620 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
40020574:	96 10 20 00 	clr  %o3                                       <== NOT EXECUTED
    if (rc > 0)                                                       
40020578:	ba 92 20 00 	orcc  %o0, 0, %i5                              <== NOT EXECUTED
4002057c:	34 bf ff f2 	bg,a   40020544 <rtems_rfs_symlink_read+0x140> <== NOT EXECUTED
40020580:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
      rtems_rfs_inode_close (fs, &inode);                             
      return rc;                                                      
    }                                                                 
                                                                      
    data = rtems_rfs_buffer_data (&buffer);                           
    memcpy (path, data, *length);                                     
40020584:	c2 07 bf 84 	ld  [ %fp + -124 ], %g1                        <== NOT EXECUTED
40020588:	d4 07 00 00 	ld  [ %i4 ], %o2                               <== NOT EXECUTED
4002058c:	d2 00 60 1c 	ld  [ %g1 + 0x1c ], %o1                        <== NOT EXECUTED
40020590:	40 00 0d 6e 	call  40023b48 <memcpy>                        <== NOT EXECUTED
40020594:	90 10 00 1a 	mov  %i2, %o0                                  <== 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);                       
40020598:	92 07 bf 7c 	add  %fp, -132, %o1                            <== NOT EXECUTED
4002059c:	7f ff ef a7 	call  4001c438 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
400205a0:	90 10 00 18 	mov  %i0, %o0                                  <== 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);                        
400205a4:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
400205a8:	c0 2f bf 7c 	clrb  [ %fp + -132 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
400205ac:	c0 27 bf 80 	clr  [ %fp + -128 ]                            <== NOT EXECUTED
  handle->buffer = NULL;                                              
400205b0:	c0 27 bf 84 	clr  [ %fp + -124 ]                            <== NOT EXECUTED
400205b4:	7f ff ec 78 	call  4001b794 <rtems_rfs_block_map_close>     <== NOT EXECUTED
400205b8:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
    if (rc > 0)                                                       
400205bc:	ba 92 20 00 	orcc  %o0, 0, %i5                              <== NOT EXECUTED
400205c0:	04 bf ff c9 	ble  400204e4 <rtems_rfs_symlink_read+0xe0>    <== NOT EXECUTED
400205c4:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
400205c8:	30 bf ff d3 	b,a   40020514 <rtems_rfs_symlink_read+0x110>  <== NOT EXECUTED
                                                                      

40013ee4 <rtems_rfs_trace_clear_mask>: rtems_rfs_trace_mask rtems_rfs_trace_clear_mask (rtems_rfs_trace_mask mask) { rtems_rfs_trace_mask state = rtems_rfs_trace_flags;
40013ee4:	03 10 01 26 	sethi  %hi(0x40049800), %g1                    <== NOT EXECUTED
40013ee8:	c4 18 61 f8 	ldd  [ %g1 + 0x1f8 ], %g2	! 400499f8 <rtems_rfs_trace_flags><== NOT EXECUTED
  rtems_rfs_trace_flags &= ~mask;                                     
40013eec:	98 28 80 08 	andn  %g2, %o0, %o4                            <== NOT EXECUTED
40013ef0:	9a 28 c0 09 	andn  %g3, %o1, %o5                            <== NOT EXECUTED
  return state;                                                       
}                                                                     
40013ef4:	90 10 00 02 	mov  %g2, %o0                                  <== NOT EXECUTED
                                                                      
rtems_rfs_trace_mask                                                  
rtems_rfs_trace_clear_mask (rtems_rfs_trace_mask mask)                
{                                                                     
  rtems_rfs_trace_mask state = rtems_rfs_trace_flags;                 
  rtems_rfs_trace_flags &= ~mask;                                     
40013ef8:	d8 38 61 f8 	std  %o4, [ %g1 + 0x1f8 ]                      <== NOT EXECUTED
  return state;                                                       
}                                                                     
40013efc:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
40013f00:	92 10 00 03 	mov  %g3, %o1                                  <== NOT EXECUTED
                                                                      

40013ec4 <rtems_rfs_trace_set_mask>: rtems_rfs_trace_mask rtems_rfs_trace_set_mask (rtems_rfs_trace_mask mask) { rtems_rfs_trace_mask state = rtems_rfs_trace_flags;
40013ec4:	03 10 01 26 	sethi  %hi(0x40049800), %g1                    <== NOT EXECUTED
40013ec8:	c4 18 61 f8 	ldd  [ %g1 + 0x1f8 ], %g2	! 400499f8 <rtems_rfs_trace_flags><== NOT EXECUTED
  rtems_rfs_trace_flags |= mask;                                      
40013ecc:	98 12 00 02 	or  %o0, %g2, %o4                              <== NOT EXECUTED
40013ed0:	9a 12 40 03 	or  %o1, %g3, %o5                              <== NOT EXECUTED
  return state;                                                       
}                                                                     
40013ed4:	90 10 00 02 	mov  %g2, %o0                                  <== NOT EXECUTED
                                                                      
rtems_rfs_trace_mask                                                  
rtems_rfs_trace_set_mask (rtems_rfs_trace_mask mask)                  
{                                                                     
  rtems_rfs_trace_mask state = rtems_rfs_trace_flags;                 
  rtems_rfs_trace_flags |= mask;                                      
40013ed8:	d8 38 61 f8 	std  %o4, [ %g1 + 0x1f8 ]                      <== NOT EXECUTED
  return state;                                                       
}                                                                     
40013edc:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
40013ee0:	92 10 00 03 	mov  %g3, %o1                                  <== NOT EXECUTED
                                                                      

40013f04 <rtems_rfs_trace_shell_command>: int rtems_rfs_trace_shell_command (int argc, char *argv[]) {
40013f04:	9d e3 bf 00 	save  %sp, -256, %sp                           <== NOT EXECUTED
  const char* table[] =                                               
40013f08:	13 10 00 d8 	sethi  %hi(0x40036000), %o1                    <== NOT EXECUTED
40013f0c:	a8 07 bf 64 	add  %fp, -156, %l4                            <== NOT EXECUTED
40013f10:	92 12 63 0c 	or  %o1, 0x30c, %o1                            <== NOT EXECUTED
40013f14:	90 10 00 14 	mov  %l4, %o0                                  <== NOT EXECUTED
40013f18:	40 00 3f 0c 	call  40023b48 <memcpy>                        <== NOT EXECUTED
40013f1c:	94 10 20 9c 	mov  0x9c, %o2                                 <== NOT EXECUTED
  rtems_rfs_trace_mask clear_value = 0;                               
  bool                 set = true;                                    
  int                  arg;                                           
  int                  t;                                             
                                                                      
  for (arg = 1; arg < argc; arg++)                                    
40013f20:	80 a6 20 01 	cmp  %i0, 1                                    <== NOT EXECUTED
40013f24:	04 80 00 3f 	ble  40014020 <rtems_rfs_trace_shell_command+0x11c><== NOT EXECUTED
40013f28:	01 00 00 00 	nop                                            <== NOT EXECUTED
  {                                                                   
    if (argv[arg][0] == '-')                                          
40013f2c:	e4 06 60 04 	ld  [ %i1 + 4 ], %l2                           <== NOT EXECUTED
40013f30:	c2 4c 80 00 	ldsb  [ %l2 ], %g1                             <== NOT EXECUTED
40013f34:	80 a0 60 2d 	cmp  %g1, 0x2d                                 <== NOT EXECUTED
40013f38:	02 80 00 6e 	be  400140f0 <rtems_rfs_trace_shell_command+0x1ec><== NOT EXECUTED
40013f3c:	2f 10 01 26 	sethi  %hi(0x40049800), %l7                    <== NOT EXECUTED
  rtems_rfs_trace_mask clear_value = 0;                               
  bool                 set = true;                                    
  int                  arg;                                           
  int                  t;                                             
                                                                      
  for (arg = 1; arg < argc; arg++)                                    
40013f40:	a6 10 20 01 	mov  1, %l3                                    <== NOT EXECUTED
40013f44:	f8 1d e1 f8 	ldd  [ %l7 + 0x1f8 ], %i4                      <== NOT EXECUTED
    "file-set"                                                        
  };                                                                  
                                                                      
  rtems_rfs_trace_mask set_value = 0;                                 
  rtems_rfs_trace_mask clear_value = 0;                               
  bool                 set = true;                                    
40013f48:	aa 10 20 01 	mov  1, %l5                                    <== NOT EXECUTED
    "file-io",                                                        
    "file-set"                                                        
  };                                                                  
                                                                      
  rtems_rfs_trace_mask set_value = 0;                                 
  rtems_rfs_trace_mask clear_value = 0;                               
40013f4c:	b4 10 20 00 	clr  %i2                                       <== NOT EXECUTED
40013f50:	b6 10 20 00 	clr  %i3                                       <== NOT EXECUTED
    "file-close",                                                     
    "file-io",                                                        
    "file-set"                                                        
  };                                                                  
                                                                      
  rtems_rfs_trace_mask set_value = 0;                                 
40013f54:	a0 10 20 00 	clr  %l0                                       <== NOT EXECUTED
40013f58:	a2 10 20 00 	clr  %l1                                       <== NOT EXECUTED
40013f5c:	10 80 00 10 	b  40013f9c <rtems_rfs_trace_shell_command+0x98><== NOT EXECUTED
40013f60:	ae 15 e1 f8 	or  %l7, 0x1f8, %l7                            <== NOT EXECUTED
40013f64:	ba 14 40 1d 	or  %l1, %i5, %i5                              <== NOT EXECUTED
    else                                                              
    {                                                                 
      if (strcmp (argv[arg], "set") == 0)                             
        set = true;                                                   
      if (strcmp (argv[arg], "clear") == 0)                           
        set = false;                                                  
40013f68:	aa 10 20 00 	clr  %l5                                       <== NOT EXECUTED
40013f6c:	b8 2f 00 1a 	andn  %i4, %i2, %i4                            <== NOT EXECUTED
40013f70:	ba 2f 40 1b 	andn  %i5, %i3, %i5                            <== NOT EXECUTED
  rtems_rfs_trace_mask clear_value = 0;                               
  bool                 set = true;                                    
  int                  arg;                                           
  int                  t;                                             
                                                                      
  for (arg = 1; arg < argc; arg++)                                    
40013f74:	a6 04 e0 01 	inc  %l3                                       <== NOT EXECUTED
40013f78:	80 a4 c0 18 	cmp  %l3, %i0                                  <== NOT EXECUTED
40013f7c:	02 80 00 29 	be  40014020 <rtems_rfs_trace_shell_command+0x11c><== NOT EXECUTED
40013f80:	f8 3d c0 00 	std  %i4, [ %l7 ]                              <== NOT EXECUTED
  rtems_rfs_trace_flags &= ~mask;                                     
  return state;                                                       
}                                                                     
                                                                      
int                                                                   
rtems_rfs_trace_shell_command (int argc, char *argv[])                
40013f84:	83 2c e0 02 	sll  %l3, 2, %g1                               <== NOT EXECUTED
  int                  arg;                                           
  int                  t;                                             
                                                                      
  for (arg = 1; arg < argc; arg++)                                    
  {                                                                   
    if (argv[arg][0] == '-')                                          
40013f88:	e4 06 40 01 	ld  [ %i1 + %g1 ], %l2                         <== NOT EXECUTED
40013f8c:	c2 4c 80 00 	ldsb  [ %l2 ], %g1                             <== NOT EXECUTED
40013f90:	80 a0 60 2d 	cmp  %g1, 0x2d                                 <== NOT EXECUTED
40013f94:	22 80 00 58 	be,a   400140f4 <rtems_rfs_trace_shell_command+0x1f0><== NOT EXECUTED
40013f98:	c2 4c a0 01 	ldsb  [ %l2 + 1 ], %g1                         <== NOT EXECUTED
          return 1;                                                   
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      if (strcmp (argv[arg], "set") == 0)                             
40013f9c:	90 10 00 12 	mov  %l2, %o0                                  <== NOT EXECUTED
40013fa0:	13 10 00 d1 	sethi  %hi(0x40034400), %o1                    <== NOT EXECUTED
40013fa4:	40 00 42 7d 	call  40024998 <strcmp>                        <== NOT EXECUTED
40013fa8:	92 12 60 08 	or  %o1, 8, %o1	! 40034408 <__FUNCTION__.6193+0x340><== NOT EXECUTED
40013fac:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40013fb0:	22 80 00 02 	be,a   40013fb8 <rtems_rfs_trace_shell_command+0xb4><== NOT EXECUTED
40013fb4:	aa 10 20 01 	mov  1, %l5                                    <== NOT EXECUTED
        set = true;                                                   
      if (strcmp (argv[arg], "clear") == 0)                           
40013fb8:	90 10 00 12 	mov  %l2, %o0                                  <== NOT EXECUTED
40013fbc:	13 10 00 d8 	sethi  %hi(0x40036000), %o1                    <== NOT EXECUTED
40013fc0:	40 00 42 76 	call  40024998 <strcmp>                        <== NOT EXECUTED
40013fc4:	92 12 60 a0 	or  %o1, 0xa0, %o1	! 400360a0 <rtems_rfs_rtems_eval_config+0xa0><== NOT EXECUTED
40013fc8:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40013fcc:	22 bf ff e6 	be,a   40013f64 <rtems_rfs_trace_shell_command+0x60><== NOT EXECUTED
40013fd0:	b8 14 00 1c 	or  %l0, %i4, %i4                              <== NOT EXECUTED
        set = false;                                                  
      else if (strcmp (argv[arg], "all") == 0)                        
40013fd4:	90 10 00 12 	mov  %l2, %o0                                  <== NOT EXECUTED
40013fd8:	13 10 00 d8 	sethi  %hi(0x40036000), %o1                    <== NOT EXECUTED
40013fdc:	40 00 42 6f 	call  40024998 <strcmp>                        <== NOT EXECUTED
40013fe0:	92 12 60 a8 	or  %o1, 0xa8, %o1	! 400360a8 <rtems_rfs_rtems_eval_config+0xa8><== NOT EXECUTED
40013fe4:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40013fe8:	12 80 00 13 	bne  40014034 <rtems_rfs_trace_shell_command+0x130><== NOT EXECUTED
40013fec:	ac 10 20 00 	clr  %l6                                       <== NOT EXECUTED
      {                                                               
        if (set)                                                      
40013ff0:	80 8d 60 ff 	btst  0xff, %l5                                <== NOT EXECUTED
40013ff4:	22 80 00 23 	be,a   40014080 <rtems_rfs_trace_shell_command+0x17c><== NOT EXECUTED
40013ff8:	35 3f ff ff 	sethi  %hi(0xfffffc00), %i2                    <== NOT EXECUTED
40013ffc:	b8 3e a0 00 	xnor  %i2, 0, %i4                              <== NOT EXECUTED
40014000:	ba 3e e0 00 	xnor  %i3, 0, %i5                              <== NOT EXECUTED
          }                                                           
        }                                                             
      }                                                               
                                                                      
      rtems_rfs_trace_flags |= set_value;                             
      rtems_rfs_trace_flags &= ~clear_value;                          
40014004:	f8 3d c0 00 	std  %i4, [ %l7 ]                              <== NOT EXECUTED
      if (strcmp (argv[arg], "clear") == 0)                           
        set = false;                                                  
      else if (strcmp (argv[arg], "all") == 0)                        
      {                                                               
        if (set)                                                      
          set_value = RTEMS_RFS_TRACE_ALL;                            
40014008:	21 3f ff ff 	sethi  %hi(0xfffffc00), %l0                    <== NOT EXECUTED
  rtems_rfs_trace_mask clear_value = 0;                               
  bool                 set = true;                                    
  int                  arg;                                           
  int                  t;                                             
                                                                      
  for (arg = 1; arg < argc; arg++)                                    
4001400c:	a6 04 e0 01 	inc  %l3                                       <== NOT EXECUTED
      if (strcmp (argv[arg], "clear") == 0)                           
        set = false;                                                  
      else if (strcmp (argv[arg], "all") == 0)                        
      {                                                               
        if (set)                                                      
          set_value = RTEMS_RFS_TRACE_ALL;                            
40014010:	a0 14 23 ff 	or  %l0, 0x3ff, %l0                            <== NOT EXECUTED
  rtems_rfs_trace_mask clear_value = 0;                               
  bool                 set = true;                                    
  int                  arg;                                           
  int                  t;                                             
                                                                      
  for (arg = 1; arg < argc; arg++)                                    
40014014:	80 a4 c0 18 	cmp  %l3, %i0                                  <== NOT EXECUTED
40014018:	12 bf ff db 	bne  40013f84 <rtems_rfs_trace_shell_command+0x80><== NOT EXECUTED
4001401c:	a2 10 00 10 	mov  %l0, %l1                                  <== NOT EXECUTED
    {                                                                 
      switch (argv[arg][1])                                           
      {                                                               
        case 'h':                                                     
          printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);  
          return 0;                                                   
40014020:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40014024:	91 e8 20 00 	restore  %g0, 0, %o0                           <== NOT EXECUTED
        else                                                          
          clear_value = RTEMS_RFS_TRACE_ALL;                          
      }                                                               
      else                                                            
      {                                                               
        for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++) 
40014028:	80 a5 a0 27 	cmp  %l6, 0x27                                 <== NOT EXECUTED
4001402c:	22 80 00 11 	be,a   40014070 <rtems_rfs_trace_shell_command+0x16c><== NOT EXECUTED
40014030:	b8 14 00 1c 	or  %l0, %i4, %i4                              <== NOT EXECUTED
  rtems_rfs_trace_flags &= ~mask;                                     
  return state;                                                       
}                                                                     
                                                                      
int                                                                   
rtems_rfs_trace_shell_command (int argc, char *argv[])                
40014034:	85 2d a0 02 	sll  %l6, 2, %g2                               <== NOT EXECUTED
      }                                                               
      else                                                            
      {                                                               
        for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++) 
        {                                                             
          if (strcmp (argv[arg], table[t]) == 0)                      
40014038:	d2 05 00 02 	ld  [ %l4 + %g2 ], %o1                         <== NOT EXECUTED
4001403c:	40 00 42 57 	call  40024998 <strcmp>                        <== NOT EXECUTED
40014040:	90 10 00 12 	mov  %l2, %o0                                  <== NOT EXECUTED
40014044:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40014048:	32 bf ff f8 	bne,a   40014028 <rtems_rfs_trace_shell_command+0x124><== NOT EXECUTED
4001404c:	ac 05 a0 01 	inc  %l6                                       <== NOT EXECUTED
          {                                                           
            if (set)                                                  
40014050:	80 8d 60 ff 	btst  0xff, %l5                                <== NOT EXECUTED
40014054:	02 80 00 10 	be  40014094 <rtems_rfs_trace_shell_command+0x190><== NOT EXECUTED
40014058:	80 8d a0 20 	btst  0x20, %l6                                <== NOT EXECUTED
              set_value = 1ULL << t;                                  
4001405c:	12 80 00 1e 	bne  400140d4 <rtems_rfs_trace_shell_command+0x1d0><== NOT EXECUTED
40014060:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
40014064:	a0 10 20 00 	clr  %l0                                       <== NOT EXECUTED
40014068:	a3 28 40 16 	sll  %g1, %l6, %l1                             <== NOT EXECUTED
4001406c:	b8 14 00 1c 	or  %l0, %i4, %i4                              <== NOT EXECUTED
40014070:	ba 14 40 1d 	or  %l1, %i5, %i5                              <== NOT EXECUTED
40014074:	b8 2f 00 1a 	andn  %i4, %i2, %i4                            <== NOT EXECUTED
40014078:	10 bf ff bf 	b  40013f74 <rtems_rfs_trace_shell_command+0x70><== NOT EXECUTED
4001407c:	ba 2f 40 1b 	andn  %i5, %i3, %i5                            <== NOT EXECUTED
        set = true;                                                   
      if (strcmp (argv[arg], "clear") == 0)                           
        set = false;                                                  
      else if (strcmp (argv[arg], "all") == 0)                        
      {                                                               
        if (set)                                                      
40014080:	b8 10 20 00 	clr  %i4                                       <== NOT EXECUTED
          set_value = RTEMS_RFS_TRACE_ALL;                            
        else                                                          
          clear_value = RTEMS_RFS_TRACE_ALL;                          
40014084:	b4 16 a3 ff 	or  %i2, 0x3ff, %i2                            <== NOT EXECUTED
        set = true;                                                   
      if (strcmp (argv[arg], "clear") == 0)                           
        set = false;                                                  
      else if (strcmp (argv[arg], "all") == 0)                        
      {                                                               
        if (set)                                                      
40014088:	ba 10 20 00 	clr  %i5                                       <== NOT EXECUTED
          set_value = RTEMS_RFS_TRACE_ALL;                            
        else                                                          
          clear_value = RTEMS_RFS_TRACE_ALL;                          
4001408c:	10 bf ff ba 	b  40013f74 <rtems_rfs_trace_shell_command+0x70><== NOT EXECUTED
40014090:	b6 10 00 1a 	mov  %i2, %i3                                  <== NOT EXECUTED
          if (strcmp (argv[arg], table[t]) == 0)                      
          {                                                           
            if (set)                                                  
              set_value = 1ULL << t;                                  
            else                                                      
              clear_value = 1ULL << t;                                
40014094:	12 80 00 09 	bne  400140b8 <rtems_rfs_trace_shell_command+0x1b4><== NOT EXECUTED
40014098:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
4001409c:	b4 10 20 00 	clr  %i2                                       <== NOT EXECUTED
400140a0:	b8 14 00 1c 	or  %l0, %i4, %i4                              <== NOT EXECUTED
400140a4:	b7 28 40 16 	sll  %g1, %l6, %i3                             <== NOT EXECUTED
400140a8:	ba 14 40 1d 	or  %l1, %i5, %i5                              <== NOT EXECUTED
400140ac:	b8 2f 00 1a 	andn  %i4, %i2, %i4                            <== NOT EXECUTED
400140b0:	10 bf ff b1 	b  40013f74 <rtems_rfs_trace_shell_command+0x70><== NOT EXECUTED
400140b4:	ba 2f 40 1b 	andn  %i5, %i3, %i5                            <== NOT EXECUTED
400140b8:	b6 10 20 00 	clr  %i3                                       <== NOT EXECUTED
400140bc:	b5 28 40 16 	sll  %g1, %l6, %i2                             <== NOT EXECUTED
400140c0:	b8 14 00 1c 	or  %l0, %i4, %i4                              <== NOT EXECUTED
400140c4:	ba 14 40 1d 	or  %l1, %i5, %i5                              <== NOT EXECUTED
400140c8:	b8 2f 00 1a 	andn  %i4, %i2, %i4                            <== NOT EXECUTED
400140cc:	10 bf ff aa 	b  40013f74 <rtems_rfs_trace_shell_command+0x70><== NOT EXECUTED
400140d0:	ba 2f 40 1b 	andn  %i5, %i3, %i5                            <== NOT EXECUTED
        for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++) 
        {                                                             
          if (strcmp (argv[arg], table[t]) == 0)                      
          {                                                           
            if (set)                                                  
              set_value = 1ULL << t;                                  
400140d4:	a2 10 20 00 	clr  %l1                                       <== NOT EXECUTED
400140d8:	a1 28 40 16 	sll  %g1, %l6, %l0                             <== NOT EXECUTED
400140dc:	ba 14 40 1d 	or  %l1, %i5, %i5                              <== NOT EXECUTED
400140e0:	b8 14 00 1c 	or  %l0, %i4, %i4                              <== NOT EXECUTED
400140e4:	ba 2f 40 1b 	andn  %i5, %i3, %i5                            <== NOT EXECUTED
400140e8:	10 bf ff a3 	b  40013f74 <rtems_rfs_trace_shell_command+0x70><== NOT EXECUTED
400140ec:	b8 2f 00 1a 	andn  %i4, %i2, %i4                            <== NOT EXECUTED
                                                                      
  for (arg = 1; arg < argc; arg++)                                    
  {                                                                   
    if (argv[arg][0] == '-')                                          
    {                                                                 
      switch (argv[arg][1])                                           
400140f0:	c2 4c a0 01 	ldsb  [ %l2 + 1 ], %g1                         <== NOT EXECUTED
400140f4:	80 a0 60 68 	cmp  %g1, 0x68                                 <== NOT EXECUTED
400140f8:	02 80 00 09 	be  4001411c <rtems_rfs_trace_shell_command+0x218><== NOT EXECUTED
400140fc:	80 a0 60 6c 	cmp  %g1, 0x6c                                 <== NOT EXECUTED
40014100:	02 80 00 0e 	be  40014138 <rtems_rfs_trace_shell_command+0x234><== NOT EXECUTED
40014104:	b0 10 20 01 	mov  1, %i0                                    <== NOT EXECUTED
          printf ("%s: valid flags to set or clear are:\n", argv[0]); 
          for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
            printf ("  %s\n", table[t]);                              
          return 0;                                                   
        default:                                                      
          printf ("error: unknown option\n");                         
40014108:	11 10 00 d8 	sethi  %hi(0x40036000), %o0                    <== NOT EXECUTED
4001410c:	40 00 40 34 	call  400241dc <puts>                          <== NOT EXECUTED
40014110:	90 12 20 88 	or  %o0, 0x88, %o0	! 40036088 <rtems_rfs_rtems_eval_config+0x88><== NOT EXECUTED
40014114:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40014118:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    if (argv[arg][0] == '-')                                          
    {                                                                 
      switch (argv[arg][1])                                           
      {                                                               
        case 'h':                                                     
          printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);  
4001411c:	d2 06 40 00 	ld  [ %i1 ], %o1                               <== NOT EXECUTED
40014120:	11 10 00 d8 	sethi  %hi(0x40036000), %o0                    <== NOT EXECUTED
          return 0;                                                   
40014124:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
    if (argv[arg][0] == '-')                                          
    {                                                                 
      switch (argv[arg][1])                                           
      {                                                               
        case 'h':                                                     
          printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);  
40014128:	40 00 3f 95 	call  40023f7c <printf>                        <== NOT EXECUTED
4001412c:	90 12 20 30 	or  %o0, 0x30, %o0                             <== NOT EXECUTED
40014130:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40014134:	81 e8 00 00 	restore                                        <== NOT EXECUTED
          return 0;                                                   
        case 'l':                                                     
          printf ("%s: valid flags to set or clear are:\n", argv[0]); 
40014138:	d2 06 40 00 	ld  [ %i1 ], %o1                               <== NOT EXECUTED
4001413c:	11 10 00 d8 	sethi  %hi(0x40036000), %o0                    <== NOT EXECUTED
40014140:	3b 10 00 d8 	sethi  %hi(0x40036000), %i5                    <== NOT EXECUTED
40014144:	90 12 20 58 	or  %o0, 0x58, %o0                             <== NOT EXECUTED
40014148:	40 00 3f 8d 	call  40023f7c <printf>                        <== NOT EXECUTED
4001414c:	b8 10 00 1e 	mov  %fp, %i4                                  <== NOT EXECUTED
          for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
            printf ("  %s\n", table[t]);                              
40014150:	ba 17 60 80 	or  %i5, 0x80, %i5                             <== NOT EXECUTED
40014154:	d2 05 00 00 	ld  [ %l4 ], %o1                               <== NOT EXECUTED
40014158:	40 00 3f 89 	call  40023f7c <printf>                        <== NOT EXECUTED
4001415c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40014160:	a8 05 20 04 	add  %l4, 4, %l4                               <== NOT EXECUTED
        case 'h':                                                     
          printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);  
          return 0;                                                   
        case 'l':                                                     
          printf ("%s: valid flags to set or clear are:\n", argv[0]); 
          for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
40014164:	80 a5 00 1c 	cmp  %l4, %i4                                  <== NOT EXECUTED
40014168:	32 bf ff fc 	bne,a   40014158 <rtems_rfs_trace_shell_command+0x254><== NOT EXECUTED
4001416c:	d2 05 00 00 	ld  [ %l4 ], %o1                               <== NOT EXECUTED
    {                                                                 
      switch (argv[arg][1])                                           
      {                                                               
        case 'h':                                                     
          printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);  
          return 0;                                                   
40014170:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40014174:	91 e8 20 00 	restore  %g0, 0, %o0                           <== NOT EXECUTED
40014178:	40 01 51 f4 	call  40068948 <__end+0x1dff8>                 <== NOT EXECUTED
4001417c:	40 01 53 90 	call  40068fbc <__end+0x1e66c>                 <== NOT EXECUTED
40014180:	40 01 53 88 	call  40068fa0 <__end+0x1e650>                 <== NOT EXECUTED
40014184:	40 01 53 74 	call  40068f54 <__end+0x1e604>                 <== NOT EXECUTED
40014188:	40 01 53 74 	call  40068f58 <__end+0x1e608>                 <== NOT EXECUTED
4001418c:	40 01 53 74 	call  40068f5c <__end+0x1e60c>                 <== NOT EXECUTED
40014190:	40 01 53 74 	call  40068f60 <__end+0x1e610>                 <== NOT EXECUTED
40014194:	40 01 53 40 	call  40068e94 <__end+0x1e544>                 <== NOT EXECUTED
40014198:	40 01 53 2c 	call  40068e48 <__end+0x1e4f8>                 <== NOT EXECUTED
4001419c:	40 01 53 2c 	call  40068e4c <__end+0x1e4fc>                 <== NOT EXECUTED
400141a0:	40 01 53 2c 	call  40068e50 <__end+0x1e500>                 <== NOT EXECUTED
400141a4:	40 01 52 3c 	call  40068a94 <__end+0x1e144>                 <== NOT EXECUTED
400141a8:	40 01 52 2c 	call  40068a58 <__end+0x1e108>                 <== NOT EXECUTED
400141ac:	40 01 52 2c 	call  40068a5c <__end+0x1e10c>                 <== NOT EXECUTED
400141b0:	40 01 53 08 	call  40068dd0 <__end+0x1e480>                 <== NOT EXECUTED
400141b4:	40 01 53 08 	call  40068dd4 <__end+0x1e484>                 <== NOT EXECUTED
400141b8:	40 01 53 08 	call  40068dd8 <__end+0x1e488>                 <== NOT EXECUTED
400141bc:	40 01 53 08 	call  40068ddc <__end+0x1e48c>                 <== NOT EXECUTED
400141c0:	40 01 52 d4 	call  40068d10 <__end+0x1e3c0>                 <== NOT EXECUTED
400141c4:	40 01 52 c0 	call  40068cc4 <__end+0x1e374>                 <== NOT EXECUTED
400141c8:	40 01 52 c0 	call  40068cc8 <__end+0x1e378>                 <== NOT EXECUTED
400141cc:	40 01 52 c0 	call  40068ccc <__end+0x1e37c>                 <== NOT EXECUTED
400141d0:	40 01 68 40 	call  4006e2d0 <__end+0x23980>                 <== NOT EXECUTED
400141d4:	40 01 68 40 	call  4006e2d4 <__end+0x23984>                 <== NOT EXECUTED
400141d8:	40 01 69 68 	call  4006e778 <__end+0x23e28>                 <== NOT EXECUTED
400141dc:	40 01 69 90 	call  4006e81c <__end+0x23ecc>                 <== NOT EXECUTED
400141e0:	40 01 69 90 	call  4006e820 <__end+0x23ed0>                 <== NOT EXECUTED
400141e4:	40 01 69 90 	call  4006e824 <__end+0x23ed4>                 <== NOT EXECUTED
400141e8:	40 01 68 40 	call  4006e2e8 <__end+0x23998>                 <== NOT EXECUTED
400141ec:	40 01 69 58 	call  4006e74c <__end+0x23dfc>                 <== NOT EXECUTED
400141f0:	40 01 69 50 	call  4006e730 <__end+0x23de0>                 <== NOT EXECUTED
400141f4:	40 01 69 98 	call  4006e854 <__end+0x23f04>                 <== NOT EXECUTED
400141f8:	40 01 68 40 	call  4006e2f8 <__end+0x239a8>                 <== NOT EXECUTED
                                                                      

4001fd68 <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) {
4001fd68:	9d e3 bf 50 	save  %sp, -176, %sp                           
  rtems_rfs_inode_handle target_inode;                                
  uint16_t               links;                                       
  bool                   dir;                                         
  int                    rc;                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))                       
4001fd6c:	90 10 20 00 	clr  %o0                                       
4001fd70:	7f ff d0 4d 	call  40013ea4 <rtems_rfs_trace>               
4001fd74:	13 00 80 00 	sethi  %hi(0x2000000), %o1                     
4001fd78:	80 8a 20 ff 	btst  0xff, %o0                                
4001fd7c:	12 80 00 4a 	bne  4001fea4 <rtems_rfs_unlink+0x13c>         <== NEVER TAKEN
4001fd80:	92 10 00 19 	mov  %i1, %o1                                  
    printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
                                                                      
  rc = rtems_rfs_inode_open (fs, target, &target_inode, true);        
4001fd84:	90 10 00 18 	mov  %i0, %o0                                  
4001fd88:	92 10 00 1a 	mov  %i2, %o1                                  
4001fd8c:	94 07 bf d8 	add  %fp, -40, %o2                             
4001fd90:	7f ff c9 9e 	call  40012408 <rtems_rfs_inode_open>          
4001fd94:	96 10 20 01 	mov  1, %o3                                    
  if (rc)                                                             
4001fd98:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001fd9c:	12 80 00 19 	bne  4001fe00 <rtems_rfs_unlink+0x98>          <== NEVER TAKEN
4001fda0:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
                                                                      
  /*                                                                  
   * If a directory process the unlink mode.                          
   */                                                                 
                                                                      
  dir = RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&target_inode)); 
4001fda4:	05 00 00 3c 	sethi  %hi(0xf000), %g2                        
 * @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);                    
4001fda8:	c2 08 60 02 	ldub  [ %g1 + 2 ], %g1                         
4001fdac:	83 28 60 08 	sll  %g1, 8, %g1                               
4001fdb0:	82 08 40 02 	and  %g1, %g2, %g1                             
4001fdb4:	05 00 00 10 	sethi  %hi(0x4000), %g2                        
4001fdb8:	82 18 40 02 	xor  %g1, %g2, %g1                             
  if (dir)                                                            
4001fdbc:	80 a0 00 01 	cmp  %g0, %g1                                  
4001fdc0:	a0 60 3f ff 	subx  %g0, -1, %l0                             
4001fdc4:	80 a4 20 00 	cmp  %l0, 0                                    
4001fdc8:	02 80 00 12 	be  4001fe10 <rtems_rfs_unlink+0xa8>           
4001fdcc:	80 a7 20 00 	cmp  %i4, 0                                    
  {                                                                   
    switch (dir_mode)                                                 
4001fdd0:	12 80 00 0e 	bne  4001fe08 <rtems_rfs_unlink+0xa0>          <== ALWAYS TAKEN
4001fdd4:	80 a7 20 01 	cmp  %i4, 1                                    
    {                                                                 
      case rtems_rfs_unlink_dir_denied:                               
        if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))                 
4001fdd8:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001fddc:	7f ff d0 32 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001fde0:	13 00 80 00 	sethi  %hi(0x2000000), %o1                     <== NOT EXECUTED
4001fde4:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001fde8:	12 80 00 5a 	bne  4001ff50 <rtems_rfs_unlink+0x1e8>         <== NOT EXECUTED
4001fdec:	11 10 00 e0 	sethi  %hi(0x40038000), %o0                    <== NOT EXECUTED
          printf ("rtems-rfs: link is a directory\n");                
        rtems_rfs_inode_close (fs, &target_inode);                    
4001fdf0:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001fdf4:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
4001fdf8:	7f ff c9 fc 	call  400125e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
4001fdfc:	ba 10 20 15 	mov  0x15, %i5                                 <== 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;                                                          
}                                                                     
4001fe00:	81 c7 e0 08 	ret                                            
4001fe04:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
   */                                                                 
                                                                      
  dir = RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&target_inode)); 
  if (dir)                                                            
  {                                                                   
    switch (dir_mode)                                                 
4001fe08:	02 80 00 3f 	be  4001ff04 <rtems_rfs_unlink+0x19c>          <== ALWAYS TAKEN
4001fe0c:	90 10 00 18 	mov  %i0, %o0                                  
      default:                                                        
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);        
4001fe10:	90 10 00 18 	mov  %i0, %o0                                  
4001fe14:	92 10 00 19 	mov  %i1, %o1                                  
4001fe18:	94 07 bf b0 	add  %fp, -80, %o2                             
4001fe1c:	7f ff c9 7b 	call  40012408 <rtems_rfs_inode_open>          
4001fe20:	96 10 20 01 	mov  1, %o3                                    
  if (rc)                                                             
4001fe24:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001fe28:	12 80 00 25 	bne  4001febc <rtems_rfs_unlink+0x154>         <== NEVER TAKEN
4001fe2c:	90 10 20 00 	clr  %o0                                       
              rc, strerror (rc));                                     
    rtems_rfs_inode_close (fs, &target_inode);                        
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_dir_del_entry (fs, &parent_inode, target, doff);     
4001fe30:	90 10 00 18 	mov  %i0, %o0                                  
4001fe34:	92 07 bf b0 	add  %fp, -80, %o1                             
4001fe38:	94 10 00 1a 	mov  %i2, %o2                                  
4001fe3c:	7f ff f6 43 	call  4001d748 <rtems_rfs_dir_del_entry>       
4001fe40:	96 10 00 1b 	mov  %i3, %o3                                  
  if (rc > 0)                                                         
4001fe44:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001fe48:	04 80 00 46 	ble  4001ff60 <rtems_rfs_unlink+0x1f8>         <== ALWAYS TAKEN
4001fe4c:	90 10 20 00 	clr  %o0                                       
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))                     
4001fe50:	7f ff d0 15 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001fe54:	13 00 80 00 	sethi  %hi(0x2000000), %o1                     <== NOT EXECUTED
4001fe58:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001fe5c:	02 80 00 0a 	be  4001fe84 <rtems_rfs_unlink+0x11c>          <== NOT EXECUTED
4001fe60:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
      printf ("rtems-rfs: unlink: dir-del failed: %d: %s\n",          
4001fe64:	40 00 14 90 	call  400250a4 <strerror>                      <== NOT EXECUTED
4001fe68:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001fe6c:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
4001fe70:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
4001fe74:	11 10 00 e0 	sethi  %hi(0x40038000), %o0                    <== NOT EXECUTED
4001fe78:	40 00 10 41 	call  40023f7c <printf>                        <== NOT EXECUTED
4001fe7c:	90 12 20 c8 	or  %o0, 0xc8, %o0	! 400380c8 <CSWTCH.2+0x14d8><== NOT EXECUTED
  if (rc > 0)                                                         
  {                                                                   
    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);                        
4001fe80:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
4001fe84:	7f ff c9 d9 	call  400125e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
4001fe88:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
    rtems_rfs_inode_close (fs, &target_inode);                        
4001fe8c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001fe90:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
4001fe94:	7f ff c9 d5 	call  400125e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
4001fe98:	b0 10 00 1d 	mov  %i5, %i0                                  <== 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;                                                          
}                                                                     
4001fe9c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001fea0:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  uint16_t               links;                                       
  bool                   dir;                                         
  int                    rc;                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))                       
    printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
4001fea4:	11 10 00 e0 	sethi  %hi(0x40038000), %o0                    <== NOT EXECUTED
4001fea8:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
4001feac:	40 00 10 34 	call  40023f7c <printf>                        <== NOT EXECUTED
4001feb0:	90 12 20 28 	or  %o0, 0x28, %o0                             <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_inode_open (fs, target, &target_inode, true);        
4001feb4:	10 bf ff b5 	b  4001fd88 <rtems_rfs_unlink+0x20>            <== NOT EXECUTED
4001feb8:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);        
  if (rc)                                                             
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))                     
4001febc:	7f ff cf fa 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001fec0:	13 00 80 00 	sethi  %hi(0x2000000), %o1                     <== NOT EXECUTED
4001fec4:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001fec8:	22 80 00 0a 	be,a   4001fef0 <rtems_rfs_unlink+0x188>       <== NOT EXECUTED
4001fecc:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
      printf ("rtems-rfs: link: inode-open failed: %d: %s\n",         
4001fed0:	40 00 14 75 	call  400250a4 <strerror>                      <== NOT EXECUTED
4001fed4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001fed8:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
4001fedc:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
4001fee0:	11 10 00 e0 	sethi  %hi(0x40038000), %o0                    <== NOT EXECUTED
4001fee4:	40 00 10 26 	call  40023f7c <printf>                        <== NOT EXECUTED
4001fee8:	90 12 20 98 	or  %o0, 0x98, %o0	! 40038098 <CSWTCH.2+0x14a8><== NOT EXECUTED
  if (rc > 0)                                                         
  {                                                                   
    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);                        
4001feec:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001fef0:	92 07 bf d8 	add  %fp, -40, %o1                             
4001fef4:	7f ff c9 bd 	call  400125e8 <rtems_rfs_inode_close>         
4001fef8:	b0 10 00 1d 	mov  %i5, %i0                                  
  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;                                                          
}                                                                     
4001fefc:	81 c7 e0 08 	ret                                            
4001ff00:	81 e8 00 00 	restore                                        
          printf ("rtems-rfs: link is a directory\n");                
        rtems_rfs_inode_close (fs, &target_inode);                    
        return EISDIR;                                                
                                                                      
      case rtems_rfs_unlink_dir_if_empty:                             
        rc = rtems_rfs_dir_empty (fs, &target_inode);                 
4001ff04:	7f ff f8 14 	call  4001df54 <rtems_rfs_dir_empty>           
4001ff08:	92 07 bf d8 	add  %fp, -40, %o1                             
        if (rc > 0)                                                   
4001ff0c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001ff10:	04 bf ff c0 	ble  4001fe10 <rtems_rfs_unlink+0xa8>          
4001ff14:	90 10 20 00 	clr  %o0                                       
        {                                                             
          if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))               
4001ff18:	7f ff cf e3 	call  40013ea4 <rtems_rfs_trace>               
4001ff1c:	13 00 80 00 	sethi  %hi(0x2000000), %o1                     
4001ff20:	80 8a 20 ff 	btst  0xff, %o0                                
4001ff24:	22 bf ff f3 	be,a   4001fef0 <rtems_rfs_unlink+0x188>       <== ALWAYS TAKEN
4001ff28:	90 10 00 18 	mov  %i0, %o0                                  
            printf ("rtems-rfs: dir-empty: %d: %s\n", rc, strerror (rc));
4001ff2c:	40 00 14 5e 	call  400250a4 <strerror>                      <== NOT EXECUTED
4001ff30:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001ff34:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
4001ff38:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
4001ff3c:	11 10 00 e0 	sethi  %hi(0x40038000), %o0                    <== NOT EXECUTED
4001ff40:	40 00 10 0f 	call  40023f7c <printf>                        <== NOT EXECUTED
4001ff44:	90 12 20 78 	or  %o0, 0x78, %o0	! 40038078 <CSWTCH.2+0x1488><== NOT EXECUTED
  if (rc > 0)                                                         
  {                                                                   
    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);                        
4001ff48:	10 bf ff ea 	b  4001fef0 <rtems_rfs_unlink+0x188>           <== NOT EXECUTED
4001ff4c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
  {                                                                   
    switch (dir_mode)                                                 
    {                                                                 
      case rtems_rfs_unlink_dir_denied:                               
        if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))                 
          printf ("rtems-rfs: link is a directory\n");                
4001ff50:	40 00 10 a3 	call  400241dc <puts>                          <== NOT EXECUTED
4001ff54:	90 12 20 58 	or  %o0, 0x58, %o0                             <== NOT EXECUTED
        rtems_rfs_inode_close (fs, &target_inode);                    
4001ff58:	10 bf ff a7 	b  4001fdf4 <rtems_rfs_unlink+0x8c>            <== NOT EXECUTED
4001ff5c:	90 10 00 18 	mov  %i0, %o0                                  <== 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);                  
4001ff60:	c4 07 bf e4 	ld  [ %fp + -28 ], %g2                         
  if (links == 0xffff)                                                
    links = 0;                                                        
4001ff64:	07 3f ff c0 	sethi  %hi(0xffff0000), %g3                    
 */                                                                   
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);                  
4001ff68:	c2 08 80 00 	ldub  [ %g2 ], %g1                             
4001ff6c:	c4 08 a0 01 	ldub  [ %g2 + 1 ], %g2                         
4001ff70:	83 28 60 08 	sll  %g1, 8, %g1                               
4001ff74:	82 10 40 02 	or  %g1, %g2, %g1                              
  if (links == 0xffff)                                                
4001ff78:	85 28 60 10 	sll  %g1, 0x10, %g2                            
4001ff7c:	85 30 a0 10 	srl  %g2, 0x10, %g2                            
    links = 0;                                                        
4001ff80:	84 38 c0 02 	xnor  %g3, %g2, %g2                            
4001ff84:	80 a0 00 02 	cmp  %g0, %g2                                  
4001ff88:	ba 60 20 00 	subx  %g0, 0, %i5                              
    return rc;                                                        
  }                                                                   
                                                                      
  links = rtems_rfs_inode_get_links (&target_inode);                  
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))                       
4001ff8c:	13 00 80 00 	sethi  %hi(0x2000000), %o1                     
4001ff90:	7f ff cf c5 	call  40013ea4 <rtems_rfs_trace>               
4001ff94:	ba 08 40 1d 	and  %g1, %i5, %i5                             
4001ff98:	80 8a 20 ff 	btst  0xff, %o0                                
4001ff9c:	12 80 00 22 	bne  40020024 <rtems_rfs_unlink+0x2bc>         <== NEVER TAKEN
4001ffa0:	b9 2f 60 10 	sll  %i5, 0x10, %i4                            
    printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
                                                                      
  if (links > 1)                                                      
4001ffa4:	b9 37 20 10 	srl  %i4, 0x10, %i4                            
4001ffa8:	80 a7 20 01 	cmp  %i4, 1                                    
4001ffac:	08 80 00 39 	bleu  40020090 <rtems_rfs_unlink+0x328>        
4001ffb0:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
  {                                                                   
    links--;                                                          
4001ffb4:	ba 07 7f ff 	add  %i5, -1, %i5                              
 * @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);                  
4001ffb8:	85 37 60 08 	srl  %i5, 8, %g2                               
4001ffbc:	c4 28 40 00 	stb  %g2, [ %g1 ]                              
4001ffc0:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
4001ffc4:	fa 28 60 01 	stb  %i5, [ %g1 + 1 ]                          
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
4001ffc8:	82 10 20 01 	mov  1, %g1                                    
4001ffcc:	c2 2f bf e8 	stb  %g1, [ %fp + -24 ]                        
        links--;                                                      
      rtems_rfs_inode_set_links (&parent_inode, links);               
    }                                                                 
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);    
4001ffd0:	90 07 bf b0 	add  %fp, -80, %o0                             
4001ffd4:	92 10 20 01 	mov  1, %o1                                    
4001ffd8:	7f ff c9 df 	call  40012754 <rtems_rfs_inode_time_stamp_now>
4001ffdc:	94 10 20 01 	mov  1, %o2                                    
  if (rc > 0)                                                         
4001ffe0:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001ffe4:	04 80 00 17 	ble  40020040 <rtems_rfs_unlink+0x2d8>         <== ALWAYS TAKEN
4001ffe8:	90 10 20 00 	clr  %o0                                       
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))                     
4001ffec:	7f ff cf ae 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4001fff0:	13 00 80 00 	sethi  %hi(0x2000000), %o1                     <== NOT EXECUTED
4001fff4:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001fff8:	22 bf ff a3 	be,a   4001fe84 <rtems_rfs_unlink+0x11c>       <== NOT EXECUTED
4001fffc:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
      printf ("rtems-rfs: link: inode-time-stamp failed: %d: %s\n",   
40020000:	40 00 14 29 	call  400250a4 <strerror>                      <== NOT EXECUTED
40020004:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40020008:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
4002000c:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40020010:	11 10 00 e0 	sethi  %hi(0x40038000), %o0                    <== NOT EXECUTED
40020014:	40 00 0f da 	call  40023f7c <printf>                        <== NOT EXECUTED
40020018:	90 12 21 50 	or  %o0, 0x150, %o0	! 40038150 <CSWTCH.2+0x1560><== NOT EXECUTED
              rc, strerror (rc));                                     
    rtems_rfs_inode_close (fs, &parent_inode);                        
4002001c:	10 bf ff 9a 	b  4001fe84 <rtems_rfs_unlink+0x11c>           <== NOT EXECUTED
40020020:	92 07 bf b0 	add  %fp, -80, %o1                             <== 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);
40020024:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
40020028:	11 10 00 e0 	sethi  %hi(0x40038000), %o0                    <== NOT EXECUTED
4002002c:	95 37 20 10 	srl  %i4, 0x10, %o2                            <== NOT EXECUTED
40020030:	40 00 0f d3 	call  40023f7c <printf>                        <== NOT EXECUTED
40020034:	90 12 20 f8 	or  %o0, 0xf8, %o0                             <== NOT EXECUTED
                                                                      
  if (links > 1)                                                      
40020038:	10 bf ff dc 	b  4001ffa8 <rtems_rfs_unlink+0x240>           <== NOT EXECUTED
4002003c:	b9 37 20 10 	srl  %i4, 0x10, %i4                            <== 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);                     
40020040:	90 10 00 18 	mov  %i0, %o0                                  
40020044:	7f ff c9 69 	call  400125e8 <rtems_rfs_inode_close>         
40020048:	92 07 bf b0 	add  %fp, -80, %o1                             
  if (rc > 0)                                                         
4002004c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40020050:	04 80 00 24 	ble  400200e0 <rtems_rfs_unlink+0x378>         <== ALWAYS TAKEN
40020054:	90 10 20 00 	clr  %o0                                       
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))                     
40020058:	7f ff cf 93 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
4002005c:	13 00 80 00 	sethi  %hi(0x2000000), %o1                     <== NOT EXECUTED
40020060:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40020064:	22 bf ff a3 	be,a   4001fef0 <rtems_rfs_unlink+0x188>       <== NOT EXECUTED
40020068:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
      printf ("rtems-rfs: link: parent inode-close failed: %d: %s\n", 
4002006c:	40 00 14 0e 	call  400250a4 <strerror>                      <== NOT EXECUTED
40020070:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40020074:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
40020078:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
4002007c:	11 10 00 e0 	sethi  %hi(0x40038000), %o0                    <== NOT EXECUTED
40020080:	40 00 0f bf 	call  40023f7c <printf>                        <== NOT EXECUTED
40020084:	90 12 21 88 	or  %o0, 0x188, %o0	! 40038188 <CSWTCH.2+0x1598><== NOT EXECUTED
              rc, strerror (rc));                                     
    rtems_rfs_inode_close (fs, &target_inode);                        
40020088:	10 bf ff 9a 	b  4001fef0 <rtems_rfs_unlink+0x188>           <== NOT EXECUTED
4002008c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
  else                                                                
  {                                                                   
    /*                                                                
     * Erasing the inode releases all blocks attached to it.          
     */                                                               
    rc = rtems_rfs_inode_delete (fs, &target_inode);                  
40020090:	90 10 00 18 	mov  %i0, %o0                                  
40020094:	7f ff c9 7b 	call  40012680 <rtems_rfs_inode_delete>        
40020098:	92 07 bf d8 	add  %fp, -40, %o1                             
    if (rc > 0)                                                       
4002009c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400200a0:	04 80 00 23 	ble  4002012c <rtems_rfs_unlink+0x3c4>         <== ALWAYS TAKEN
400200a4:	90 10 20 00 	clr  %o0                                       
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))                   
400200a8:	7f ff cf 7f 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
400200ac:	13 00 80 00 	sethi  %hi(0x2000000), %o1                     <== NOT EXECUTED
400200b0:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
400200b4:	22 bf ff 74 	be,a   4001fe84 <rtems_rfs_unlink+0x11c>       <== NOT EXECUTED
400200b8:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
        printf ("rtems-rfs: unlink: inode-del failed: %d: %s\n",      
400200bc:	40 00 13 fa 	call  400250a4 <strerror>                      <== NOT EXECUTED
400200c0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
400200c4:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
400200c8:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
400200cc:	11 10 00 e0 	sethi  %hi(0x40038000), %o0                    <== NOT EXECUTED
400200d0:	40 00 0f ab 	call  40023f7c <printf>                        <== NOT EXECUTED
400200d4:	90 12 21 20 	or  %o0, 0x120, %o0	! 40038120 <CSWTCH.2+0x1530><== NOT EXECUTED
  if (rc > 0)                                                         
  {                                                                   
    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);                        
400200d8:	10 bf ff 6b 	b  4001fe84 <rtems_rfs_unlink+0x11c>           <== NOT EXECUTED
400200dc:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
              rc, strerror (rc));                                     
    rtems_rfs_inode_close (fs, &target_inode);                        
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_close (fs, &target_inode);                     
400200e0:	90 10 00 18 	mov  %i0, %o0                                  
400200e4:	7f ff c9 41 	call  400125e8 <rtems_rfs_inode_close>         
400200e8:	92 07 bf d8 	add  %fp, -40, %o1                             
                                                                      
  if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))           
400200ec:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400200f0:	04 bf ff 44 	ble  4001fe00 <rtems_rfs_unlink+0x98>          <== ALWAYS TAKEN
400200f4:	90 10 20 00 	clr  %o0                                       
400200f8:	7f ff cf 6b 	call  40013ea4 <rtems_rfs_trace>               <== NOT EXECUTED
400200fc:	13 00 80 00 	sethi  %hi(0x2000000), %o1                     <== NOT EXECUTED
40020100:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40020104:	02 bf ff 3f 	be  4001fe00 <rtems_rfs_unlink+0x98>           <== NOT EXECUTED
40020108:	01 00 00 00 	nop                                            <== NOT EXECUTED
    printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",   
4002010c:	40 00 13 e6 	call  400250a4 <strerror>                      <== NOT EXECUTED
40020110:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40020114:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
40020118:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
4002011c:	11 10 00 e0 	sethi  %hi(0x40038000), %o0                    <== NOT EXECUTED
40020120:	40 00 0f 97 	call  40023f7c <printf>                        <== NOT EXECUTED
40020124:	90 12 21 c0 	or  %o0, 0x1c0, %o0	! 400381c0 <CSWTCH.2+0x15d0><== NOT EXECUTED
40020128:	30 bf ff 36 	b,a   4001fe00 <rtems_rfs_unlink+0x98>         <== NOT EXECUTED
      rtems_rfs_inode_close (fs, &parent_inode);                      
      rtems_rfs_inode_close (fs, &target_inode);                      
      return rc;                                                      
    }                                                                 
                                                                      
    if (dir)                                                          
4002012c:	80 a4 20 00 	cmp  %l0, 0                                    
40020130:	02 bf ff a9 	be  4001ffd4 <rtems_rfs_unlink+0x26c>          
40020134:	90 07 bf b0 	add  %fp, -80, %o0                             
 */                                                                   
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);                  
40020138:	c4 07 bf bc 	ld  [ %fp + -68 ], %g2                         
  if (links == 0xffff)                                                
4002013c:	3b 00 00 3f 	sethi  %hi(0xfc00), %i5                        
 */                                                                   
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);                  
40020140:	c2 08 a0 01 	ldub  [ %g2 + 1 ], %g1                         
40020144:	c6 08 80 00 	ldub  [ %g2 ], %g3                             
  if (links == 0xffff)                                                
40020148:	ba 17 63 ff 	or  %i5, 0x3ff, %i5                            
 */                                                                   
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);                  
4002014c:	87 28 e0 08 	sll  %g3, 8, %g3                               
40020150:	86 10 c0 01 	or  %g3, %g1, %g3                              
  if (links == 0xffff)                                                
40020154:	89 28 e0 10 	sll  %g3, 0x10, %g4                            
40020158:	89 31 20 10 	srl  %g4, 0x10, %g4                            
4002015c:	80 a1 00 1d 	cmp  %g4, %i5                                  
40020160:	02 80 00 0c 	be  40020190 <rtems_rfs_unlink+0x428>          <== NEVER TAKEN
40020164:	82 10 00 03 	mov  %g3, %g1                                  
    {                                                                 
      links = rtems_rfs_inode_get_links (&parent_inode);              
      if (links > 1)                                                  
40020168:	80 a1 20 01 	cmp  %g4, 1                                    
4002016c:	38 80 00 02 	bgu,a   40020174 <rtems_rfs_unlink+0x40c>      
40020170:	82 00 ff ff 	add  %g3, -1, %g1                              
 * @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);                  
40020174:	87 30 60 08 	srl  %g1, 8, %g3                               
40020178:	c6 28 80 00 	stb  %g3, [ %g2 ]                              
4002017c:	c4 07 bf bc 	ld  [ %fp + -68 ], %g2                         
40020180:	c2 28 a0 01 	stb  %g1, [ %g2 + 1 ]                          
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
40020184:	82 10 20 01 	mov  1, %g1                                    
40020188:	10 bf ff 92 	b  4001ffd0 <rtems_rfs_unlink+0x268>           
4002018c:	c2 2f bf c0 	stb  %g1, [ %fp + -64 ]                        
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)            
{                                                                     
  uint16_t links;                                                     
  links = rtems_rfs_read_u16 (&handle->node->links);                  
  if (links == 0xffff)                                                
    links = 0;                                                        
40020190:	10 bf ff f9 	b  40020174 <rtems_rfs_unlink+0x40c>           <== NOT EXECUTED
40020194:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
                                                                      

40023584 <rtems_shell_rfs_format>: return 1; } int rtems_shell_rfs_format (int argc, char* argv[]) {
40023584:	9d e3 bf 88 	save  %sp, -120, %sp                           <== NOT EXECUTED
  rtems_rfs_format_config config;                                     
  const char*             driver = NULL;                              
  int                     arg;                                        
                                                                      
  memset (&config, 0, sizeof (rtems_rfs_format_config));              
40023588:	c0 27 bf e8 	clr  [ %fp + -24 ]                             <== NOT EXECUTED
4002358c:	c0 27 bf ec 	clr  [ %fp + -20 ]                             <== NOT EXECUTED
40023590:	c0 27 bf f0 	clr  [ %fp + -16 ]                             <== NOT EXECUTED
40023594:	c0 27 bf f4 	clr  [ %fp + -12 ]                             <== NOT EXECUTED
40023598:	c0 27 bf f8 	clr  [ %fp + -8 ]                              <== NOT EXECUTED
4002359c:	c0 27 bf fc 	clr  [ %fp + -4 ]                              <== NOT EXECUTED
                                                                      
  for (arg = 1; arg < argc; arg++)                                    
400235a0:	ba 10 20 01 	mov  1, %i5                                    <== NOT EXECUTED
400235a4:	b8 10 20 00 	clr  %i4                                       <== NOT EXECUTED
  {                                                                   
    if (argv[arg][0] == '-')                                          
    {                                                                 
      switch (argv[arg][1])                                           
400235a8:	37 10 00 87 	sethi  %hi(0x40021c00), %i3                    <== NOT EXECUTED
  const char*             driver = NULL;                              
  int                     arg;                                        
                                                                      
  memset (&config, 0, sizeof (rtems_rfs_format_config));              
                                                                      
  for (arg = 1; arg < argc; arg++)                                    
400235ac:	80 a6 20 01 	cmp  %i0, 1                                    <== NOT EXECUTED
400235b0:	14 80 00 0a 	bg  400235d8 <rtems_shell_rfs_format+0x54>     <== NOT EXECUTED
400235b4:	b4 10 20 01 	mov  1, %i2                                    <== NOT EXECUTED
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if (!driver) {                                                      
    printf ("error: no driver name provided\n");                      
400235b8:	10 80 00 69 	b  4002375c <rtems_shell_rfs_format+0x1d8>     <== NOT EXECUTED
400235bc:	11 10 01 78 	sethi  %hi(0x4005e000), %o0                    <== NOT EXECUTED
          return 1;                                                   
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      if (!driver)                                                    
400235c0:	12 80 00 55 	bne  40023714 <rtems_shell_rfs_format+0x190>   <== NOT EXECUTED
400235c4:	b8 10 00 09 	mov  %o1, %i4                                  <== NOT EXECUTED
  const char*             driver = NULL;                              
  int                     arg;                                        
                                                                      
  memset (&config, 0, sizeof (rtems_rfs_format_config));              
                                                                      
  for (arg = 1; arg < argc; arg++)                                    
400235c8:	ba 07 60 01 	inc  %i5                                       <== NOT EXECUTED
400235cc:	80 a6 00 1d 	cmp  %i0, %i5                                  <== NOT EXECUTED
400235d0:	04 80 00 1d 	ble  40023644 <rtems_shell_rfs_format+0xc0>    <== NOT EXECUTED
400235d4:	80 a7 20 00 	cmp  %i4, 0                                    <== NOT EXECUTED
  {                                                                   
    if (argv[arg][0] == '-')                                          
400235d8:	83 2f 60 02 	sll  %i5, 2, %g1                               <== NOT EXECUTED
400235dc:	d2 06 40 01 	ld  [ %i1 + %g1 ], %o1                         <== NOT EXECUTED
400235e0:	c2 4a 40 00 	ldsb  [ %o1 ], %g1                             <== NOT EXECUTED
400235e4:	80 a0 60 2d 	cmp  %g1, 0x2d                                 <== NOT EXECUTED
400235e8:	12 bf ff f6 	bne  400235c0 <rtems_shell_rfs_format+0x3c>    <== NOT EXECUTED
400235ec:	80 a7 20 00 	cmp  %i4, 0                                    <== NOT EXECUTED
    {                                                                 
      switch (argv[arg][1])                                           
400235f0:	c2 0a 60 01 	ldub  [ %o1 + 1 ], %g1                         <== NOT EXECUTED
400235f4:	82 00 7f b7 	add  %g1, -73, %g1                             <== NOT EXECUTED
400235f8:	82 08 60 ff 	and  %g1, 0xff, %g1                            <== NOT EXECUTED
400235fc:	80 a0 60 2d 	cmp  %g1, 0x2d                                 <== NOT EXECUTED
40023600:	08 80 00 08 	bleu  40023620 <rtems_shell_rfs_format+0x9c>   <== NOT EXECUTED
40023604:	84 16 e3 58 	or  %i3, 0x358, %g2                            <== NOT EXECUTED
          }                                                           
          config.inode_overhead = strtoul (argv[arg], 0, 0);          
          break;                                                      
                                                                      
        default:                                                      
          printf ("error: invalid option: %s\n", argv[arg]);          
40023608:	11 10 01 70 	sethi  %hi(0x4005c000), %o0                    <== NOT EXECUTED
          return 1;                                                   
4002360c:	b0 10 20 01 	mov  1, %i0                                    <== NOT EXECUTED
          }                                                           
          config.inode_overhead = strtoul (argv[arg], 0, 0);          
          break;                                                      
                                                                      
        default:                                                      
          printf ("error: invalid option: %s\n", argv[arg]);          
40023610:	40 00 72 25 	call  4003fea4 <printf>                        <== NOT EXECUTED
40023614:	90 12 22 b0 	or  %o0, 0x2b0, %o0                            <== NOT EXECUTED
40023618:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4002361c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
  for (arg = 1; arg < argc; arg++)                                    
  {                                                                   
    if (argv[arg][0] == '-')                                          
    {                                                                 
      switch (argv[arg][1])                                           
40023620:	83 28 60 02 	sll  %g1, 2, %g1                               <== NOT EXECUTED
40023624:	c2 00 80 01 	ld  [ %g2 + %g1 ], %g1                         <== NOT EXECUTED
40023628:	81 c0 40 00 	jmp  %g1                                       <== NOT EXECUTED
4002362c:	01 00 00 00 	nop                                            <== NOT EXECUTED
  const char*             driver = NULL;                              
  int                     arg;                                        
                                                                      
  memset (&config, 0, sizeof (rtems_rfs_format_config));              
                                                                      
  for (arg = 1; arg < argc; arg++)                                    
40023630:	ba 07 60 01 	inc  %i5                                       <== NOT EXECUTED
40023634:	80 a6 00 1d 	cmp  %i0, %i5                                  <== NOT EXECUTED
40023638:	14 bf ff e8 	bg  400235d8 <rtems_shell_rfs_format+0x54>     <== NOT EXECUTED
4002363c:	f4 2f bf fd 	stb  %i2, [ %fp + -3 ]                         <== NOT EXECUTED
        return 1;                                                     
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if (!driver) {                                                      
40023640:	80 a7 20 00 	cmp  %i4, 0                                    <== NOT EXECUTED
40023644:	02 80 00 45 	be  40023758 <rtems_shell_rfs_format+0x1d4>    <== NOT EXECUTED
40023648:	92 07 bf e8 	add  %fp, -24, %o1                             <== NOT EXECUTED
    printf ("error: no driver name provided\n");                      
    return 1;                                                         
  }                                                                   
                                                                      
  if (rtems_rfs_format (driver, &config) < 0)                         
4002364c:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
40023650:	40 00 3b 15 	call  400322a4 <rtems_rfs_format>              <== NOT EXECUTED
40023654:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
40023658:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4002365c:	06 80 00 34 	bl  4002372c <rtems_shell_rfs_format+0x1a8>    <== NOT EXECUTED
40023660:	01 00 00 00 	nop                                            <== NOT EXECUTED
            driver, strerror (errno));                                
    return 1;                                                         
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
40023664:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40023668:	81 e8 00 00 	restore                                        <== NOT EXECUTED
        case 'v':                                                     
          config.verbose = true;                                      
          break;                                                      
                                                                      
        case 's':                                                     
          arg++;                                                      
4002366c:	ba 07 60 01 	inc  %i5                                       <== NOT EXECUTED
          if (arg >= argc)                                            
40023670:	80 a6 00 1d 	cmp  %i0, %i5                                  <== NOT EXECUTED
40023674:	04 80 00 45 	ble  40023788 <rtems_shell_rfs_format+0x204>   <== NOT EXECUTED
40023678:	83 2f 60 02 	sll  %i5, 2, %g1                               <== NOT EXECUTED
          {                                                           
            printf ("error: block size needs an argument\n");         
            return 1;                                                 
          }                                                           
          config.block_size = strtoul (argv[arg], 0, 0);              
4002367c:	d0 06 40 01 	ld  [ %i1 + %g1 ], %o0                         <== NOT EXECUTED
40023680:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
40023684:	40 00 81 dd 	call  40043df8 <strtoul>                       <== NOT EXECUTED
40023688:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
          break;                                                      
4002368c:	10 bf ff cf 	b  400235c8 <rtems_shell_rfs_format+0x44>      <== NOT EXECUTED
40023690:	d0 27 bf e8 	st  %o0, [ %fp + -24 ]                         <== NOT EXECUTED
        case 'I':                                                     
          config.initialise_inodes = true;                            
          break;                                                      
                                                                      
        case 'o':                                                     
          arg++;                                                      
40023694:	ba 07 60 01 	inc  %i5                                       <== NOT EXECUTED
          if (arg >= argc)                                            
40023698:	80 a6 00 1d 	cmp  %i0, %i5                                  <== NOT EXECUTED
4002369c:	04 80 00 47 	ble  400237b8 <rtems_shell_rfs_format+0x234>   <== NOT EXECUTED
400236a0:	83 2f 60 02 	sll  %i5, 2, %g1                               <== NOT EXECUTED
          {                                                           
            printf ("error: inode percentage overhead needs an argument\n");
            return 1;                                                 
          }                                                           
          config.inode_overhead = strtoul (argv[arg], 0, 0);          
400236a4:	d0 06 40 01 	ld  [ %i1 + %g1 ], %o0                         <== NOT EXECUTED
400236a8:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
400236ac:	40 00 81 d3 	call  40043df8 <strtoul>                       <== NOT EXECUTED
400236b0:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
          break;                                                      
400236b4:	10 bf ff c5 	b  400235c8 <rtems_shell_rfs_format+0x44>      <== NOT EXECUTED
400236b8:	d0 27 bf f4 	st  %o0, [ %fp + -12 ]                         <== NOT EXECUTED
          }                                                           
          config.group_blocks = strtoul (argv[arg], 0, 0);            
          break;                                                      
                                                                      
        case 'i':                                                     
          arg++;                                                      
400236bc:	ba 07 60 01 	inc  %i5                                       <== NOT EXECUTED
          if (arg >= argc)                                            
400236c0:	80 a6 00 1d 	cmp  %i0, %i5                                  <== NOT EXECUTED
400236c4:	04 80 00 37 	ble  400237a0 <rtems_shell_rfs_format+0x21c>   <== NOT EXECUTED
400236c8:	83 2f 60 02 	sll  %i5, 2, %g1                               <== NOT EXECUTED
          {                                                           
            printf ("error: group inode count needs an argument\n");  
            return 1;                                                 
          }                                                           
          config.group_inodes = strtoul (argv[arg], 0, 0);            
400236cc:	d0 06 40 01 	ld  [ %i1 + %g1 ], %o0                         <== NOT EXECUTED
400236d0:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
400236d4:	40 00 81 c9 	call  40043df8 <strtoul>                       <== NOT EXECUTED
400236d8:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
          break;                                                      
400236dc:	10 bf ff bb 	b  400235c8 <rtems_shell_rfs_format+0x44>      <== NOT EXECUTED
400236e0:	d0 27 bf f0 	st  %o0, [ %fp + -16 ]                         <== NOT EXECUTED
          }                                                           
          config.block_size = strtoul (argv[arg], 0, 0);              
          break;                                                      
                                                                      
        case 'b':                                                     
          arg++;                                                      
400236e4:	ba 07 60 01 	inc  %i5                                       <== NOT EXECUTED
          if (arg >= argc)                                            
400236e8:	80 a6 00 1d 	cmp  %i0, %i5                                  <== NOT EXECUTED
400236ec:	04 80 00 21 	ble  40023770 <rtems_shell_rfs_format+0x1ec>   <== NOT EXECUTED
400236f0:	83 2f 60 02 	sll  %i5, 2, %g1                               <== NOT EXECUTED
          {                                                           
            printf ("error: group block count needs an argument\n");  
            return 1;                                                 
          }                                                           
          config.group_blocks = strtoul (argv[arg], 0, 0);            
400236f4:	d0 06 40 01 	ld  [ %i1 + %g1 ], %o0                         <== NOT EXECUTED
400236f8:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
400236fc:	40 00 81 bf 	call  40043df8 <strtoul>                       <== NOT EXECUTED
40023700:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
          break;                                                      
40023704:	10 bf ff b1 	b  400235c8 <rtems_shell_rfs_format+0x44>      <== NOT EXECUTED
40023708:	d0 27 bf ec 	st  %o0, [ %fp + -20 ]                         <== NOT EXECUTED
          config.group_inodes = strtoul (argv[arg], 0, 0);            
          break;                                                      
                                                                      
        case 'I':                                                     
          config.initialise_inodes = true;                            
          break;                                                      
4002370c:	10 bf ff af 	b  400235c8 <rtems_shell_rfs_format+0x44>      <== NOT EXECUTED
40023710:	f4 2f bf fc 	stb  %i2, [ %fp + -4 ]                         <== NOT EXECUTED
    {                                                                 
      if (!driver)                                                    
        driver = argv[arg];                                           
      else                                                            
      {                                                               
        printf ("error: only one driver name allowed: %s\n", argv[arg]);
40023714:	11 10 01 78 	sethi  %hi(0x4005e000), %o0                    <== NOT EXECUTED
        return 1;                                                     
40023718:	b0 10 20 01 	mov  1, %i0                                    <== NOT EXECUTED
    {                                                                 
      if (!driver)                                                    
        driver = argv[arg];                                           
      else                                                            
      {                                                               
        printf ("error: only one driver name allowed: %s\n", argv[arg]);
4002371c:	40 00 71 e2 	call  4003fea4 <printf>                        <== NOT EXECUTED
40023720:	90 12 22 78 	or  %o0, 0x278, %o0                            <== NOT EXECUTED
40023724:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40023728:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  if (rtems_rfs_format (driver, &config) < 0)                         
  {                                                                   
    printf ("error: format of %s failed: %s\n",                       
            driver, strerror (errno));                                
4002372c:	40 00 5f 8f 	call  4003b568 <__errno>                       <== NOT EXECUTED
40023730:	b0 10 20 01 	mov  1, %i0                                    <== NOT EXECUTED
    return 1;                                                         
  }                                                                   
                                                                      
  if (rtems_rfs_format (driver, &config) < 0)                         
  {                                                                   
    printf ("error: format of %s failed: %s\n",                       
40023734:	40 00 7b 34 	call  40042404 <strerror>                      <== NOT EXECUTED
40023738:	d0 02 00 00 	ld  [ %o0 ], %o0                               <== NOT EXECUTED
4002373c:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
40023740:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40023744:	11 10 01 78 	sethi  %hi(0x4005e000), %o0                    <== NOT EXECUTED
40023748:	40 00 71 d7 	call  4003fea4 <printf>                        <== NOT EXECUTED
4002374c:	90 12 22 a8 	or  %o0, 0x2a8, %o0	! 4005e2a8 <rtems_rtc_shell_usage+0x18a0><== NOT EXECUTED
            driver, strerror (errno));                                
    return 1;                                                         
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
40023750:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40023754:	81 e8 00 00 	restore                                        <== NOT EXECUTED
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if (!driver) {                                                      
    printf ("error: no driver name provided\n");                      
40023758:	11 10 01 78 	sethi  %hi(0x4005e000), %o0                    <== NOT EXECUTED
    return 1;                                                         
4002375c:	b0 10 20 01 	mov  1, %i0                                    <== NOT EXECUTED
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if (!driver) {                                                      
    printf ("error: no driver name provided\n");                      
40023760:	40 00 72 69 	call  40040104 <puts>                          <== NOT EXECUTED
40023764:	90 12 21 98 	or  %o0, 0x198, %o0                            <== NOT EXECUTED
40023768:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4002376c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
        case 'b':                                                     
          arg++;                                                      
          if (arg >= argc)                                            
          {                                                           
            printf ("error: group block count needs an argument\n");  
40023770:	11 10 01 78 	sethi  %hi(0x4005e000), %o0                    <== NOT EXECUTED
            return 1;                                                 
40023774:	b0 10 20 01 	mov  1, %i0                                    <== NOT EXECUTED
                                                                      
        case 'b':                                                     
          arg++;                                                      
          if (arg >= argc)                                            
          {                                                           
            printf ("error: group block count needs an argument\n");  
40023778:	40 00 72 63 	call  40040104 <puts>                          <== NOT EXECUTED
4002377c:	90 12 21 e0 	or  %o0, 0x1e0, %o0                            <== NOT EXECUTED
40023780:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40023784:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
        case 's':                                                     
          arg++;                                                      
          if (arg >= argc)                                            
          {                                                           
            printf ("error: block size needs an argument\n");         
40023788:	11 10 01 78 	sethi  %hi(0x4005e000), %o0                    <== NOT EXECUTED
            return 1;                                                 
4002378c:	b0 10 20 01 	mov  1, %i0                                    <== NOT EXECUTED
                                                                      
        case 's':                                                     
          arg++;                                                      
          if (arg >= argc)                                            
          {                                                           
            printf ("error: block size needs an argument\n");         
40023790:	40 00 72 5d 	call  40040104 <puts>                          <== NOT EXECUTED
40023794:	90 12 21 b8 	or  %o0, 0x1b8, %o0                            <== NOT EXECUTED
40023798:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4002379c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
        case 'i':                                                     
          arg++;                                                      
          if (arg >= argc)                                            
          {                                                           
            printf ("error: group inode count needs an argument\n");  
400237a0:	11 10 01 78 	sethi  %hi(0x4005e000), %o0                    <== NOT EXECUTED
            return 1;                                                 
400237a4:	b0 10 20 01 	mov  1, %i0                                    <== NOT EXECUTED
                                                                      
        case 'i':                                                     
          arg++;                                                      
          if (arg >= argc)                                            
          {                                                           
            printf ("error: group inode count needs an argument\n");  
400237a8:	40 00 72 57 	call  40040104 <puts>                          <== NOT EXECUTED
400237ac:	90 12 22 10 	or  %o0, 0x210, %o0                            <== NOT EXECUTED
400237b0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400237b4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
        case 'o':                                                     
          arg++;                                                      
          if (arg >= argc)                                            
          {                                                           
            printf ("error: inode percentage overhead needs an argument\n");
400237b8:	11 10 01 78 	sethi  %hi(0x4005e000), %o0                    <== NOT EXECUTED
            return 1;                                                 
400237bc:	b0 10 20 01 	mov  1, %i0                                    <== NOT EXECUTED
                                                                      
        case 'o':                                                     
          arg++;                                                      
          if (arg >= argc)                                            
          {                                                           
            printf ("error: inode percentage overhead needs an argument\n");
400237c0:	40 00 72 51 	call  40040104 <puts>                          <== NOT EXECUTED
400237c4:	90 12 22 40 	or  %o0, 0x240, %o0                            <== NOT EXECUTED
400237c8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400237cc:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40016590 <rtems_signal_send>: rtems_status_code rtems_signal_send( rtems_id id, rtems_signal_set signal_set ) {
40016590:	9d e3 bf 98 	save  %sp, -104, %sp                           
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
  RTEMS_API_Control       *api;                                       
  ASR_Information         *asr;                                       
                                                                      
  if ( !signal_set )                                                  
40016594:	80 a6 60 00 	cmp  %i1, 0                                    
40016598:	12 80 00 04 	bne  400165a8 <rtems_signal_send+0x18>         
4001659c:	82 10 20 0a 	mov  0xa, %g1                                  
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
400165a0:	81 c7 e0 08 	ret                                            
400165a4:	91 e8 00 01 	restore  %g0, %g1, %o0                         
  ASR_Information         *asr;                                       
                                                                      
  if ( !signal_set )                                                  
    return RTEMS_INVALID_NUMBER;                                      
                                                                      
  the_thread = _Thread_Get( id, &location );                          
400165a8:	90 10 00 18 	mov  %i0, %o0                                  
400165ac:	40 00 13 a5 	call  4001b440 <_Thread_Get>                   
400165b0:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
400165b4:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
400165b8:	80 a0 60 00 	cmp  %g1, 0                                    
400165bc:	12 80 00 20 	bne  4001663c <rtems_signal_send+0xac>         
400165c0:	b8 10 00 08 	mov  %o0, %i4                                  
                                                                      
    case OBJECTS_LOCAL:                                               
      api = the_thread->API_Extensions[ THREAD_API_RTEMS ];           
400165c4:	fa 02 21 4c 	ld  [ %o0 + 0x14c ], %i5                       
      asr = &api->Signal;                                             
                                                                      
      if ( ! _ASR_Is_null_handler( asr->handler ) ) {                 
400165c8:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
400165cc:	80 a0 60 00 	cmp  %g1, 0                                    
400165d0:	02 80 00 1e 	be  40016648 <rtems_signal_send+0xb8>          
400165d4:	01 00 00 00 	nop                                            
        if ( asr->is_enabled ) {                                      
400165d8:	c2 0f 60 08 	ldub  [ %i5 + 8 ], %g1                         
400165dc:	80 a0 60 00 	cmp  %g1, 0                                    
400165e0:	02 80 00 1e 	be  40016658 <rtems_signal_send+0xc8>          
400165e4:	01 00 00 00 	nop                                            
  rtems_signal_set *signal_set                                        
)                                                                     
{                                                                     
  ISR_Level              _level;                                      
                                                                      
  _ISR_Disable( _level );                                             
400165e8:	7f ff e2 ea 	call  4000f190 <sparc_disable_interrupts>      
400165ec:	01 00 00 00 	nop                                            
    *signal_set |= signals;                                           
400165f0:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
400165f4:	b2 10 40 19 	or  %g1, %i1, %i1                              
400165f8:	f2 27 60 14 	st  %i1, [ %i5 + 0x14 ]                        
  _ISR_Enable( _level );                                              
400165fc:	7f ff e2 e9 	call  4000f1a0 <sparc_enable_interrupts>       
40016600:	01 00 00 00 	nop                                            
          _ASR_Post_signals( signal_set, &asr->signals_posted );      
                                                                      
          if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
40016604:	03 10 00 f6 	sethi  %hi(0x4003d800), %g1                    
40016608:	82 10 61 90 	or  %g1, 0x190, %g1	! 4003d990 <_Per_CPU_Information>
4001660c:	c4 00 60 08 	ld  [ %g1 + 8 ], %g2                           
40016610:	80 a0 a0 00 	cmp  %g2, 0                                    
40016614:	02 80 00 06 	be  4001662c <rtems_signal_send+0x9c>          
40016618:	01 00 00 00 	nop                                            
4001661c:	c4 00 60 10 	ld  [ %g1 + 0x10 ], %g2                        
40016620:	80 a7 00 02 	cmp  %i4, %g2                                  
40016624:	02 80 00 15 	be  40016678 <rtems_signal_send+0xe8>          <== ALWAYS TAKEN
40016628:	84 10 20 01 	mov  1, %g2                                    
            _Thread_Dispatch_necessary = true;                        
        } else {                                                      
          _ASR_Post_signals( signal_set, &asr->signals_pending );     
        }                                                             
        _Thread_Enable_dispatch();                                    
4001662c:	40 00 13 79 	call  4001b410 <_Thread_Enable_dispatch>       
40016630:	01 00 00 00 	nop                                            
        return RTEMS_SUCCESSFUL;                                      
40016634:	10 bf ff db 	b  400165a0 <rtems_signal_send+0x10>           
40016638:	82 10 20 00 	clr  %g1	! 0 <PROM_START>                      
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
4001663c:	82 10 20 04 	mov  4, %g1                                    
}                                                                     
40016640:	81 c7 e0 08 	ret                                            
40016644:	91 e8 00 01 	restore  %g0, %g1, %o0                         
          _ASR_Post_signals( signal_set, &asr->signals_pending );     
        }                                                             
        _Thread_Enable_dispatch();                                    
        return RTEMS_SUCCESSFUL;                                      
      }                                                               
      _Thread_Enable_dispatch();                                      
40016648:	40 00 13 72 	call  4001b410 <_Thread_Enable_dispatch>       
4001664c:	01 00 00 00 	nop                                            
      return RTEMS_NOT_DEFINED;                                       
40016650:	10 bf ff d4 	b  400165a0 <rtems_signal_send+0x10>           
40016654:	82 10 20 0b 	mov  0xb, %g1	! b <PROM_START+0xb>             
  rtems_signal_set *signal_set                                        
)                                                                     
{                                                                     
  ISR_Level              _level;                                      
                                                                      
  _ISR_Disable( _level );                                             
40016658:	7f ff e2 ce 	call  4000f190 <sparc_disable_interrupts>      
4001665c:	01 00 00 00 	nop                                            
    *signal_set |= signals;                                           
40016660:	c2 07 60 18 	ld  [ %i5 + 0x18 ], %g1                        
40016664:	b2 10 40 19 	or  %g1, %i1, %i1                              
40016668:	f2 27 60 18 	st  %i1, [ %i5 + 0x18 ]                        
  _ISR_Enable( _level );                                              
4001666c:	7f ff e2 cd 	call  4000f1a0 <sparc_enable_interrupts>       
40016670:	01 00 00 00 	nop                                            
40016674:	30 bf ff ee 	b,a   4001662c <rtems_signal_send+0x9c>        
      if ( ! _ASR_Is_null_handler( asr->handler ) ) {                 
        if ( asr->is_enabled ) {                                      
          _ASR_Post_signals( signal_set, &asr->signals_posted );      
                                                                      
          if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
            _Thread_Dispatch_necessary = true;                        
40016678:	c4 28 60 0c 	stb  %g2, [ %g1 + 0xc ]                        
4001667c:	30 bf ff ec 	b,a   4001662c <rtems_signal_send+0x9c>        
                                                                      

4000ef10 <rtems_sparse_disk_create_and_register>: const char *device_file_name, uint32_t media_block_size, rtems_blkdev_bnum blocks_with_buffer, rtems_blkdev_bnum media_block_count, uint8_t fill_pattern ) {
4000ef10:	9d e3 bf 98 	save  %sp, -104, %sp                           
  const rtems_blkdev_bnum blocks_with_buffer )                        
{                                                                     
  size_t const key_table_size = blocks_with_buffer                    
                                * sizeof( rtems_sparse_disk_key );    
  size_t const data_size      = blocks_with_buffer * media_block_size;
  size_t const alloc_size     = sizeof( rtems_sparse_disk )           
4000ef14:	92 10 00 1a 	mov  %i2, %o1                                  
4000ef18:	7f ff cd 9d 	call  4000258c <.umul>                         
4000ef1c:	90 06 60 08 	add  %i1, 8, %o0                               
                                + key_table_size + data_size;         
                                                                      
  rtems_sparse_disk *const sd = (rtems_sparse_disk *) malloc(         
4000ef20:	7f ff d8 76 	call  400050f8 <malloc>                        
4000ef24:	90 02 20 1c 	add  %o0, 0x1c, %o0                            
4000ef28:	92 10 00 08 	mov  %o0, %o1                                  
  rtems_sparse_disk *sparse_disk = sparse_disk_allocate(              
    media_block_size,                                                 
    blocks_with_buffer                                                
  );                                                                  
                                                                      
  if ( sparse_disk != NULL ) {                                        
4000ef2c:	80 a2 60 00 	cmp  %o1, 0                                    
4000ef30:	02 80 00 0b 	be  4000ef5c <rtems_sparse_disk_create_and_register+0x4c><== NEVER TAKEN
4000ef34:	90 10 20 1a 	mov  0x1a, %o0                                 
    sc = rtems_sparse_disk_register(                                  
4000ef38:	03 10 00 3b 	sethi  %hi(0x4000ec00), %g1                    
4000ef3c:	82 10 62 18 	or  %g1, 0x218, %g1	! 4000ee18 <rtems_sparse_disk_free>
4000ef40:	90 10 00 18 	mov  %i0, %o0                                  
4000ef44:	c2 23 a0 5c 	st  %g1, [ %sp + 0x5c ]                        
4000ef48:	94 10 00 19 	mov  %i1, %o2                                  
4000ef4c:	96 10 00 1a 	mov  %i2, %o3                                  
4000ef50:	98 10 00 1b 	mov  %i3, %o4                                  
4000ef54:	7f ff ff b4 	call  4000ee24 <rtems_sparse_disk_register>    
4000ef58:	9a 10 00 1c 	mov  %i4, %o5                                  
  } else {                                                            
    sc = RTEMS_NO_MEMORY;                                             
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
4000ef5c:	81 c7 e0 08 	ret                                            
4000ef60:	91 e8 00 08 	restore  %g0, %o0, %o0                         
4000ef64:	40 00 ff e0 	call  4004eee4 <__end+0x1fe54>                 <== NOT EXECUTED
4000ef68:	40 01 01 7c 	call  4004f558 <__end+0x204c8>                 <== NOT EXECUTED
4000ef6c:	40 01 01 74 	call  4004f53c <__end+0x204ac>                 <== NOT EXECUTED
4000ef70:	40 01 01 60 	call  4004f4f0 <__end+0x20460>                 <== NOT EXECUTED
4000ef74:	40 01 01 60 	call  4004f4f4 <__end+0x20464>                 <== NOT EXECUTED
4000ef78:	40 01 01 60 	call  4004f4f8 <__end+0x20468>                 <== NOT EXECUTED
4000ef7c:	40 01 01 60 	call  4004f4fc <__end+0x2046c>                 <== NOT EXECUTED
4000ef80:	40 01 01 2c 	call  4004f430 <__end+0x203a0>                 <== NOT EXECUTED
4000ef84:	40 01 01 18 	call  4004f3e4 <__end+0x20354>                 <== NOT EXECUTED
4000ef88:	40 01 01 18 	call  4004f3e8 <__end+0x20358>                 <== NOT EXECUTED
4000ef8c:	40 01 01 18 	call  4004f3ec <__end+0x2035c>                 <== NOT EXECUTED
4000ef90:	40 01 00 28 	call  4004f030 <__end+0x1ffa0>                 <== NOT EXECUTED
4000ef94:	40 01 00 18 	call  4004eff4 <__end+0x1ff64>                 <== NOT EXECUTED
4000ef98:	40 01 00 18 	call  4004eff8 <__end+0x1ff68>                 <== NOT EXECUTED
4000ef9c:	40 01 00 f4 	call  4004f36c <__end+0x202dc>                 <== NOT EXECUTED
4000efa0:	40 01 00 f4 	call  4004f370 <__end+0x202e0>                 <== NOT EXECUTED
4000efa4:	40 01 00 f4 	call  4004f374 <__end+0x202e4>                 <== NOT EXECUTED
4000efa8:	40 01 00 f4 	call  4004f378 <__end+0x202e8>                 <== NOT EXECUTED
4000efac:	40 01 00 c0 	call  4004f2ac <__end+0x2021c>                 <== NOT EXECUTED
4000efb0:	40 01 00 ac 	call  4004f260 <__end+0x201d0>                 <== NOT EXECUTED
4000efb4:	40 01 00 ac 	call  4004f264 <__end+0x201d4>                 <== NOT EXECUTED
4000efb8:	40 01 00 ac 	call  4004f268 <__end+0x201d8>                 <== NOT EXECUTED
4000efbc:	40 01 16 2c 	call  4005486c <__end+0x257dc>                 <== NOT EXECUTED
4000efc0:	40 01 16 2c 	call  40054870 <__end+0x257e0>                 <== NOT EXECUTED
4000efc4:	40 01 17 54 	call  40054d14 <__end+0x25c84>                 <== NOT EXECUTED
4000efc8:	40 01 17 7c 	call  40054db8 <__end+0x25d28>                 <== NOT EXECUTED
4000efcc:	40 01 17 7c 	call  40054dbc <__end+0x25d2c>                 <== NOT EXECUTED
4000efd0:	40 01 17 7c 	call  40054dc0 <__end+0x25d30>                 <== NOT EXECUTED
4000efd4:	40 01 16 2c 	call  40054884 <__end+0x257f4>                 <== NOT EXECUTED
4000efd8:	40 01 17 44 	call  40054ce8 <__end+0x25c58>                 <== NOT EXECUTED
4000efdc:	40 01 17 3c 	call  40054ccc <__end+0x25c3c>                 <== NOT EXECUTED
4000efe0:	40 01 17 84 	call  40054df0 <__end+0x25d60>                 <== NOT EXECUTED
4000efe4:	40 01 16 2c 	call  40054894 <__end+0x25804>                 <== NOT EXECUTED
                                                                      

4000ee24 <rtems_sparse_disk_register>: uint32_t media_block_size, rtems_blkdev_bnum blocks_with_buffer, rtems_blkdev_bnum media_block_count, uint8_t fill_pattern, rtems_sparse_disk_delete_handler sparse_disk_delete ) {
4000ee24:	9d e3 bf a0 	save  %sp, -96, %sp                            
4000ee28:	a2 10 00 18 	mov  %i0, %l1                                  
4000ee2c:	a0 10 00 19 	mov  %i1, %l0                                  
        sparse_disk_ioctl,                                            
        sparse_disk                                                   
      );                                                              
    }                                                                 
  } else {                                                            
    sc = RTEMS_INVALID_NUMBER;                                        
4000ee30:	b0 10 20 0a 	mov  0xa, %i0                                  
  uint8_t                          fill_pattern,                      
  rtems_sparse_disk_delete_handler sparse_disk_delete )               
{                                                                     
  rtems_status_code sc;                                               
                                                                      
  if ( blocks_with_buffer <= media_block_count ) {                    
4000ee34:	80 a6 c0 1c 	cmp  %i3, %i4                                  
4000ee38:	08 80 00 04 	bleu  4000ee48 <rtems_sparse_disk_register+0x24><== ALWAYS TAKEN
4000ee3c:	f2 07 a0 5c 	ld  [ %fp + 0x5c ], %i1                        
  } else {                                                            
    sc = RTEMS_INVALID_NUMBER;                                        
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
4000ee40:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000ee44:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  const uint8_t                                                     fill_pattern )
{                                                                     
  rtems_status_code sc;                                               
  rtems_blkdev_bnum i;                                                
                                                                      
  if ( NULL == sd )                                                   
4000ee48:	80 a4 20 00 	cmp  %l0, 0                                    
4000ee4c:	02 80 00 2f 	be  4000ef08 <rtems_sparse_disk_register+0xe4> <== NEVER TAKEN
4000ee50:	92 10 20 00 	clr  %o1                                       
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  uint8_t     *data           = (uint8_t *) sd;                       
  size_t const key_table_size = blocks_with_buffer                    
4000ee54:	a5 2e e0 03 	sll  %i3, 3, %l2                               
                                * sizeof( rtems_sparse_disk_key );    
  size_t const data_size      = blocks_with_buffer * media_block_size;
                                                                      
  memset( data, 0, sizeof( rtems_sparse_disk ) + key_table_size );    
4000ee58:	90 10 00 10 	mov  %l0, %o0                                  
4000ee5c:	b0 04 a0 1c 	add  %l2, 0x1c, %i0                            
4000ee60:	40 00 38 2e 	call  4001cf18 <memset>                        
4000ee64:	94 10 00 18 	mov  %i0, %o2                                  
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  uint8_t     *data           = (uint8_t *) sd;                       
  size_t const key_table_size = blocks_with_buffer                    
                                * sizeof( rtems_sparse_disk_key );    
  size_t const data_size      = blocks_with_buffer * media_block_size;
4000ee68:	92 10 00 1a 	mov  %i2, %o1                                  
                                                                      
  memset( data, 0, sizeof( rtems_sparse_disk ) + key_table_size );    
                                                                      
  sd->fill_pattern = fill_pattern;                                    
4000ee6c:	fa 2c 20 14 	stb  %i5, [ %l0 + 0x14 ]                       
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  uint8_t     *data           = (uint8_t *) sd;                       
  size_t const key_table_size = blocks_with_buffer                    
                                * sizeof( rtems_sparse_disk_key );    
  size_t const data_size      = blocks_with_buffer * media_block_size;
4000ee70:	7f ff cd c7 	call  4000258c <.umul>                         
4000ee74:	90 10 00 1b 	mov  %i3, %o0                                  
                                                                      
  memset( data, 0, sizeof( rtems_sparse_disk ) + key_table_size );    
                                                                      
  sd->fill_pattern = fill_pattern;                                    
  memset( (uint8_t *) ( data + sizeof( rtems_sparse_disk ) + key_table_size ),
4000ee78:	b0 04 00 18 	add  %l0, %i0, %i0                             
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  uint8_t     *data           = (uint8_t *) sd;                       
  size_t const key_table_size = blocks_with_buffer                    
                                * sizeof( rtems_sparse_disk_key );    
  size_t const data_size      = blocks_with_buffer * media_block_size;
4000ee7c:	94 10 00 08 	mov  %o0, %o2                                  
                                                                      
  memset( data, 0, sizeof( rtems_sparse_disk ) + key_table_size );    
                                                                      
  sd->fill_pattern = fill_pattern;                                    
  memset( (uint8_t *) ( data + sizeof( rtems_sparse_disk ) + key_table_size ),
4000ee80:	92 10 00 1d 	mov  %i5, %o1                                  
4000ee84:	40 00 38 25 	call  4001cf18 <memset>                        
4000ee88:	90 10 00 18 	mov  %i0, %o0                                  
          sd->fill_pattern,                                           
          data_size );                                                
                                                                      
  sd->delete_handler = sparse_disk_delete;                            
                                                                      
  sc                 = rtems_semaphore_create(                        
4000ee8c:	92 10 20 01 	mov  1, %o1                                    
  sd->fill_pattern = fill_pattern;                                    
  memset( (uint8_t *) ( data + sizeof( rtems_sparse_disk ) + key_table_size ),
          sd->fill_pattern,                                           
          data_size );                                                
                                                                      
  sd->delete_handler = sparse_disk_delete;                            
4000ee90:	f2 24 20 10 	st  %i1, [ %l0 + 0x10 ]                        
                                                                      
  sc                 = rtems_semaphore_create(                        
4000ee94:	94 10 20 54 	mov  0x54, %o2                                 
4000ee98:	11 14 d4 10 	sethi  %hi(0x53504000), %o0                    
4000ee9c:	96 10 20 00 	clr  %o3                                       
4000eea0:	90 12 21 52 	or  %o0, 0x152, %o0                            
4000eea4:	7f ff e8 ad 	call  40009158 <rtems_semaphore_create>        
4000eea8:	98 10 00 10 	mov  %l0, %o4                                  
    RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY, 
    0,                                                                
    &sd->mutex                                                        
    );                                                                
                                                                      
  if ( sc != RTEMS_SUCCESSFUL ) {                                     
4000eeac:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4000eeb0:	12 bf ff e4 	bne  4000ee40 <rtems_sparse_disk_register+0x1c><== NEVER TAKEN
4000eeb4:	84 04 20 1c 	add  %l0, 0x1c, %g2                            
    return sc;                                                        
  }                                                                   
                                                                      
  data                  += sizeof( rtems_sparse_disk );               
                                                                      
  sd->blocks_with_buffer = blocks_with_buffer;                        
4000eeb8:	f6 24 20 04 	st  %i3, [ %l0 + 4 ]                           
  sd->key_table          = (rtems_sparse_disk_key *) data;            
4000eebc:	c4 24 20 18 	st  %g2, [ %l0 + 0x18 ]                        
                                                                      
  data                  += key_table_size;                            
                                                                      
  for ( i = 0; i < blocks_with_buffer; ++i, data += media_block_size ) {
4000eec0:	82 10 20 00 	clr  %g1                                       
4000eec4:	80 a6 e0 00 	cmp  %i3, 0                                    
4000eec8:	02 80 00 08 	be  4000eee8 <rtems_sparse_disk_register+0xc4> <== NEVER TAKEN
4000eecc:	84 00 80 12 	add  %g2, %l2, %g2                             
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
                                                                      
rtems_status_code rtems_sparse_disk_register(                         
4000eed0:	86 04 00 01 	add  %l0, %g1, %g3                             
  sd->key_table          = (rtems_sparse_disk_key *) data;            
                                                                      
  data                  += key_table_size;                            
                                                                      
  for ( i = 0; i < blocks_with_buffer; ++i, data += media_block_size ) {
    sd->key_table[i].data = data;                                     
4000eed4:	c4 20 e0 20 	st  %g2, [ %g3 + 0x20 ]                        
4000eed8:	82 00 60 08 	add  %g1, 8, %g1                               
  sd->blocks_with_buffer = blocks_with_buffer;                        
  sd->key_table          = (rtems_sparse_disk_key *) data;            
                                                                      
  data                  += key_table_size;                            
                                                                      
  for ( i = 0; i < blocks_with_buffer; ++i, data += media_block_size ) {
4000eedc:	80 a4 80 01 	cmp  %l2, %g1                                  
4000eee0:	12 bf ff fc 	bne  4000eed0 <rtems_sparse_disk_register+0xac>
4000eee4:	84 00 80 1a 	add  %g2, %i2, %g2                             
    sd->key_table[i].data = data;                                     
  }                                                                   
                                                                      
  sd->media_block_size = media_block_size;                            
4000eee8:	f4 24 20 0c 	st  %i2, [ %l0 + 0xc ]                         
      sparse_disk_delete,                                             
      fill_pattern                                                    
    );                                                                
                                                                      
    if ( RTEMS_SUCCESSFUL == sc ) {                                   
      sc = rtems_blkdev_create(                                       
4000eeec:	b2 10 00 1a 	mov  %i2, %i1                                  
4000eef0:	37 10 00 3a 	sethi  %hi(0x4000e800), %i3                    
4000eef4:	b4 10 00 1c 	mov  %i4, %i2                                  
4000eef8:	b0 10 00 11 	mov  %l1, %i0                                  
4000eefc:	b6 16 e3 40 	or  %i3, 0x340, %i3                            
4000ef00:	40 00 0b 63 	call  40011c8c <rtems_blkdev_create>           
4000ef04:	99 e8 00 10 	restore  %g0, %l0, %o4                         
  } else {                                                            
    sc = RTEMS_INVALID_NUMBER;                                        
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
4000ef08:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000ef0c:	91 e8 20 09 	restore  %g0, 9, %o0                           <== NOT EXECUTED
                                                                      

40025190 <rtems_stack_checker_begin_extension>: Thread_Control *the_thread ) { Stack_check_Control *the_pattern; if ( the_thread->Object.id == 0 ) /* skip system tasks */
40025190:	c2 02 20 08 	ld  [ %o0 + 8 ], %g1                           
40025194:	80 a0 60 00 	cmp  %g1, 0                                    
40025198:	02 80 00 0c 	be  400251c8 <rtems_stack_checker_begin_extension+0x38><== NEVER TAKEN
4002519c:	05 10 01 a3 	sethi  %hi(0x40068c00), %g2                    
    return;                                                           
                                                                      
  the_pattern = Stack_check_Get_pattern_area(&the_thread->Start.Initial_stack);
                                                                      
  *the_pattern = Stack_check_Pattern;                                 
400251a0:	c2 02 20 b8 	ld  [ %o0 + 0xb8 ], %g1                        
400251a4:	c6 00 a2 dc 	ld  [ %g2 + 0x2dc ], %g3                       
400251a8:	84 10 a2 dc 	or  %g2, 0x2dc, %g2                            
400251ac:	c6 20 60 08 	st  %g3, [ %g1 + 8 ]                           
400251b0:	c6 00 a0 04 	ld  [ %g2 + 4 ], %g3                           
400251b4:	c6 20 60 0c 	st  %g3, [ %g1 + 0xc ]                         
400251b8:	c6 00 a0 08 	ld  [ %g2 + 8 ], %g3                           
400251bc:	c6 20 60 10 	st  %g3, [ %g1 + 0x10 ]                        
400251c0:	c4 00 a0 0c 	ld  [ %g2 + 0xc ], %g2                         
400251c4:	c4 20 60 14 	st  %g2, [ %g1 + 0x14 ]                        
400251c8:	81 c3 e0 08 	retl                                           
                                                                      

400250dc <rtems_stack_checker_create_extension>: */ bool rtems_stack_checker_create_extension( Thread_Control *running __attribute__((unused)), Thread_Control *the_thread ) {
400250dc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  static    uint32_t pattern[ 4 ] = {                                 
    0xFEEDF00D, 0x0BAD0D06,  /* FEED FOOD to  BAD DOG */              
    0xDEADF00D, 0x600D0D06   /* DEAD FOOD but GOOD DOG */             
  };                                                                  
                                                                      
  if ( Stack_check_Initialized )                                      
400250e0:	3b 10 01 9f 	sethi  %hi(0x40067c00), %i5                    
400250e4:	c2 07 60 f8 	ld  [ %i5 + 0xf8 ], %g1	! 40067cf8 <Stack_check_Initialized>
400250e8:	80 a0 60 00 	cmp  %g1, 0                                    
400250ec:	12 80 00 20 	bne  4002516c <rtems_stack_checker_create_extension+0x90>
400250f0:	07 10 01 a3 	sethi  %hi(0x40068c00), %g3                    
  /*                                                                  
   * Dope the pattern and fill areas                                  
   */                                                                 
  p = Stack_check_Pattern.pattern;                                    
  for ( i = 0; i < PATTERN_SIZE_WORDS; i++ ) {                        
      p[i] = pattern[ i%4 ];                                          
400250f4:	09 3f bb 7c 	sethi  %hi(0xfeedf000), %g4                    
400250f8:	82 10 e2 dc 	or  %g3, 0x2dc, %g1                            
400250fc:	88 11 20 0d 	or  %g4, 0xd, %g4                              
40025100:	c8 20 e2 dc 	st  %g4, [ %g3 + 0x2dc ]                       
40025104:	07 02 eb 43 	sethi  %hi(0xbad0c00), %g3                     
40025108:	86 10 e1 06 	or  %g3, 0x106, %g3	! bad0d06 <RAM_SIZE+0xb6d0d06>
  /*                                                                  
   * If appropriate, setup the interrupt stack for high water testing 
   * also.                                                            
   */                                                                 
  #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)                          
    if (_CPU_Interrupt_stack_low && _CPU_Interrupt_stack_high) {      
4002510c:	05 10 01 a2 	sethi  %hi(0x40068800), %g2                    
40025110:	d0 00 a1 b0 	ld  [ %g2 + 0x1b0 ], %o0	! 400689b0 <_Per_CPU_Information>
  /*                                                                  
   * Dope the pattern and fill areas                                  
   */                                                                 
  p = Stack_check_Pattern.pattern;                                    
  for ( i = 0; i < PATTERN_SIZE_WORDS; i++ ) {                        
      p[i] = pattern[ i%4 ];                                          
40025114:	c6 20 60 04 	st  %g3, [ %g1 + 4 ]                           
40025118:	07 37 ab 7c 	sethi  %hi(0xdeadf000), %g3                    
4002511c:	86 10 e0 0d 	or  %g3, 0xd, %g3	! deadf00d <LEON_REG+0x5eadf00d>
40025120:	c6 20 60 08 	st  %g3, [ %g1 + 8 ]                           
40025124:	07 18 03 43 	sethi  %hi(0x600d0c00), %g3                    
40025128:	86 10 e1 06 	or  %g3, 0x106, %g3	! 600d0d06 <RAM_END+0x1fcd0d06>
4002512c:	c6 20 60 0c 	st  %g3, [ %g1 + 0xc ]                         
  /*                                                                  
   * If appropriate, setup the interrupt stack for high water testing 
   * also.                                                            
   */                                                                 
  #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)                          
    if (_CPU_Interrupt_stack_low && _CPU_Interrupt_stack_high) {      
40025130:	80 a2 20 00 	cmp  %o0, 0                                    
40025134:	02 80 00 0c 	be  40025164 <rtems_stack_checker_create_extension+0x88><== NEVER TAKEN
40025138:	84 10 a1 b0 	or  %g2, 0x1b0, %g2                            
4002513c:	d4 00 a0 04 	ld  [ %g2 + 4 ], %o2                           
40025140:	80 a2 a0 00 	cmp  %o2, 0                                    
40025144:	02 80 00 08 	be  40025164 <rtems_stack_checker_create_extension+0x88><== NEVER TAKEN
40025148:	03 10 01 a3 	sethi  %hi(0x40068c00), %g1                    
      Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low;    
4002514c:	84 10 62 ec 	or  %g1, 0x2ec, %g2	! 40068eec <Stack_check_Interrupt_stack>
      Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
40025150:	94 22 80 08 	sub  %o2, %o0, %o2                             
   * If appropriate, setup the interrupt stack for high water testing 
   * also.                                                            
   */                                                                 
  #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)                          
    if (_CPU_Interrupt_stack_low && _CPU_Interrupt_stack_high) {      
      Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low;    
40025154:	d0 20 a0 04 	st  %o0, [ %g2 + 4 ]                           
      Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
40025158:	d4 20 62 ec 	st  %o2, [ %g1 + 0x2ec ]                       
                                  (char *) _CPU_Interrupt_stack_low;  
      Stack_check_Dope_stack(&Stack_check_Interrupt_stack);           
4002515c:	40 00 66 e1 	call  4003ece0 <memset>                        
40025160:	92 10 20 a5 	mov  0xa5, %o1                                 
   }                                                                  
  #endif                                                              
                                                                      
  Stack_check_Initialized = 1;                                        
40025164:	82 10 20 01 	mov  1, %g1                                    
40025168:	c2 27 60 f8 	st  %g1, [ %i5 + 0xf8 ]                        
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
  Stack_check_Initialize();                                           
                                                                      
  if (the_thread)                                                     
4002516c:	80 a6 60 00 	cmp  %i1, 0                                    
40025170:	02 80 00 06 	be  40025188 <rtems_stack_checker_create_extension+0xac><== NEVER TAKEN
40025174:	01 00 00 00 	nop                                            
    Stack_check_Dope_stack(&the_thread->Start.Initial_stack);         
40025178:	d0 06 60 b8 	ld  [ %i1 + 0xb8 ], %o0                        
4002517c:	d4 06 60 b4 	ld  [ %i1 + 0xb4 ], %o2                        
40025180:	40 00 66 d8 	call  4003ece0 <memset>                        
40025184:	92 10 20 a5 	mov  0xa5, %o1                                 
                                                                      
  return true;                                                        
}                                                                     
40025188:	81 c7 e0 08 	ret                                            
4002518c:	91 e8 20 01 	restore  %g0, 1, %o0                           
                                                                      

400252f0 <rtems_stack_checker_is_blown>: /* * Check if blown */ bool rtems_stack_checker_is_blown( void ) {
400252f0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack; 
400252f4:	39 10 01 a2 	sethi  %hi(0x40068800), %i4                    
400252f8:	b8 17 21 b0 	or  %i4, 0x1b0, %i4	! 400689b0 <_Per_CPU_Information>
400252fc:	c2 07 20 10 	ld  [ %i4 + 0x10 ], %g1                        
)                                                                     
{                                                                     
  #if defined(__GNUC__)                                               
    void *sp = __builtin_frame_address(0);                            
                                                                      
    if ( sp < the_stack->area ) {                                     
40025300:	d0 00 60 b8 	ld  [ %g1 + 0xb8 ], %o0                        
40025304:	80 a7 80 08 	cmp  %fp, %o0                                  
40025308:	0a 80 00 06 	bcs  40025320 <rtems_stack_checker_is_blown+0x30><== NEVER TAKEN
4002530c:	ba 10 20 01 	mov  1, %i5                                    
      return false;                                                   
    }                                                                 
    if ( sp > (the_stack->area + the_stack->size) ) {                 
40025310:	c2 00 60 b4 	ld  [ %g1 + 0xb4 ], %g1                        
40025314:	82 02 00 01 	add  %o0, %g1, %g1                             
40025318:	80 a0 40 1e 	cmp  %g1, %fp                                  
4002531c:	ba 40 20 00 	addx  %g0, 0, %i5                              
                                                                      
  /*                                                                  
   * The stack checker must be initialized before the pattern is there
   * to check.                                                        
   */                                                                 
  if ( Stack_check_Initialized ) {                                    
40025320:	03 10 01 9f 	sethi  %hi(0x40067c00), %g1                    
40025324:	c2 00 60 f8 	ld  [ %g1 + 0xf8 ], %g1	! 40067cf8 <Stack_check_Initialized>
40025328:	80 a0 60 00 	cmp  %g1, 0                                    
4002532c:	02 80 00 12 	be  40025374 <rtems_stack_checker_is_blown+0x84><== NEVER TAKEN
40025330:	82 10 20 00 	clr  %g1                                       
    pattern_ok = (!memcmp(                                            
40025334:	90 02 20 08 	add  %o0, 8, %o0                               
40025338:	94 10 20 10 	mov  0x10, %o2                                 
4002533c:	13 10 01 a3 	sethi  %hi(0x40068c00), %o1                    
40025340:	40 00 65 af 	call  4003e9fc <memcmp>                        
40025344:	92 12 62 dc 	or  %o1, 0x2dc, %o1	! 40068edc <Stack_check_Pattern>
40025348:	80 a0 00 08 	cmp  %g0, %o0                                  
4002534c:	82 60 3f ff 	subx  %g0, -1, %g1                             
40025350:	92 10 00 01 	mov  %g1, %o1                                  
40025354:	82 18 60 01 	xor  %g1, 1, %g1                               
                                                                      
                                                                      
  /*                                                                  
   * Let's report as much as we can.                                  
   */                                                                 
  if ( !sp_ok || !pattern_ok ) {                                      
40025358:	80 88 60 ff 	btst  0xff, %g1                                
4002535c:	12 80 00 08 	bne  4002537c <rtems_stack_checker_is_blown+0x8c><== NEVER TAKEN
40025360:	80 8f 60 ff 	btst  0xff, %i5                                
40025364:	12 80 00 06 	bne  4002537c <rtems_stack_checker_is_blown+0x8c><== NEVER TAKEN
40025368:	b0 10 20 00 	clr  %i0                                       
                                                                      
  /*                                                                  
   * The Stack Pointer and the Pattern Area are OK so return false.   
   */                                                                 
  return false;                                                       
}                                                                     
4002536c:	81 c7 e0 08 	ret                                            
40025370:	81 e8 00 00 	restore                                        
 */                                                                   
bool rtems_stack_checker_is_blown( void )                             
{                                                                     
  Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack; 
  bool           sp_ok;                                               
  bool           pattern_ok = true;                                   
40025374:	10 bf ff f9 	b  40025358 <rtems_stack_checker_is_blown+0x68><== NOT EXECUTED
40025378:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Let's report as much as we can.                                  
   */                                                                 
  if ( !sp_ok || !pattern_ok ) {                                      
    Stack_check_report_blown_task( _Thread_Executing, pattern_ok );   
4002537c:	d0 07 20 10 	ld  [ %i4 + 0x10 ], %o0                        <== NOT EXECUTED
40025380:	7f ff ff 94 	call  400251d0 <Stack_check_report_blown_task> <== NOT EXECUTED
40025384:	92 0a 60 01 	and  %o1, 1, %o1                               <== NOT EXECUTED
                                                                      

400253ec <rtems_stack_checker_report_usage>: } void rtems_stack_checker_report_usage( void ) { rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin );
400253ec:	13 10 00 9e 	sethi  %hi(0x40027800), %o1                    <== NOT EXECUTED
400253f0:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
400253f4:	92 12 63 44 	or  %o1, 0x344, %o1                            <== NOT EXECUTED
400253f8:	82 13 c0 00 	mov  %o7, %g1                                  <== NOT EXECUTED
400253fc:	7f ff ff e4 	call  4002538c <rtems_stack_checker_report_usage_with_plugin><== NOT EXECUTED
40025400:	9e 10 40 00 	mov  %g1, %o7                                  <== NOT EXECUTED
                                                                      

4002538c <rtems_stack_checker_report_usage_with_plugin>: void rtems_stack_checker_report_usage_with_plugin( void *context, rtems_printk_plugin_t print ) {
4002538c:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
  if ( !print )                                                       
40025390:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
40025394:	02 80 00 14 	be  400253e4 <rtems_stack_checker_report_usage_with_plugin+0x58><== NOT EXECUTED
40025398:	39 10 01 9f 	sethi  %hi(0x40067c00), %i4                    <== NOT EXECUTED
    return;                                                           
                                                                      
  print_context = context;                                            
  print_handler = print;                                              
4002539c:	3b 10 01 9f 	sethi  %hi(0x40067c00), %i5                    <== NOT EXECUTED
)                                                                     
{                                                                     
  if ( !print )                                                       
    return;                                                           
                                                                      
  print_context = context;                                            
400253a0:	f0 27 20 fc 	st  %i0, [ %i4 + 0xfc ]                        <== NOT EXECUTED
  print_handler = print;                                              
400253a4:	f2 27 61 00 	st  %i1, [ %i5 + 0x100 ]                       <== NOT EXECUTED
                                                                      
  (*print)( context, "Stack usage by thread\n");                      
400253a8:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
400253ac:	13 10 01 7b 	sethi  %hi(0x4005ec00), %o1                    <== NOT EXECUTED
400253b0:	9f c6 40 00 	call  %i1                                      <== NOT EXECUTED
400253b4:	92 12 60 28 	or  %o1, 0x28, %o1	! 4005ec28 <RTEMS_BDPART_MBR_MASTER_TYPE+0x3f8><== NOT EXECUTED
  (*print)( context,                                                  
400253b8:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
400253bc:	13 10 01 7b 	sethi  %hi(0x4005ec00), %o1                    <== NOT EXECUTED
400253c0:	9f c6 40 00 	call  %i1                                      <== NOT EXECUTED
400253c4:	92 12 60 40 	or  %o1, 0x40, %o1	! 4005ec40 <RTEMS_BDPART_MBR_MASTER_TYPE+0x410><== 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 );   
400253c8:	11 10 00 93 	sethi  %hi(0x40024c00), %o0                    <== NOT EXECUTED
400253cc:	40 00 12 b3 	call  40029e98 <rtems_iterate_over_all_threads><== NOT EXECUTED
400253d0:	90 12 23 5c 	or  %o0, 0x35c, %o0	! 40024f5c <Stack_check_Dump_threads_usage><== NOT EXECUTED
                                                                      
  #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)                          
    /* dump interrupt stack info if any */                            
    Stack_check_Dump_threads_usage((Thread_Control *) -1);            
400253d4:	7f ff fe e2 	call  40024f5c <Stack_check_Dump_threads_usage><== NOT EXECUTED
400253d8:	90 10 3f ff 	mov  -1, %o0                                   <== NOT EXECUTED
  #endif                                                              
                                                                      
  print_context = NULL;                                               
400253dc:	c0 27 20 fc 	clr  [ %i4 + 0xfc ]                            <== NOT EXECUTED
  print_handler = NULL;                                               
400253e0:	c0 27 61 00 	clr  [ %i5 + 0x100 ]                           <== NOT EXECUTED
400253e4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400253e8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40025280 <rtems_stack_checker_switch_extension>: */ void rtems_stack_checker_switch_extension( Thread_Control *running __attribute__((unused)), Thread_Control *heir __attribute__((unused)) ) {
40025280:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Stack_Control *the_stack = &running->Start.Initial_stack;           
  void          *pattern;                                             
  bool           sp_ok;                                               
  bool           pattern_ok = true;                                   
                                                                      
  pattern = Stack_check_Get_pattern_area(the_stack);                  
40025284:	c2 06 20 b8 	ld  [ %i0 + 0xb8 ], %g1                        
  /*                                                                  
   *  Check for an out of bounds stack pointer or an overwrite        
   */                                                                 
  sp_ok = Stack_check_Frame_pointer_in_range( the_stack );            
                                                                      
  pattern_ok = (!memcmp( pattern,                                     
40025288:	13 10 01 a3 	sethi  %hi(0x40068c00), %o1                    
  Stack_Control *the_stack = &running->Start.Initial_stack;           
  void          *pattern;                                             
  bool           sp_ok;                                               
  bool           pattern_ok = true;                                   
                                                                      
  pattern = Stack_check_Get_pattern_area(the_stack);                  
4002528c:	90 00 60 08 	add  %g1, 8, %o0                               
  /*                                                                  
   *  Check for an out of bounds stack pointer or an overwrite        
   */                                                                 
  sp_ok = Stack_check_Frame_pointer_in_range( the_stack );            
                                                                      
  pattern_ok = (!memcmp( pattern,                                     
40025290:	94 10 20 10 	mov  0x10, %o2                                 
)                                                                     
{                                                                     
  #if defined(__GNUC__)                                               
    void *sp = __builtin_frame_address(0);                            
                                                                      
    if ( sp < the_stack->area ) {                                     
40025294:	80 a7 80 01 	cmp  %fp, %g1                                  
40025298:	0a 80 00 07 	bcs  400252b4 <rtems_stack_checker_switch_extension+0x34><== NEVER TAKEN
4002529c:	92 12 62 dc 	or  %o1, 0x2dc, %o1                            
      return false;                                                   
    }                                                                 
    if ( sp > (the_stack->area + the_stack->size) ) {                 
400252a0:	c4 06 20 b4 	ld  [ %i0 + 0xb4 ], %g2                        
400252a4:	82 00 40 02 	add  %g1, %g2, %g1                             
400252a8:	80 a7 80 01 	cmp  %fp, %g1                                  
400252ac:	08 80 00 0a 	bleu  400252d4 <rtems_stack_checker_switch_extension+0x54><== ALWAYS TAKEN
400252b0:	01 00 00 00 	nop                                            
  /*                                                                  
   *  Check for an out of bounds stack pointer or an overwrite        
   */                                                                 
  sp_ok = Stack_check_Frame_pointer_in_range( the_stack );            
                                                                      
  pattern_ok = (!memcmp( pattern,                                     
400252b4:	40 00 65 d2 	call  4003e9fc <memcmp>                        <== NOT EXECUTED
400252b8:	01 00 00 00 	nop                                            <== NOT EXECUTED
400252bc:	80 a0 00 08 	cmp  %g0, %o0                                  <== NOT EXECUTED
400252c0:	82 60 3f ff 	subx  %g0, -1, %g1                             <== NOT EXECUTED
400252c4:	92 10 00 01 	mov  %g1, %o1                                  <== NOT EXECUTED
            (void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
                                                                      
  if ( !sp_ok || !pattern_ok ) {                                      
    Stack_check_report_blown_task( running, pattern_ok );             
400252c8:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
400252cc:	7f ff ff c1 	call  400251d0 <Stack_check_report_blown_task> <== NOT EXECUTED
400252d0:	92 0a 60 01 	and  %o1, 1, %o1                               <== NOT EXECUTED
  /*                                                                  
   *  Check for an out of bounds stack pointer or an overwrite        
   */                                                                 
  sp_ok = Stack_check_Frame_pointer_in_range( the_stack );            
                                                                      
  pattern_ok = (!memcmp( pattern,                                     
400252d4:	40 00 65 ca 	call  4003e9fc <memcmp>                        
400252d8:	01 00 00 00 	nop                                            
            (void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
                                                                      
  if ( !sp_ok || !pattern_ok ) {                                      
400252dc:	80 a2 20 00 	cmp  %o0, 0                                    
400252e0:	12 bf ff fa 	bne  400252c8 <rtems_stack_checker_switch_extension+0x48><== NEVER TAKEN
400252e4:	92 10 20 00 	clr  %o1                                       
400252e8:	81 c7 e0 08 	ret                                            
400252ec:	81 e8 00 00 	restore                                        
                                                                      

4000d8ec <rtems_string_to_double>: rtems_status_code rtems_string_to_double ( const char *s, double *n, char **endptr ) {
4000d8ec:	9d e3 bf 98 	save  %sp, -104, %sp                           
  double result;                                                      
  char *end;                                                          
                                                                      
  if ( !n )                                                           
4000d8f0:	80 a6 60 00 	cmp  %i1, 0                                    
4000d8f4:	02 80 00 1b 	be  4000d960 <rtems_string_to_double+0x74>     
4000d8f8:	b6 10 20 09 	mov  9, %i3                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
4000d8fc:	40 00 0c 5d 	call  40010a70 <__errno>                       
4000d900:	01 00 00 00 	nop                                            
4000d904:	c0 22 00 00 	clr  [ %o0 ]                                   
  *n = 0;                                                             
4000d908:	c0 26 40 00 	clr  [ %i1 ]                                   
4000d90c:	c0 26 60 04 	clr  [ %i1 + 4 ]                               
                                                                      
  result = strtod( s, &end );                                         
4000d910:	90 10 00 18 	mov  %i0, %o0                                  
4000d914:	40 00 17 b8 	call  400137f4 <strtod>                        
4000d918:	92 07 bf fc 	add  %fp, -4, %o1                              
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
4000d91c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtod( s, &end );                                         
4000d920:	b8 10 00 08 	mov  %o0, %i4                                  
                                                                      
  if ( endptr )                                                       
4000d924:	80 a6 a0 00 	cmp  %i2, 0                                    
4000d928:	02 80 00 03 	be  4000d934 <rtems_string_to_double+0x48>     
4000d92c:	ba 10 00 09 	mov  %o1, %i5                                  
    *endptr = end;                                                    
4000d930:	c2 26 80 00 	st  %g1, [ %i2 ]                               
                                                                      
  if ( end == s )                                                     
4000d934:	80 a6 00 01 	cmp  %i0, %g1                                  
4000d938:	02 80 00 0a 	be  4000d960 <rtems_string_to_double+0x74>     
4000d93c:	b6 10 20 0b 	mov  0xb, %i3                                  
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
4000d940:	40 00 0c 4c 	call  40010a70 <__errno>                       
4000d944:	01 00 00 00 	nop                                            
4000d948:	c2 02 00 00 	ld  [ %o0 ], %g1                               
4000d94c:	80 a0 60 22 	cmp  %g1, 0x22                                 
4000d950:	02 80 00 06 	be  4000d968 <rtems_string_to_double+0x7c>     
4000d954:	90 10 00 1c 	mov  %i4, %o0                                  
    (( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  *n = result;                                                        
4000d958:	f8 3e 40 00 	std  %i4, [ %i1 ]                              
                                                                      
  return RTEMS_SUCCESSFUL;                                            
4000d95c:	b6 10 20 00 	clr  %i3                                       
}                                                                     
4000d960:	81 c7 e0 08 	ret                                            
4000d964:	91 e8 00 1b 	restore  %g0, %i3, %o0                         
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
4000d968:	92 10 00 1d 	mov  %i5, %o1                                  
4000d96c:	94 10 20 00 	clr  %o2                                       
4000d970:	96 10 20 00 	clr  %o3                                       
4000d974:	40 00 41 f1 	call  4001e138 <__eqdf2>                       
4000d978:	b6 10 20 0a 	mov  0xa, %i3                                  
4000d97c:	80 a2 20 00 	cmp  %o0, 0                                    
4000d980:	02 bf ff f8 	be  4000d960 <rtems_string_to_double+0x74>     <== NEVER TAKEN
4000d984:	90 10 00 1c 	mov  %i4, %o0                                  
    (( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
4000d988:	92 10 00 1d 	mov  %i5, %o1                                  
4000d98c:	15 1f fb ff 	sethi  %hi(0x7feffc00), %o2                    
4000d990:	96 10 3f ff 	mov  -1, %o3                                   
4000d994:	40 00 41 ff 	call  4001e190 <__gtdf2>                       
4000d998:	94 12 a3 ff 	or  %o2, 0x3ff, %o2                            
4000d99c:	80 a2 20 00 	cmp  %o0, 0                                    
4000d9a0:	14 bf ff f0 	bg  4000d960 <rtems_string_to_double+0x74>     
4000d9a4:	90 10 00 1c 	mov  %i4, %o0                                  
4000d9a8:	92 10 00 1d 	mov  %i5, %o1                                  
4000d9ac:	15 3f fb ff 	sethi  %hi(0xffeffc00), %o2                    
4000d9b0:	96 10 3f ff 	mov  -1, %o3                                   
4000d9b4:	40 00 42 23 	call  4001e240 <__ltdf2>                       
4000d9b8:	94 12 a3 ff 	or  %o2, 0x3ff, %o2                            
4000d9bc:	80 a2 20 00 	cmp  %o0, 0                                    
4000d9c0:	06 bf ff e8 	bl  4000d960 <rtems_string_to_double+0x74>     <== ALWAYS TAKEN
4000d9c4:	01 00 00 00 	nop                                            
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  *n = result;                                                        
4000d9c8:	10 bf ff e5 	b  4000d95c <rtems_string_to_double+0x70>      <== NOT EXECUTED
4000d9cc:	f8 3e 40 00 	std  %i4, [ %i1 ]                              <== NOT EXECUTED
                                                                      

4000d9d0 <rtems_string_to_float>: rtems_status_code rtems_string_to_float ( const char *s, float *n, char **endptr ) {
4000d9d0:	9d e3 bf 98 	save  %sp, -104, %sp                           
  float result;                                                       
  char *end;                                                          
                                                                      
  if ( !n )                                                           
4000d9d4:	80 a6 60 00 	cmp  %i1, 0                                    
4000d9d8:	02 80 00 19 	be  4000da3c <rtems_string_to_float+0x6c>      
4000d9dc:	ba 10 20 09 	mov  9, %i5                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
4000d9e0:	40 00 0c 24 	call  40010a70 <__errno>                       
4000d9e4:	01 00 00 00 	nop                                            
4000d9e8:	c0 22 00 00 	clr  [ %o0 ]                                   
  *n = 0;                                                             
4000d9ec:	c0 26 40 00 	clr  [ %i1 ]                                   
                                                                      
  result = strtof( s, &end );                                         
4000d9f0:	90 10 00 18 	mov  %i0, %o0                                  
4000d9f4:	40 00 17 87 	call  40013810 <strtof>                        
4000d9f8:	92 07 bf fc 	add  %fp, -4, %o1                              
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
4000d9fc:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtof( s, &end );                                         
                                                                      
  if ( endptr )                                                       
4000da00:	80 a6 a0 00 	cmp  %i2, 0                                    
4000da04:	02 80 00 03 	be  4000da10 <rtems_string_to_float+0x40>      
4000da08:	b8 10 00 08 	mov  %o0, %i4                                  
    *endptr = end;                                                    
4000da0c:	c2 26 80 00 	st  %g1, [ %i2 ]                               
                                                                      
  if ( end == s )                                                     
4000da10:	80 a6 00 01 	cmp  %i0, %g1                                  
4000da14:	02 80 00 0a 	be  4000da3c <rtems_string_to_float+0x6c>      
4000da18:	ba 10 20 0b 	mov  0xb, %i5                                  
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
4000da1c:	40 00 0c 15 	call  40010a70 <__errno>                       
4000da20:	01 00 00 00 	nop                                            
4000da24:	c2 02 00 00 	ld  [ %o0 ], %g1                               
4000da28:	80 a0 60 22 	cmp  %g1, 0x22                                 
4000da2c:	02 80 00 06 	be  4000da44 <rtems_string_to_float+0x74>      
4000da30:	90 10 00 1c 	mov  %i4, %o0                                  
    (( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  *n = result;                                                        
4000da34:	f8 26 40 00 	st  %i4, [ %i1 ]                               
                                                                      
  return RTEMS_SUCCESSFUL;                                            
4000da38:	ba 10 20 00 	clr  %i5                                       
}                                                                     
4000da3c:	81 c7 e0 08 	ret                                            
4000da40:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
4000da44:	92 10 20 00 	clr  %o1                                       
4000da48:	40 00 3f 17 	call  4001d6a4 <__eqsf2>                       
4000da4c:	ba 10 20 0a 	mov  0xa, %i5                                  
4000da50:	80 a2 20 00 	cmp  %o0, 0                                    
4000da54:	02 bf ff fa 	be  4000da3c <rtems_string_to_float+0x6c>      <== NEVER TAKEN
4000da58:	90 10 00 1c 	mov  %i4, %o0                                  
    (( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
4000da5c:	13 1f df ff 	sethi  %hi(0x7f7ffc00), %o1                    
4000da60:	40 00 3f 26 	call  4001d6f8 <__gtsf2>                       
4000da64:	92 12 63 ff 	or  %o1, 0x3ff, %o1	! 7f7fffff <RAM_END+0x3f3fffff>
4000da68:	80 a2 20 00 	cmp  %o0, 0                                    
4000da6c:	14 bf ff f4 	bg  4000da3c <rtems_string_to_float+0x6c>      
4000da70:	90 10 00 1c 	mov  %i4, %o0                                  
4000da74:	13 3f df ff 	sethi  %hi(0xff7ffc00), %o1                    
4000da78:	40 00 3f 35 	call  4001d74c <__ltsf2>                       
4000da7c:	92 12 63 ff 	or  %o1, 0x3ff, %o1	! ff7fffff <LEON_REG+0x7f7fffff>
4000da80:	80 a2 20 00 	cmp  %o0, 0                                    
4000da84:	06 bf ff ee 	bl  4000da3c <rtems_string_to_float+0x6c>      <== ALWAYS TAKEN
4000da88:	01 00 00 00 	nop                                            
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  *n = result;                                                        
4000da8c:	10 bf ff eb 	b  4000da38 <rtems_string_to_float+0x68>       <== NOT EXECUTED
4000da90:	f8 26 40 00 	st  %i4, [ %i1 ]                               <== NOT EXECUTED
                                                                      

4001f498 <rtems_string_to_int>: const char *s, int *n, char **endptr, int base ) {
4001f498:	9d e3 bf 98 	save  %sp, -104, %sp                           
  long result;                                                        
  char *end;                                                          
                                                                      
  if ( !n )                                                           
4001f49c:	80 a6 60 00 	cmp  %i1, 0                                    
4001f4a0:	02 80 00 1a 	be  4001f508 <rtems_string_to_int+0x70>        
4001f4a4:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
4001f4a8:	40 00 70 30 	call  4003b568 <__errno>                       
4001f4ac:	01 00 00 00 	nop                                            
4001f4b0:	c0 22 00 00 	clr  [ %o0 ]                                   
  *n = 0;                                                             
4001f4b4:	c0 26 40 00 	clr  [ %i1 ]                                   
                                                                      
  result = strtol( s, &end, base );                                   
4001f4b8:	90 10 00 18 	mov  %i0, %o0                                  
4001f4bc:	92 07 bf fc 	add  %fp, -4, %o1                              
4001f4c0:	40 00 91 00 	call  400438c0 <strtol>                        
4001f4c4:	94 10 00 1b 	mov  %i3, %o2                                  
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
4001f4c8:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtol( s, &end, base );                                   
                                                                      
  if ( endptr )                                                       
4001f4cc:	80 a6 a0 00 	cmp  %i2, 0                                    
4001f4d0:	02 80 00 03 	be  4001f4dc <rtems_string_to_int+0x44>        
4001f4d4:	ba 10 00 08 	mov  %o0, %i5                                  
    *endptr = end;                                                    
4001f4d8:	c4 26 80 00 	st  %g2, [ %i2 ]                               
                                                                      
  if ( end == s )                                                     
4001f4dc:	80 a6 00 02 	cmp  %i0, %g2                                  
4001f4e0:	02 80 00 0a 	be  4001f508 <rtems_string_to_int+0x70>        
4001f4e4:	82 10 20 0b 	mov  0xb, %g1                                  
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
4001f4e8:	40 00 70 20 	call  4003b568 <__errno>                       
4001f4ec:	01 00 00 00 	nop                                            
4001f4f0:	c2 02 00 00 	ld  [ %o0 ], %g1                               
4001f4f4:	80 a0 60 22 	cmp  %g1, 0x22                                 
4001f4f8:	02 80 00 06 	be  4001f510 <rtems_string_to_int+0x78>        
4001f4fc:	03 20 00 00 	sethi  %hi(0x80000000), %g1                    
    errno = ERANGE;                                                   
    return RTEMS_INVALID_NUMBER;                                      
  }                                                                   
#endif                                                                
                                                                      
  *n = result;                                                        
4001f500:	fa 26 40 00 	st  %i5, [ %i1 ]                               
                                                                      
  return RTEMS_SUCCESSFUL;                                            
4001f504:	82 10 20 00 	clr  %g1                                       
}                                                                     
4001f508:	81 c7 e0 08 	ret                                            
4001f50c:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
    (( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
4001f510:	82 38 40 1d 	xnor  %g1, %i5, %g1                            
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
4001f514:	80 a0 60 00 	cmp  %g1, 0                                    
4001f518:	02 bf ff fc 	be  4001f508 <rtems_string_to_int+0x70>        
4001f51c:	82 10 20 0a 	mov  0xa, %g1                                  
4001f520:	80 a7 60 00 	cmp  %i5, 0                                    
4001f524:	02 bf ff f9 	be  4001f508 <rtems_string_to_int+0x70>        <== NEVER TAKEN
4001f528:	05 20 00 00 	sethi  %hi(0x80000000), %g2                    
    (( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
4001f52c:	80 a7 40 02 	cmp  %i5, %g2                                  
4001f530:	02 bf ff f6 	be  4001f508 <rtems_string_to_int+0x70>        <== ALWAYS TAKEN
4001f534:	01 00 00 00 	nop                                            
    errno = ERANGE;                                                   
    return RTEMS_INVALID_NUMBER;                                      
  }                                                                   
#endif                                                                
                                                                      
  *n = result;                                                        
4001f538:	fa 26 40 00 	st  %i5, [ %i1 ]                               <== NOT EXECUTED
                                                                      
  return RTEMS_SUCCESSFUL;                                            
4001f53c:	10 bf ff f3 	b  4001f508 <rtems_string_to_int+0x70>         <== NOT EXECUTED
4001f540:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
                                                                      

4000dc18 <rtems_string_to_long>: const char *s, long *n, char **endptr, int base ) {
4000dc18:	9d e3 bf 98 	save  %sp, -104, %sp                           
  long result;                                                        
  char *end;                                                          
                                                                      
  if ( !n )                                                           
4000dc1c:	80 a6 60 00 	cmp  %i1, 0                                    
4000dc20:	02 80 00 1a 	be  4000dc88 <rtems_string_to_long+0x70>       
4000dc24:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
4000dc28:	40 00 0b 92 	call  40010a70 <__errno>                       
4000dc2c:	01 00 00 00 	nop                                            
4000dc30:	c0 22 00 00 	clr  [ %o0 ]                                   
  *n = 0;                                                             
4000dc34:	c0 26 40 00 	clr  [ %i1 ]                                   
                                                                      
  result = strtol( s, &end, base );                                   
4000dc38:	90 10 00 18 	mov  %i0, %o0                                  
4000dc3c:	92 07 bf fc 	add  %fp, -4, %o1                              
4000dc40:	40 00 17 95 	call  40013a94 <strtol>                        
4000dc44:	94 10 00 1b 	mov  %i3, %o2                                  
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
4000dc48:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtol( s, &end, base );                                   
                                                                      
  if ( endptr )                                                       
4000dc4c:	80 a6 a0 00 	cmp  %i2, 0                                    
4000dc50:	02 80 00 03 	be  4000dc5c <rtems_string_to_long+0x44>       
4000dc54:	ba 10 00 08 	mov  %o0, %i5                                  
    *endptr = end;                                                    
4000dc58:	c4 26 80 00 	st  %g2, [ %i2 ]                               
                                                                      
  if ( end == s )                                                     
4000dc5c:	80 a6 00 02 	cmp  %i0, %g2                                  
4000dc60:	02 80 00 0a 	be  4000dc88 <rtems_string_to_long+0x70>       
4000dc64:	82 10 20 0b 	mov  0xb, %g1                                  
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
4000dc68:	40 00 0b 82 	call  40010a70 <__errno>                       
4000dc6c:	01 00 00 00 	nop                                            
4000dc70:	c2 02 00 00 	ld  [ %o0 ], %g1                               
4000dc74:	80 a0 60 22 	cmp  %g1, 0x22                                 
4000dc78:	02 80 00 06 	be  4000dc90 <rtems_string_to_long+0x78>       
4000dc7c:	03 20 00 00 	sethi  %hi(0x80000000), %g1                    
    (( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  *n = result;                                                        
4000dc80:	fa 26 40 00 	st  %i5, [ %i1 ]                               
                                                                      
  return RTEMS_SUCCESSFUL;                                            
4000dc84:	82 10 20 00 	clr  %g1                                       
}                                                                     
4000dc88:	81 c7 e0 08 	ret                                            
4000dc8c:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
    (( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
4000dc90:	82 38 40 1d 	xnor  %g1, %i5, %g1                            
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
4000dc94:	80 a0 60 00 	cmp  %g1, 0                                    
4000dc98:	02 bf ff fc 	be  4000dc88 <rtems_string_to_long+0x70>       
4000dc9c:	82 10 20 0a 	mov  0xa, %g1                                  
4000dca0:	80 a7 60 00 	cmp  %i5, 0                                    
4000dca4:	02 bf ff f9 	be  4000dc88 <rtems_string_to_long+0x70>       <== NEVER TAKEN
4000dca8:	05 20 00 00 	sethi  %hi(0x80000000), %g2                    
    (( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
4000dcac:	80 a7 40 02 	cmp  %i5, %g2                                  
4000dcb0:	02 bf ff f6 	be  4000dc88 <rtems_string_to_long+0x70>       <== ALWAYS TAKEN
4000dcb4:	01 00 00 00 	nop                                            
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  *n = result;                                                        
4000dcb8:	fa 26 40 00 	st  %i5, [ %i1 ]                               <== NOT EXECUTED
                                                                      
  return RTEMS_SUCCESSFUL;                                            
4000dcbc:	10 bf ff f3 	b  4000dc88 <rtems_string_to_long+0x70>        <== NOT EXECUTED
4000dcc0:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
                                                                      

4000db40 <rtems_string_to_long_long>: const char *s, long long *n, char **endptr, int base ) {
4000db40:	9d e3 bf 98 	save  %sp, -104, %sp                           
  long long result;                                                   
  char *end;                                                          
                                                                      
  if ( !n )                                                           
4000db44:	80 a6 60 00 	cmp  %i1, 0                                    
4000db48:	02 80 00 1c 	be  4000dbb8 <rtems_string_to_long_long+0x78>  
4000db4c:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
4000db50:	40 00 0b c8 	call  40010a70 <__errno>                       
4000db54:	01 00 00 00 	nop                                            
4000db58:	c0 22 00 00 	clr  [ %o0 ]                                   
  *n = 0;                                                             
4000db5c:	c0 26 40 00 	clr  [ %i1 ]                                   
4000db60:	c0 26 60 04 	clr  [ %i1 + 4 ]                               
                                                                      
  result = strtoll( s, &end, base );                                  
4000db64:	90 10 00 18 	mov  %i0, %o0                                  
4000db68:	92 07 bf fc 	add  %fp, -4, %o1                              
4000db6c:	40 00 17 d3 	call  40013ab8 <strtoll>                       
4000db70:	94 10 00 1b 	mov  %i3, %o2                                  
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
4000db74:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtoll( s, &end, base );                                  
4000db78:	b8 10 00 08 	mov  %o0, %i4                                  
                                                                      
  if ( endptr )                                                       
4000db7c:	80 a6 a0 00 	cmp  %i2, 0                                    
4000db80:	02 80 00 03 	be  4000db8c <rtems_string_to_long_long+0x4c>  
4000db84:	ba 10 00 09 	mov  %o1, %i5                                  
    *endptr = end;                                                    
4000db88:	c4 26 80 00 	st  %g2, [ %i2 ]                               
                                                                      
  if ( end == s )                                                     
4000db8c:	80 a6 00 02 	cmp  %i0, %g2                                  
4000db90:	02 80 00 0a 	be  4000dbb8 <rtems_string_to_long_long+0x78>  
4000db94:	82 10 20 0b 	mov  0xb, %g1                                  
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
4000db98:	40 00 0b b6 	call  40010a70 <__errno>                       
4000db9c:	01 00 00 00 	nop                                            
4000dba0:	c2 02 00 00 	ld  [ %o0 ], %g1                               
4000dba4:	80 a0 60 22 	cmp  %g1, 0x22                                 
4000dba8:	02 80 00 06 	be  4000dbc0 <rtems_string_to_long_long+0x80>  
4000dbac:	05 1f ff ff 	sethi  %hi(0x7ffffc00), %g2                    
    (( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  *n = result;                                                        
4000dbb0:	f8 3e 40 00 	std  %i4, [ %i1 ]                              
                                                                      
  return RTEMS_SUCCESSFUL;                                            
4000dbb4:	82 10 20 00 	clr  %g1                                       
}                                                                     
4000dbb8:	81 c7 e0 08 	ret                                            
4000dbbc:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
    (( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
4000dbc0:	07 3f ff ff 	sethi  %hi(0xfffffc00), %g3                    
4000dbc4:	84 10 a3 ff 	or  %g2, 0x3ff, %g2                            
4000dbc8:	86 10 e3 ff 	or  %g3, 0x3ff, %g3                            
4000dbcc:	84 1f 00 02 	xor  %i4, %g2, %g2                             
4000dbd0:	86 1f 40 03 	xor  %i5, %g3, %g3                             
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
4000dbd4:	80 90 80 03 	orcc  %g2, %g3, %g0                            
4000dbd8:	12 80 00 04 	bne  4000dbe8 <rtems_string_to_long_long+0xa8> 
4000dbdc:	80 97 00 1d 	orcc  %i4, %i5, %g0                            
    (( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
      return RTEMS_INVALID_NUMBER;                                    
4000dbe0:	10 bf ff f6 	b  4000dbb8 <rtems_string_to_long_long+0x78>   
4000dbe4:	82 10 20 0a 	mov  0xa, %g1                                  
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
4000dbe8:	02 bf ff f4 	be  4000dbb8 <rtems_string_to_long_long+0x78>  <== NEVER TAKEN
4000dbec:	82 10 20 0a 	mov  0xa, %g1                                  
    (( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
4000dbf0:	03 20 00 00 	sethi  %hi(0x80000000), %g1                    
4000dbf4:	80 a7 00 01 	cmp  %i4, %g1                                  
4000dbf8:	32 bf ff ef 	bne,a   4000dbb4 <rtems_string_to_long_long+0x74><== NEVER TAKEN
4000dbfc:	f8 3e 40 00 	std  %i4, [ %i1 ]                              <== NOT EXECUTED
4000dc00:	80 a7 60 00 	cmp  %i5, 0                                    
4000dc04:	22 bf ff ed 	be,a   4000dbb8 <rtems_string_to_long_long+0x78><== ALWAYS TAKEN
4000dc08:	82 10 20 0a 	mov  0xa, %g1                                  
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  *n = result;                                                        
4000dc0c:	f8 3e 40 00 	std  %i4, [ %i1 ]                              <== NOT EXECUTED
                                                                      
  return RTEMS_SUCCESSFUL;                                            
4000dc10:	10 bf ff ea 	b  4000dbb8 <rtems_string_to_long_long+0x78>   <== NOT EXECUTED
4000dc14:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
                                                                      

4001f554 <rtems_string_to_unsigned_char>: const char *s, unsigned char *n, char **endptr, int base ) {
4001f554:	9d e3 bf 98 	save  %sp, -104, %sp                           
  unsigned long result;                                               
  char *end;                                                          
                                                                      
  if ( !n )                                                           
4001f558:	80 a6 60 00 	cmp  %i1, 0                                    
4001f55c:	02 80 00 1b 	be  4001f5c8 <rtems_string_to_unsigned_char+0x74>
4001f560:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
4001f564:	40 00 70 01 	call  4003b568 <__errno>                       
4001f568:	01 00 00 00 	nop                                            
4001f56c:	c0 22 00 00 	clr  [ %o0 ]                                   
  *n = 0;                                                             
4001f570:	c0 2e 40 00 	clrb  [ %i1 ]                                  
                                                                      
  result = strtoul( s, &end, base );                                  
4001f574:	90 10 00 18 	mov  %i0, %o0                                  
4001f578:	92 07 bf fc 	add  %fp, -4, %o1                              
4001f57c:	40 00 92 1f 	call  40043df8 <strtoul>                       
4001f580:	94 10 00 1b 	mov  %i3, %o2                                  
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
4001f584:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtoul( s, &end, base );                                  
                                                                      
  if ( endptr )                                                       
4001f588:	80 a6 a0 00 	cmp  %i2, 0                                    
4001f58c:	02 80 00 03 	be  4001f598 <rtems_string_to_unsigned_char+0x44>
4001f590:	ba 10 00 08 	mov  %o0, %i5                                  
    *endptr = end;                                                    
4001f594:	c4 26 80 00 	st  %g2, [ %i2 ]                               
                                                                      
  if ( end == s )                                                     
4001f598:	80 a6 00 02 	cmp  %i0, %g2                                  
4001f59c:	02 80 00 0b 	be  4001f5c8 <rtems_string_to_unsigned_char+0x74>
4001f5a0:	82 10 20 0b 	mov  0xb, %g1                                  
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
4001f5a4:	40 00 6f f1 	call  4003b568 <__errno>                       
4001f5a8:	01 00 00 00 	nop                                            
4001f5ac:	c2 02 00 00 	ld  [ %o0 ], %g1                               
4001f5b0:	80 a0 60 22 	cmp  %g1, 0x22                                 
4001f5b4:	02 80 00 0e 	be  4001f5ec <rtems_string_to_unsigned_char+0x98>
4001f5b8:	80 a7 60 ff 	cmp  %i5, 0xff                                 
    (( result == 0 ) || ( result == ULONG_MAX )))                     
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
#if (UCHAR_MAX < ULONG_MAX)                                           
  if ( result > UCHAR_MAX ) {                                         
4001f5bc:	18 80 00 05 	bgu  4001f5d0 <rtems_string_to_unsigned_char+0x7c>
4001f5c0:	82 10 20 00 	clr  %g1                                       
    errno = ERANGE;                                                   
    return RTEMS_INVALID_NUMBER;                                      
  }                                                                   
#endif                                                                
                                                                      
  *n = result;                                                        
4001f5c4:	fa 2e 40 00 	stb  %i5, [ %i1 ]                              
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
4001f5c8:	81 c7 e0 08 	ret                                            
4001f5cc:	91 e8 00 01 	restore  %g0, %g1, %o0                         
    (( result == 0 ) || ( result == ULONG_MAX )))                     
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
#if (UCHAR_MAX < ULONG_MAX)                                           
  if ( result > UCHAR_MAX ) {                                         
    errno = ERANGE;                                                   
4001f5d0:	40 00 6f e6 	call  4003b568 <__errno>                       
4001f5d4:	01 00 00 00 	nop                                            
    return RTEMS_INVALID_NUMBER;                                      
4001f5d8:	82 10 20 0a 	mov  0xa, %g1	! a <PROM_START+0xa>             
    (( result == 0 ) || ( result == ULONG_MAX )))                     
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
#if (UCHAR_MAX < ULONG_MAX)                                           
  if ( result > UCHAR_MAX ) {                                         
    errno = ERANGE;                                                   
4001f5dc:	84 10 20 22 	mov  0x22, %g2                                 
4001f5e0:	c4 22 00 00 	st  %g2, [ %o0 ]                               
#endif                                                                
                                                                      
  *n = result;                                                        
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
4001f5e4:	81 c7 e0 08 	ret                                            
4001f5e8:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
    (( result == 0 ) || ( result == ULONG_MAX )))                     
4001f5ec:	84 07 7f ff 	add  %i5, -1, %g2                              
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
4001f5f0:	80 a0 bf fd 	cmp  %g2, -3                                   
4001f5f4:	18 bf ff f5 	bgu  4001f5c8 <rtems_string_to_unsigned_char+0x74><== ALWAYS TAKEN
4001f5f8:	82 10 20 0a 	mov  0xa, %g1                                  
    (( result == 0 ) || ( result == ULONG_MAX )))                     
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
#if (UCHAR_MAX < ULONG_MAX)                                           
  if ( result > UCHAR_MAX ) {                                         
4001f5fc:	10 bf ff f0 	b  4001f5bc <rtems_string_to_unsigned_char+0x68><== NOT EXECUTED
4001f600:	80 a7 60 ff 	cmp  %i5, 0xff                                 <== NOT EXECUTED
                                                                      

4000dd84 <rtems_string_to_unsigned_int>: const char *s, unsigned int *n, char **endptr, int base ) {
4000dd84:	9d e3 bf 98 	save  %sp, -104, %sp                           
  unsigned long result;                                               
  char *end;                                                          
                                                                      
  if ( !n )                                                           
4000dd88:	80 a6 60 00 	cmp  %i1, 0                                    
4000dd8c:	02 80 00 1a 	be  4000ddf4 <rtems_string_to_unsigned_int+0x70>
4000dd90:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
4000dd94:	40 00 0b 37 	call  40010a70 <__errno>                       
4000dd98:	01 00 00 00 	nop                                            
4000dd9c:	c0 22 00 00 	clr  [ %o0 ]                                   
  *n = 0;                                                             
4000dda0:	c0 26 40 00 	clr  [ %i1 ]                                   
                                                                      
  result = strtoul( s, &end, base );                                  
4000dda4:	90 10 00 18 	mov  %i0, %o0                                  
4000dda8:	92 07 bf fc 	add  %fp, -4, %o1                              
4000ddac:	40 00 18 88 	call  40013fcc <strtoul>                       
4000ddb0:	94 10 00 1b 	mov  %i3, %o2                                  
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
4000ddb4:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtoul( s, &end, base );                                  
                                                                      
  if ( endptr )                                                       
4000ddb8:	80 a6 a0 00 	cmp  %i2, 0                                    
4000ddbc:	02 80 00 03 	be  4000ddc8 <rtems_string_to_unsigned_int+0x44>
4000ddc0:	ba 10 00 08 	mov  %o0, %i5                                  
    *endptr = end;                                                    
4000ddc4:	c4 26 80 00 	st  %g2, [ %i2 ]                               
                                                                      
  if ( end == s )                                                     
4000ddc8:	80 a6 00 02 	cmp  %i0, %g2                                  
4000ddcc:	02 80 00 0a 	be  4000ddf4 <rtems_string_to_unsigned_int+0x70>
4000ddd0:	82 10 20 0b 	mov  0xb, %g1                                  
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
4000ddd4:	40 00 0b 27 	call  40010a70 <__errno>                       
4000ddd8:	01 00 00 00 	nop                                            
4000dddc:	c2 02 00 00 	ld  [ %o0 ], %g1                               
4000dde0:	80 a0 60 22 	cmp  %g1, 0x22                                 
4000dde4:	02 80 00 06 	be  4000ddfc <rtems_string_to_unsigned_int+0x78>
4000dde8:	84 07 7f ff 	add  %i5, -1, %g2                              
    errno = ERANGE;                                                   
    return RTEMS_INVALID_NUMBER;                                      
  }                                                                   
#endif                                                                
                                                                      
  *n = result;                                                        
4000ddec:	fa 26 40 00 	st  %i5, [ %i1 ]                               
                                                                      
  return RTEMS_SUCCESSFUL;                                            
4000ddf0:	82 10 20 00 	clr  %g1                                       
}                                                                     
4000ddf4:	81 c7 e0 08 	ret                                            
4000ddf8:	91 e8 00 01 	restore  %g0, %g1, %o0                         
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
4000ddfc:	80 a0 bf fd 	cmp  %g2, -3                                   
4000de00:	18 bf ff fd 	bgu  4000ddf4 <rtems_string_to_unsigned_int+0x70><== ALWAYS TAKEN
4000de04:	82 10 20 0a 	mov  0xa, %g1                                  
    errno = ERANGE;                                                   
    return RTEMS_INVALID_NUMBER;                                      
  }                                                                   
#endif                                                                
                                                                      
  *n = result;                                                        
4000de08:	10 bf ff fa 	b  4000ddf0 <rtems_string_to_unsigned_int+0x6c><== NOT EXECUTED
4000de0c:	fa 26 40 00 	st  %i5, [ %i1 ]                               <== NOT EXECUTED
                                                                      

4000b78c <rtems_string_to_unsigned_long>: const char *s, unsigned long *n, char **endptr, int base ) {
4000b78c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  unsigned long result;                                               
  char *end;                                                          
                                                                      
  if ( !n )                                                           
4000b790:	80 a6 60 00 	cmp  %i1, 0                                    
4000b794:	02 80 00 1a 	be  4000b7fc <rtems_string_to_unsigned_long+0x70>
4000b798:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
4000b79c:	40 00 bf 73 	call  4003b568 <__errno>                       
4000b7a0:	01 00 00 00 	nop                                            
4000b7a4:	c0 22 00 00 	clr  [ %o0 ]                                   
  *n = 0;                                                             
4000b7a8:	c0 26 40 00 	clr  [ %i1 ]                                   
                                                                      
  result = strtoul( s, &end, base );                                  
4000b7ac:	90 10 00 18 	mov  %i0, %o0                                  
4000b7b0:	92 07 bf fc 	add  %fp, -4, %o1                              
4000b7b4:	40 00 e1 91 	call  40043df8 <strtoul>                       
4000b7b8:	94 10 00 1b 	mov  %i3, %o2                                  
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
4000b7bc:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtoul( s, &end, base );                                  
                                                                      
  if ( endptr )                                                       
4000b7c0:	80 a6 a0 00 	cmp  %i2, 0                                    
4000b7c4:	02 80 00 03 	be  4000b7d0 <rtems_string_to_unsigned_long+0x44>
4000b7c8:	ba 10 00 08 	mov  %o0, %i5                                  
    *endptr = end;                                                    
4000b7cc:	c4 26 80 00 	st  %g2, [ %i2 ]                               
                                                                      
  if ( end == s )                                                     
4000b7d0:	80 a6 00 02 	cmp  %i0, %g2                                  
4000b7d4:	02 80 00 0a 	be  4000b7fc <rtems_string_to_unsigned_long+0x70>
4000b7d8:	82 10 20 0b 	mov  0xb, %g1                                  
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
4000b7dc:	40 00 bf 63 	call  4003b568 <__errno>                       
4000b7e0:	01 00 00 00 	nop                                            
4000b7e4:	c2 02 00 00 	ld  [ %o0 ], %g1                               
4000b7e8:	80 a0 60 22 	cmp  %g1, 0x22                                 
4000b7ec:	02 80 00 06 	be  4000b804 <rtems_string_to_unsigned_long+0x78>
4000b7f0:	84 07 7f ff 	add  %i5, -1, %g2                              
    (( result == 0 ) || ( result == ULONG_MAX )))                     
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  *n = result;                                                        
4000b7f4:	fa 26 40 00 	st  %i5, [ %i1 ]                               
                                                                      
  return RTEMS_SUCCESSFUL;                                            
4000b7f8:	82 10 20 00 	clr  %g1                                       
}                                                                     
4000b7fc:	81 c7 e0 08 	ret                                            
4000b800:	91 e8 00 01 	restore  %g0, %g1, %o0                         
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
4000b804:	80 a0 bf fd 	cmp  %g2, -3                                   
4000b808:	18 bf ff fd 	bgu  4000b7fc <rtems_string_to_unsigned_long+0x70><== ALWAYS TAKEN
4000b80c:	82 10 20 0a 	mov  0xa, %g1                                  
    (( result == 0 ) || ( result == ULONG_MAX )))                     
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  *n = result;                                                        
4000b810:	10 bf ff fa 	b  4000b7f8 <rtems_string_to_unsigned_long+0x6c><== NOT EXECUTED
4000b814:	fa 26 40 00 	st  %i5, [ %i1 ]                               <== NOT EXECUTED
                                                                      

4000de10 <rtems_string_to_unsigned_long_long>: const char *s, unsigned long long *n, char **endptr, int base ) {
4000de10:	9d e3 bf 98 	save  %sp, -104, %sp                           
  unsigned long long result;                                          
  char *end;                                                          
                                                                      
  if ( !n )                                                           
4000de14:	80 a6 60 00 	cmp  %i1, 0                                    
4000de18:	02 80 00 1c 	be  4000de88 <rtems_string_to_unsigned_long_long+0x78>
4000de1c:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
4000de20:	40 00 0b 14 	call  40010a70 <__errno>                       
4000de24:	01 00 00 00 	nop                                            
4000de28:	c0 22 00 00 	clr  [ %o0 ]                                   
  *n = 0;                                                             
4000de2c:	c0 26 40 00 	clr  [ %i1 ]                                   
4000de30:	c0 26 60 04 	clr  [ %i1 + 4 ]                               
                                                                      
  result = strtoull( s, &end, base );                                 
4000de34:	90 10 00 18 	mov  %i0, %o0                                  
4000de38:	92 07 bf fc 	add  %fp, -4, %o1                              
4000de3c:	40 00 18 6d 	call  40013ff0 <strtoull>                      
4000de40:	94 10 00 1b 	mov  %i3, %o2                                  
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
4000de44:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtoull( s, &end, base );                                 
4000de48:	b8 10 00 08 	mov  %o0, %i4                                  
                                                                      
  if ( endptr )                                                       
4000de4c:	80 a6 a0 00 	cmp  %i2, 0                                    
4000de50:	02 80 00 03 	be  4000de5c <rtems_string_to_unsigned_long_long+0x4c>
4000de54:	ba 10 00 09 	mov  %o1, %i5                                  
    *endptr = end;                                                    
4000de58:	c4 26 80 00 	st  %g2, [ %i2 ]                               
                                                                      
  if ( end == s )                                                     
4000de5c:	80 a6 00 02 	cmp  %i0, %g2                                  
4000de60:	02 80 00 0a 	be  4000de88 <rtems_string_to_unsigned_long_long+0x78>
4000de64:	82 10 20 0b 	mov  0xb, %g1                                  
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
4000de68:	40 00 0b 02 	call  40010a70 <__errno>                       
4000de6c:	01 00 00 00 	nop                                            
4000de70:	c2 02 00 00 	ld  [ %o0 ], %g1                               
4000de74:	80 a0 60 22 	cmp  %g1, 0x22                                 
4000de78:	02 80 00 06 	be  4000de90 <rtems_string_to_unsigned_long_long+0x80>
4000de7c:	86 87 7f ff 	addcc  %i5, -1, %g3                            
    (( result == 0 ) || ( result == ULONG_LONG_MAX )))                
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  *n = result;                                                        
4000de80:	f8 3e 40 00 	std  %i4, [ %i1 ]                              
                                                                      
  return RTEMS_SUCCESSFUL;                                            
4000de84:	82 10 20 00 	clr  %g1                                       
}                                                                     
4000de88:	81 c7 e0 08 	ret                                            
4000de8c:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
    (( result == 0 ) || ( result == ULONG_LONG_MAX )))                
4000de90:	84 47 3f ff 	addx  %i4, -1, %g2                             
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
4000de94:	80 a0 bf ff 	cmp  %g2, -1                                   
4000de98:	12 bf ff fa 	bne  4000de80 <rtems_string_to_unsigned_long_long+0x70><== NEVER TAKEN
4000de9c:	80 a0 ff fd 	cmp  %g3, -3                                   
4000dea0:	18 bf ff fa 	bgu  4000de88 <rtems_string_to_unsigned_long_long+0x78><== ALWAYS TAKEN
4000dea4:	82 10 20 0a 	mov  0xa, %g1                                  
    (( result == 0 ) || ( result == ULONG_LONG_MAX )))                
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  *n = result;                                                        
4000dea8:	10 bf ff f7 	b  4000de84 <rtems_string_to_unsigned_long_long+0x74><== NOT EXECUTED
4000deac:	f8 3e 40 00 	std  %i4, [ %i1 ]                              <== NOT EXECUTED
                                                                      

40002a40 <rtems_tarfs_load>: int rtems_tarfs_load( const char *mountpoint, uint8_t *tar_image, size_t tar_size ) {
40002a40:	9d e3 bd e0 	save  %sp, -544, %sp                           
   IMFS_jnode_t                    *node;                             
   int rv = 0;                                                        
   int eval_flags = RTEMS_FS_FOLLOW_LINK;                             
   rtems_filesystem_eval_path_context_t ctx;                          
   rtems_filesystem_location_info_t rootloc;                          
   rtems_filesystem_location_info_t *currentloc =                     
40002a44:	94 10 20 18 	mov  0x18, %o2                                 
40002a48:	92 10 00 18 	mov  %i0, %o1                                  
40002a4c:	40 00 08 18 	call  40004aac <rtems_filesystem_eval_path_start>
40002a50:	90 07 be 60 	add  %fp, -416, %o0                            
static inline void rtems_filesystem_eval_path_extract_currentloc(     
  rtems_filesystem_eval_path_context_t *ctx,                          
  rtems_filesystem_location_info_t *get                               
)                                                                     
{                                                                     
  rtems_filesystem_location_copy_and_detach(                          
40002a54:	92 07 be 78 	add  %fp, -392, %o1                            
40002a58:	aa 10 00 08 	mov  %o0, %l5                                  
40002a5c:	40 00 09 0d 	call  40004e90 <rtems_filesystem_location_copy_and_detach>
40002a60:	90 07 be 48 	add  %fp, -440, %o0                            
     &ctx,                                                            
     RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE                               
   );                                                                 
                                                                      
   if (                                                               
     rootloc.mt_entry->ops != &IMFS_ops                               
40002a64:	c2 07 be 5c 	ld  [ %fp + -420 ], %g1                        
static inline void rtems_filesystem_eval_path_set_flags(              
  rtems_filesystem_eval_path_context_t *ctx,                          
  int flags                                                           
)                                                                     
{                                                                     
  ctx->flags = flags;                                                 
40002a68:	84 10 20 60 	mov  0x60, %g2                                 
40002a6c:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
40002a70:	c4 27 be 70 	st  %g2, [ %fp + -400 ]                        
   rtems_filesystem_eval_path_set_flags(                              
     &ctx,                                                            
     RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE                               
   );                                                                 
                                                                      
   if (                                                               
40002a74:	05 10 00 85 	sethi  %hi(0x40021400), %g2                    
40002a78:	84 10 a2 d0 	or  %g2, 0x2d0, %g2	! 400216d0 <IMFS_ops>      
40002a7c:	80 a0 40 02 	cmp  %g1, %g2                                  
40002a80:	02 80 00 06 	be  40002a98 <rtems_tarfs_load+0x58>           
40002a84:	05 10 00 88 	sethi  %hi(0x40022000), %g2                    
     rootloc.mt_entry->ops != &IMFS_ops                               
       && rootloc.mt_entry->ops != &fifoIMFS_ops                      
40002a88:	84 10 a0 70 	or  %g2, 0x70, %g2	! 40022070 <fifoIMFS_ops>   
40002a8c:	80 a0 40 02 	cmp  %g1, %g2                                  
40002a90:	12 80 00 78 	bne  40002c70 <rtems_tarfs_load+0x230>         <== ALWAYS TAKEN
40002a94:	01 00 00 00 	nop                                            
   /*                                                                 
    * Create an IMFS node structure pointing to tar image memory.     
    */                                                                
   offset = 0;                                                        
   while ( rv == 0 ) {                                                
    if (offset + 512 > tar_size)                                      
40002a98:	80 a6 a1 ff 	cmp  %i2, 0x1ff                                
40002a9c:	08 80 00 4b 	bleu  40002bc8 <rtems_tarfs_load+0x188>        <== NEVER TAKEN
40002aa0:	01 00 00 00 	nop                                            
     * - For directories, just create directories as usual.  IMFS     
     *   will take care of the rest.                                  
     * - For files, create a file node with special tarfs properties. 
     */                                                               
    if (linkflag == DIRTYPE) {                                        
      strcpy(full_filename, mountpoint);                              
40002aa4:	ac 07 bf 00 	add  %fp, -256, %l6                            
    /*                                                                
     * Read a header.                                                 
     */                                                               
    hdr_ptr = (char *) &tar_image[offset];                            
    offset += 512;                                                    
    if (strncmp(&hdr_ptr[257], "ustar", 5))                           
40002aa8:	27 10 00 85 	sethi  %hi(0x40021400), %l3                    
     * - For directories, just create directories as usual.  IMFS     
     *   will take care of the rest.                                  
     * - For files, create a file node with special tarfs properties. 
     */                                                               
    if (linkflag == DIRTYPE) {                                        
      strcpy(full_filename, mountpoint);                              
40002aac:	84 38 00 16 	xnor  %g0, %l6, %g2                            
   /*                                                                 
    * Create an IMFS node structure pointing to tar image memory.     
    */                                                                
   offset = 0;                                                        
   while ( rv == 0 ) {                                                
    if (offset + 512 > tar_size)                                      
40002ab0:	a2 10 22 00 	mov  0x200, %l1                                
40002ab4:	b8 10 22 00 	mov  0x200, %i4                                
40002ab8:	ba 10 20 00 	clr  %i5                                       
    /*                                                                
     * Read a header.                                                 
     */                                                               
    hdr_ptr = (char *) &tar_image[offset];                            
    offset += 512;                                                    
    if (strncmp(&hdr_ptr[257], "ustar", 5))                           
40002abc:	a6 14 e3 58 	or  %l3, 0x358, %l3                            
      break;                                                          
                                                                      
    strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);                  
40002ac0:	a0 07 be 98 	add  %fp, -360, %l0                            
     * - For directories, just create directories as usual.  IMFS     
     *   will take care of the rest.                                  
     * - For files, create a file node with special tarfs properties. 
     */                                                               
    if (linkflag == DIRTYPE) {                                        
      strcpy(full_filename, mountpoint);                              
40002ac4:	10 80 00 08 	b  40002ae4 <rtems_tarfs_load+0xa4>            
40002ac8:	c4 27 be 44 	st  %g2, [ %fp + -444 ]                        
      mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);              
    }                                                                 
    /*                                                                
     * Create a LINEAR_FILE node                                      
     */                                                               
    else if (linkflag == REGTYPE) {                                   
40002acc:	02 80 00 46 	be  40002be4 <rtems_tarfs_load+0x1a4>          
40002ad0:	ba 10 00 1c 	mov  %i4, %i5                                  
   /*                                                                 
    * Create an IMFS node structure pointing to tar image memory.     
    */                                                                
   offset = 0;                                                        
   while ( rv == 0 ) {                                                
    if (offset + 512 > tar_size)                                      
40002ad4:	b8 07 62 00 	add  %i5, 0x200, %i4                           
40002ad8:	80 a7 00 1a 	cmp  %i4, %i2                                  
40002adc:	18 80 00 3b 	bgu  40002bc8 <rtems_tarfs_load+0x188>         <== NEVER TAKEN
40002ae0:	a2 10 00 1c 	mov  %i4, %l1                                  
      break;                                                          
                                                                      
    /*                                                                
     * Read a header.                                                 
     */                                                               
    hdr_ptr = (char *) &tar_image[offset];                            
40002ae4:	ba 06 40 1d 	add  %i1, %i5, %i5                             
    offset += 512;                                                    
    if (strncmp(&hdr_ptr[257], "ustar", 5))                           
40002ae8:	92 10 00 13 	mov  %l3, %o1                                  
40002aec:	90 07 61 01 	add  %i5, 0x101, %o0                           
40002af0:	40 00 46 2a 	call  40014398 <strncmp>                       
40002af4:	94 10 20 05 	mov  5, %o2                                    
40002af8:	80 a2 20 00 	cmp  %o0, 0                                    
40002afc:	12 80 00 33 	bne  40002bc8 <rtems_tarfs_load+0x188>         
40002b00:	94 10 20 63 	mov  0x63, %o2                                 
      break;                                                          
                                                                      
    strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);                  
40002b04:	92 10 00 1d 	mov  %i5, %o1                                  
40002b08:	40 00 46 7a 	call  400144f0 <strncpy>                       
40002b0c:	90 10 00 10 	mov  %l0, %o0                                  
    filename[MAX_NAME_FIELD_SIZE] = '\0';                             
                                                                      
    linkflag   = hdr_ptr[156];                                        
    file_mode  = _rtems_octal2ulong(&hdr_ptr[100], 8);                
40002b10:	92 10 20 08 	mov  8, %o1                                    
    offset += 512;                                                    
    if (strncmp(&hdr_ptr[257], "ustar", 5))                           
      break;                                                          
                                                                      
    strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);                  
    filename[MAX_NAME_FIELD_SIZE] = '\0';                             
40002b14:	c0 2f be fb 	clrb  [ %fp + -261 ]                           
                                                                      
    linkflag   = hdr_ptr[156];                                        
40002b18:	f6 0f 60 9c 	ldub  [ %i5 + 0x9c ], %i3                      
    file_mode  = _rtems_octal2ulong(&hdr_ptr[100], 8);                
40002b1c:	40 00 23 00 	call  4000b71c <_rtems_octal2ulong>            
40002b20:	90 07 60 64 	add  %i5, 0x64, %o0                            
    file_size  = _rtems_octal2ulong(&hdr_ptr[124], 12);               
40002b24:	92 10 20 0c 	mov  0xc, %o1                                  
                                                                      
    strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);                  
    filename[MAX_NAME_FIELD_SIZE] = '\0';                             
                                                                      
    linkflag   = hdr_ptr[156];                                        
    file_mode  = _rtems_octal2ulong(&hdr_ptr[100], 8);                
40002b28:	a8 10 00 08 	mov  %o0, %l4                                  
    file_size  = _rtems_octal2ulong(&hdr_ptr[124], 12);               
40002b2c:	40 00 22 fc 	call  4000b71c <_rtems_octal2ulong>            
40002b30:	90 07 60 7c 	add  %i5, 0x7c, %o0                            
    hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);                
40002b34:	92 10 20 08 	mov  8, %o1                                    
    strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);                  
    filename[MAX_NAME_FIELD_SIZE] = '\0';                             
                                                                      
    linkflag   = hdr_ptr[156];                                        
    file_mode  = _rtems_octal2ulong(&hdr_ptr[100], 8);                
    file_size  = _rtems_octal2ulong(&hdr_ptr[124], 12);               
40002b38:	a4 10 00 08 	mov  %o0, %l2                                  
    hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);                
40002b3c:	40 00 22 f8 	call  4000b71c <_rtems_octal2ulong>            
40002b40:	90 07 60 94 	add  %i5, 0x94, %o0                            
40002b44:	ae 10 00 08 	mov  %o0, %l7                                  
                                                                      
    if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)            
40002b48:	40 00 24 4f 	call  4000bc84 <_rtems_tar_header_checksum>    
40002b4c:	90 10 00 1d 	mov  %i5, %o0                                  
40002b50:	80 a2 00 17 	cmp  %o0, %l7                                  
40002b54:	12 80 00 1d 	bne  40002bc8 <rtems_tarfs_load+0x188>         <== NEVER TAKEN
40002b58:	01 00 00 00 	nop                                            
     * Generate an IMFS node depending on the file type.              
     * - For directories, just create directories as usual.  IMFS     
     *   will take care of the rest.                                  
     * - For files, create a file node with special tarfs properties. 
     */                                                               
    if (linkflag == DIRTYPE) {                                        
40002b5c:	b6 0e e0 ff 	and  %i3, 0xff, %i3                            
40002b60:	80 a6 e0 35 	cmp  %i3, 0x35                                 
40002b64:	12 bf ff da 	bne  40002acc <rtems_tarfs_load+0x8c>          
40002b68:	80 a6 e0 30 	cmp  %i3, 0x30                                 
      strcpy(full_filename, mountpoint);                              
40002b6c:	90 10 00 16 	mov  %l6, %o0                                  
40002b70:	40 00 43 a6 	call  40013a08 <stpcpy>                        
40002b74:	92 10 00 18 	mov  %i0, %o1                                  
      if (full_filename[strlen(full_filename)-1] != '/')              
40002b78:	c4 07 be 44 	ld  [ %fp + -444 ], %g2                        
40002b7c:	82 07 80 08 	add  %fp, %o0, %g1                             
40002b80:	82 00 40 02 	add  %g1, %g2, %g1                             
40002b84:	c2 48 7f 00 	ldsb  [ %g1 + -256 ], %g1                      
40002b88:	80 a0 60 2f 	cmp  %g1, 0x2f                                 
40002b8c:	02 80 00 04 	be  40002b9c <rtems_tarfs_load+0x15c>          <== ALWAYS TAKEN
40002b90:	82 10 20 2f 	mov  0x2f, %g1                                 
        strcat(full_filename, "/");                                   
40002b94:	c0 2a 20 01 	clrb  [ %o0 + 1 ]                              <== NOT EXECUTED
40002b98:	c2 2a 00 00 	stb  %g1, [ %o0 ]                              <== NOT EXECUTED
      strcat(full_filename, filename);                                
40002b9c:	92 10 00 10 	mov  %l0, %o1                                  
40002ba0:	40 00 43 b9 	call  40013a84 <strcat>                        
40002ba4:	90 10 00 16 	mov  %l6, %o0                                  
      mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);              
40002ba8:	90 10 00 16 	mov  %l6, %o0                                  
40002bac:	40 00 04 14 	call  40003bfc <mkdir>                         
40002bb0:	92 10 21 ff 	mov  0x1ff, %o1                                
40002bb4:	ba 10 00 1c 	mov  %i4, %i5                                  
   /*                                                                 
    * Create an IMFS node structure pointing to tar image memory.     
    */                                                                
   offset = 0;                                                        
   while ( rv == 0 ) {                                                
    if (offset + 512 > tar_size)                                      
40002bb8:	b8 07 62 00 	add  %i5, 0x200, %i4                           
40002bbc:	80 a7 00 1a 	cmp  %i4, %i2                                  
40002bc0:	08 bf ff c9 	bleu  40002ae4 <rtems_tarfs_load+0xa4>         <== ALWAYS TAKEN
40002bc4:	a2 10 00 1c 	mov  %i4, %l1                                  
      nblocks = (((file_size) + 511) & ~511) / 512;                   
      offset += 512 * nblocks;                                        
    }                                                                 
  }                                                                   
                                                                      
  rtems_filesystem_location_free( &rootloc );                         
40002bc8:	40 00 02 6e 	call  40003580 <rtems_filesystem_location_free>
40002bcc:	90 07 be 48 	add  %fp, -440, %o0                            
                                                                      
   if (                                                               
     rootloc.mt_entry->ops != &IMFS_ops                               
       && rootloc.mt_entry->ops != &fifoIMFS_ops                      
   ) {                                                                
     rv = -1;                                                         
40002bd0:	b0 10 20 00 	clr  %i0                                       
      offset += 512 * nblocks;                                        
    }                                                                 
  }                                                                   
                                                                      
  rtems_filesystem_location_free( &rootloc );                         
  rtems_filesystem_eval_path_cleanup( &ctx );                         
40002bd4:	40 00 07 f6 	call  40004bac <rtems_filesystem_eval_path_cleanup>
40002bd8:	90 07 be 60 	add  %fp, -416, %o0                            
40002bdc:	81 c7 e0 08 	ret                                            
40002be0:	81 e8 00 00 	restore                                        
    }                                                                 
    /*                                                                
     * Create a LINEAR_FILE node                                      
     */                                                               
    else if (linkflag == REGTYPE) {                                   
      rtems_filesystem_location_free( currentloc );                   
40002be4:	40 00 02 67 	call  40003580 <rtems_filesystem_location_free>
40002be8:	90 10 00 15 	mov  %l5, %o0                                  
      rtems_filesystem_location_clone( currentloc, &rootloc );        
40002bec:	92 07 be 48 	add  %fp, -440, %o1                            
40002bf0:	40 00 01 96 	call  40003248 <rtems_filesystem_location_clone>
40002bf4:	90 10 00 15 	mov  %l5, %o0                                  
      rtems_filesystem_eval_path_set_path(                            
40002bf8:	40 00 45 b6 	call  400142d0 <strlen>                        
40002bfc:	90 10 00 10 	mov  %l0, %o0                                  
  rtems_filesystem_eval_path_context_t *ctx,                          
  const char *path,                                                   
  size_t pathlen                                                      
)                                                                     
{                                                                     
  ctx->path = path;                                                   
40002c00:	e0 27 be 60 	st  %l0, [ %fp + -416 ]                        
  ctx->pathlen = pathlen;                                             
40002c04:	d0 27 be 64 	st  %o0, [ %fp + -412 ]                        
        &ctx,                                                         
        filename,                                                     
        strlen( filename )                                            
      );                                                              
      rtems_filesystem_eval_path_continue( &ctx );                    
40002c08:	40 00 07 2c 	call  400048b8 <rtems_filesystem_eval_path_continue>
40002c0c:	90 07 be 60 	add  %fp, -416, %o0                            
                                                                      
      if ( !rtems_filesystem_location_is_null( currentloc ) ) {       
40002c10:	c2 05 60 10 	ld  [ %l5 + 0x10 ], %g1                        
40002c14:	05 10 00 87 	sethi  %hi(0x40021c00), %g2                    
40002c18:	84 10 a1 cc 	or  %g2, 0x1cc, %g2	! 40021dcc <rtems_filesystem_null_handlers>
40002c1c:	80 a0 40 02 	cmp  %g1, %g2                                  
40002c20:	02 80 00 10 	be  40002c60 <rtems_tarfs_load+0x220>          <== NEVER TAKEN
40002c24:	d4 07 be 68 	ld  [ %fp + -408 ], %o2                        
  size_t namelen,                                                     
  mode_t mode,                                                        
  const IMFS_types_union *info                                        
)                                                                     
{                                                                     
  const IMFS_fs_info_t *fs_info =                                     
40002c28:	c2 05 60 14 	ld  [ %l5 + 0x14 ], %g1                        
    (const IMFS_fs_info_t *) parentloc->mt_entry->fs_info;            
                                                                      
  return IMFS_create_node_with_control(                               
40002c2c:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
40002c30:	d6 07 be 6c 	ld  [ %fp + -404 ], %o3                        
40002c34:	d2 00 60 1c 	ld  [ %g1 + 0x1c ], %o1                        
40002c38:	03 00 00 20 	sethi  %hi(0x8000), %g1                        
        node = IMFS_create_node(                                      
          currentloc,                                                 
          IMFS_LINEAR_FILE,                                           
          rtems_filesystem_eval_path_get_token( &ctx ),               
          rtems_filesystem_eval_path_get_tokenlen( &ctx ),            
          (file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,      
40002c3c:	98 0d 21 ff 	and  %l4, 0x1ff, %o4                           
40002c40:	90 10 00 15 	mov  %l5, %o0                                  
40002c44:	98 13 00 01 	or  %o4, %g1, %o4                              
40002c48:	40 00 24 c9 	call  4000bf6c <IMFS_create_node_with_control> 
40002c4c:	9a 10 20 00 	clr  %o5                                       
          NULL                                                        
        );                                                            
        node->info.linearfile.size   = file_size;                     
        node->info.linearfile.direct = &tar_image[offset];            
40002c50:	82 06 40 11 	add  %i1, %l1, %g1                             
          rtems_filesystem_eval_path_get_token( &ctx ),               
          rtems_filesystem_eval_path_get_tokenlen( &ctx ),            
          (file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,      
          NULL                                                        
        );                                                            
        node->info.linearfile.size   = file_size;                     
40002c54:	c0 22 20 50 	clr  [ %o0 + 0x50 ]                            
40002c58:	e4 22 20 54 	st  %l2, [ %o0 + 0x54 ]                        
        node->info.linearfile.direct = &tar_image[offset];            
40002c5c:	c2 22 20 58 	st  %g1, [ %o0 + 0x58 ]                        
      }                                                               
                                                                      
      nblocks = (((file_size) + 511) & ~511) / 512;                   
40002c60:	ba 04 a1 ff 	add  %l2, 0x1ff, %i5                           
      offset += 512 * nblocks;                                        
40002c64:	ba 0f 7e 00 	and  %i5, -512, %i5                            
40002c68:	10 bf ff 9b 	b  40002ad4 <rtems_tarfs_load+0x94>            
40002c6c:	ba 07 40 11 	add  %i5, %l1, %i5                             
    }                                                                 
  }                                                                   
                                                                      
  rtems_filesystem_location_free( &rootloc );                         
40002c70:	40 00 02 44 	call  40003580 <rtems_filesystem_location_free>
40002c74:	90 07 be 48 	add  %fp, -440, %o0                            
                                                                      
   if (                                                               
     rootloc.mt_entry->ops != &IMFS_ops                               
       && rootloc.mt_entry->ops != &fifoIMFS_ops                      
   ) {                                                                
     rv = -1;                                                         
40002c78:	b0 10 3f ff 	mov  -1, %i0                                   
      offset += 512 * nblocks;                                        
    }                                                                 
  }                                                                   
                                                                      
  rtems_filesystem_location_free( &rootloc );                         
  rtems_filesystem_eval_path_cleanup( &ctx );                         
40002c7c:	40 00 07 cc 	call  40004bac <rtems_filesystem_eval_path_cleanup>
40002c80:	90 07 be 60 	add  %fp, -416, %o0                            
40002c84:	81 c7 e0 08 	ret                                            
40002c88:	81 e8 00 00 	restore                                        
                                                                      

4001133c <rtems_task_mode>: rtems_status_code rtems_task_mode( rtems_mode mode_set, rtems_mode mask, rtems_mode *previous_mode_set ) {
4001133c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  ASR_Information    *asr;                                            
  bool                is_asr_enabled = false;                         
  bool                needs_asr_dispatching = false;                  
  rtems_mode          old_mode;                                       
                                                                      
  if ( !previous_mode_set )                                           
40011340:	80 a6 a0 00 	cmp  %i2, 0                                    
40011344:	02 80 00 3b 	be  40011430 <rtems_task_mode+0xf4>            
40011348:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  executing     = _Thread_Executing;                                  
4001134c:	21 10 00 6d 	sethi  %hi(0x4001b400), %l0                    
40011350:	a0 14 23 e0 	or  %l0, 0x3e0, %l0	! 4001b7e0 <_Per_CPU_Information>
40011354:	fa 04 20 10 	ld  [ %l0 + 0x10 ], %i5                        
  api = executing->API_Extensions[ THREAD_API_RTEMS ];                
  asr = &api->Signal;                                                 
                                                                      
  old_mode  = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
40011358:	c4 0f 60 70 	ldub  [ %i5 + 0x70 ], %g2                      
                                                                      
  if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
4001135c:	c2 07 60 78 	ld  [ %i5 + 0x78 ], %g1                        
                                                                      
  executing     = _Thread_Executing;                                  
  api = executing->API_Extensions[ THREAD_API_RTEMS ];                
  asr = &api->Signal;                                                 
                                                                      
  old_mode  = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
40011360:	80 a0 00 02 	cmp  %g0, %g2                                  
                                                                      
  if ( !previous_mode_set )                                           
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  executing     = _Thread_Executing;                                  
  api = executing->API_Extensions[ THREAD_API_RTEMS ];                
40011364:	f8 07 61 4c 	ld  [ %i5 + 0x14c ], %i4                       
  asr = &api->Signal;                                                 
                                                                      
  old_mode  = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
40011368:	b6 60 3f ff 	subx  %g0, -1, %i3                             
                                                                      
  if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
4001136c:	80 a0 60 00 	cmp  %g1, 0                                    
40011370:	12 80 00 40 	bne  40011470 <rtems_task_mode+0x134>          
40011374:	b7 2e e0 08 	sll  %i3, 8, %i3                               
    old_mode |= RTEMS_NO_TIMESLICE;                                   
  else                                                                
    old_mode |= RTEMS_TIMESLICE;                                      
                                                                      
  old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;           
40011378:	c2 0f 20 08 	ldub  [ %i4 + 8 ], %g1                         
4001137c:	80 a0 00 01 	cmp  %g0, %g1                                  
  old_mode |= _ISR_Get_level();                                       
40011380:	7f ff eb e1 	call  4000c304 <_CPU_ISR_Get_level>            
40011384:	a2 60 3f ff 	subx  %g0, -1, %l1                             
  if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
    old_mode |= RTEMS_NO_TIMESLICE;                                   
  else                                                                
    old_mode |= RTEMS_TIMESLICE;                                      
                                                                      
  old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;           
40011388:	a3 2c 60 0a 	sll  %l1, 0xa, %l1                             
4001138c:	90 14 40 08 	or  %l1, %o0, %o0                              
  old_mode |= _ISR_Get_level();                                       
40011390:	b6 12 00 1b 	or  %o0, %i3, %i3                              
  *previous_mode_set = old_mode;                                      
                                                                      
  /*                                                                  
   *  These are generic thread scheduling characteristics.            
   */                                                                 
  if ( mask & RTEMS_PREEMPT_MASK )                                    
40011394:	80 8e 61 00 	btst  0x100, %i1                               
40011398:	02 80 00 06 	be  400113b0 <rtems_task_mode+0x74>            
4001139c:	f6 26 80 00 	st  %i3, [ %i2 ]                               
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Modes_Is_preempt (                         
  Modes_Control mode_set                                              
)                                                                     
{                                                                     
   return (mode_set & RTEMS_PREEMPT_MASK) == RTEMS_PREEMPT;           
400113a0:	83 36 20 08 	srl  %i0, 8, %g1                               
400113a4:	82 18 60 01 	xor  %g1, 1, %g1                               
400113a8:	82 08 60 01 	and  %g1, 1, %g1                               
    executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
400113ac:	c2 2f 60 70 	stb  %g1, [ %i5 + 0x70 ]                       
                                                                      
  if ( mask & RTEMS_TIMESLICE_MASK ) {                                
400113b0:	80 8e 62 00 	btst  0x200, %i1                               
400113b4:	12 80 00 21 	bne  40011438 <rtems_task_mode+0xfc>           
400113b8:	80 8e 22 00 	btst  0x200, %i0                               
  }                                                                   
                                                                      
  /*                                                                  
   *  Set the new interrupt level                                     
   */                                                                 
  if ( mask & RTEMS_INTERRUPT_MASK )                                  
400113bc:	80 8e 60 0f 	btst  0xf, %i1                                 
400113c0:	12 80 00 27 	bne  4001145c <rtems_task_mode+0x120>          
400113c4:	01 00 00 00 	nop                                            
   *  This is specific to the RTEMS API                               
   */                                                                 
  is_asr_enabled = false;                                             
  needs_asr_dispatching = false;                                      
                                                                      
  if ( mask & RTEMS_ASR_MASK ) {                                      
400113c8:	80 8e 64 00 	btst  0x400, %i1                               
400113cc:	02 80 00 14 	be  4001141c <rtems_task_mode+0xe0>            
400113d0:	86 10 20 00 	clr  %g3                                       
    is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
    if ( is_asr_enabled != asr->is_enabled ) {                        
400113d4:	c2 0f 20 08 	ldub  [ %i4 + 8 ], %g1                         
   */                                                                 
  is_asr_enabled = false;                                             
  needs_asr_dispatching = false;                                      
                                                                      
  if ( mask & RTEMS_ASR_MASK ) {                                      
    is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
400113d8:	b1 36 20 0a 	srl  %i0, 0xa, %i0                             
400113dc:	b0 1e 20 01 	xor  %i0, 1, %i0                               
400113e0:	b0 0e 20 01 	and  %i0, 1, %i0                               
    if ( is_asr_enabled != asr->is_enabled ) {                        
400113e4:	80 a6 00 01 	cmp  %i0, %g1                                  
400113e8:	22 80 00 0e 	be,a   40011420 <rtems_task_mode+0xe4>         
400113ec:	03 10 00 6d 	sethi  %hi(0x4001b400), %g1                    
)                                                                     
{                                                                     
  rtems_signal_set _signals;                                          
  ISR_Level        _level;                                            
                                                                      
  _ISR_Disable( _level );                                             
400113f0:	7f ff c5 17 	call  4000284c <sparc_disable_interrupts>      
400113f4:	f0 2f 20 08 	stb  %i0, [ %i4 + 8 ]                          
    _signals                     = information->signals_pending;      
400113f8:	c4 07 20 18 	ld  [ %i4 + 0x18 ], %g2                        
    information->signals_pending = information->signals_posted;       
400113fc:	c2 07 20 14 	ld  [ %i4 + 0x14 ], %g1                        
    information->signals_posted  = _signals;                          
40011400:	c4 27 20 14 	st  %g2, [ %i4 + 0x14 ]                        
  rtems_signal_set _signals;                                          
  ISR_Level        _level;                                            
                                                                      
  _ISR_Disable( _level );                                             
    _signals                     = information->signals_pending;      
    information->signals_pending = information->signals_posted;       
40011404:	c2 27 20 18 	st  %g1, [ %i4 + 0x18 ]                        
    information->signals_posted  = _signals;                          
  _ISR_Enable( _level );                                              
40011408:	7f ff c5 15 	call  4000285c <sparc_enable_interrupts>       
4001140c:	01 00 00 00 	nop                                            
      asr->is_enabled = is_asr_enabled;                               
      _ASR_Swap_signals( asr );                                       
      if ( _ASR_Are_signals_pending( asr ) ) {                        
40011410:	c2 07 20 14 	ld  [ %i4 + 0x14 ], %g1                        
40011414:	80 a0 00 01 	cmp  %g0, %g1                                  
40011418:	86 40 20 00 	addx  %g0, 0, %g3                              
        needs_asr_dispatching = true;                                 
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if ( _System_state_Is_up( _System_state_Get() ) ) {                 
4001141c:	03 10 00 6d 	sethi  %hi(0x4001b400), %g1                    
40011420:	c4 00 63 d8 	ld  [ %g1 + 0x3d8 ], %g2	! 4001b7d8 <_System_state_Current>
40011424:	80 a0 a0 03 	cmp  %g2, 3                                    
40011428:	02 80 00 1f 	be  400114a4 <rtems_task_mode+0x168>           
4001142c:	82 10 20 00 	clr  %g1                                       
     if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
      _Thread_Dispatch();                                             
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
40011430:	81 c7 e0 08 	ret                                            
40011434:	91 e8 00 01 	restore  %g0, %g1, %o0                         
   */                                                                 
  if ( mask & RTEMS_PREEMPT_MASK )                                    
    executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
                                                                      
  if ( mask & RTEMS_TIMESLICE_MASK ) {                                
    if ( _Modes_Is_timeslice(mode_set) ) {                            
40011438:	22 bf ff e1 	be,a   400113bc <rtems_task_mode+0x80>         
4001143c:	c0 27 60 78 	clr  [ %i5 + 0x78 ]                            
      executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
      executing->cpu_time_budget  = _Thread_Ticks_per_timeslice;      
40011440:	03 10 00 6c 	sethi  %hi(0x4001b000), %g1                    
40011444:	c2 00 62 30 	ld  [ %g1 + 0x230 ], %g1	! 4001b230 <_Thread_Ticks_per_timeslice>
  }                                                                   
                                                                      
  /*                                                                  
   *  Set the new interrupt level                                     
   */                                                                 
  if ( mask & RTEMS_INTERRUPT_MASK )                                  
40011448:	80 8e 60 0f 	btst  0xf, %i1                                 
    executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
                                                                      
  if ( mask & RTEMS_TIMESLICE_MASK ) {                                
    if ( _Modes_Is_timeslice(mode_set) ) {                            
      executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
      executing->cpu_time_budget  = _Thread_Ticks_per_timeslice;      
4001144c:	c2 27 60 74 	st  %g1, [ %i5 + 0x74 ]                        
  if ( mask & RTEMS_PREEMPT_MASK )                                    
    executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
                                                                      
  if ( mask & RTEMS_TIMESLICE_MASK ) {                                
    if ( _Modes_Is_timeslice(mode_set) ) {                            
      executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
40011450:	82 10 20 01 	mov  1, %g1                                    
  }                                                                   
                                                                      
  /*                                                                  
   *  Set the new interrupt level                                     
   */                                                                 
  if ( mask & RTEMS_INTERRUPT_MASK )                                  
40011454:	02 bf ff dd 	be  400113c8 <rtems_task_mode+0x8c>            
40011458:	c2 27 60 78 	st  %g1, [ %i5 + 0x78 ]                        
 */                                                                   
RTEMS_INLINE_ROUTINE ISR_Level _Modes_Get_interrupt_level (           
  Modes_Control mode_set                                              
)                                                                     
{                                                                     
  return ( mode_set & RTEMS_INTERRUPT_MASK );                         
4001145c:	90 0e 20 0f 	and  %i0, 0xf, %o0                             
 */                                                                   
RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level (                
  Modes_Control mode_set                                              
)                                                                     
{                                                                     
  _ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) );           
40011460:	7f ff c4 ff 	call  4000285c <sparc_enable_interrupts>       
40011464:	91 2a 20 08 	sll  %o0, 8, %o0                               
   *  This is specific to the RTEMS API                               
   */                                                                 
  is_asr_enabled = false;                                             
  needs_asr_dispatching = false;                                      
                                                                      
  if ( mask & RTEMS_ASR_MASK ) {                                      
40011468:	10 bf ff d9 	b  400113cc <rtems_task_mode+0x90>             
4001146c:	80 8e 64 00 	btst  0x400, %i1                               
  if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
    old_mode |= RTEMS_NO_TIMESLICE;                                   
  else                                                                
    old_mode |= RTEMS_TIMESLICE;                                      
                                                                      
  old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;           
40011470:	c2 0f 20 08 	ldub  [ %i4 + 8 ], %g1                         
  old_mode  = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
                                                                      
  if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
    old_mode |= RTEMS_NO_TIMESLICE;                                   
  else                                                                
    old_mode |= RTEMS_TIMESLICE;                                      
40011474:	b6 16 e2 00 	or  %i3, 0x200, %i3                            
                                                                      
  old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;           
40011478:	80 a0 00 01 	cmp  %g0, %g1                                  
  old_mode |= _ISR_Get_level();                                       
4001147c:	7f ff eb a2 	call  4000c304 <_CPU_ISR_Get_level>            
40011480:	a2 60 3f ff 	subx  %g0, -1, %l1                             
  if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
    old_mode |= RTEMS_NO_TIMESLICE;                                   
  else                                                                
    old_mode |= RTEMS_TIMESLICE;                                      
                                                                      
  old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;           
40011484:	a3 2c 60 0a 	sll  %l1, 0xa, %l1                             
40011488:	90 14 40 08 	or  %l1, %o0, %o0                              
  old_mode |= _ISR_Get_level();                                       
4001148c:	b6 12 00 1b 	or  %o0, %i3, %i3                              
  *previous_mode_set = old_mode;                                      
                                                                      
  /*                                                                  
   *  These are generic thread scheduling characteristics.            
   */                                                                 
  if ( mask & RTEMS_PREEMPT_MASK )                                    
40011490:	80 8e 61 00 	btst  0x100, %i1                               
40011494:	02 bf ff c7 	be  400113b0 <rtems_task_mode+0x74>            
40011498:	f6 26 80 00 	st  %i3, [ %i2 ]                               
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Modes_Is_preempt (                         
  Modes_Control mode_set                                              
)                                                                     
{                                                                     
   return (mode_set & RTEMS_PREEMPT_MASK) == RTEMS_PREEMPT;           
4001149c:	10 bf ff c2 	b  400113a4 <rtems_task_mode+0x68>             
400114a0:	83 36 20 08 	srl  %i0, 8, %g1                               
{                                                                     
  Thread_Control     *executing;                                      
                                                                      
  executing = _Thread_Executing;                                      
                                                                      
  if ( are_signals_pending ||                                         
400114a4:	80 88 e0 ff 	btst  0xff, %g3                                
400114a8:	12 80 00 0a 	bne  400114d0 <rtems_task_mode+0x194>          
400114ac:	c4 04 20 10 	ld  [ %l0 + 0x10 ], %g2                        
400114b0:	c6 04 20 14 	ld  [ %l0 + 0x14 ], %g3                        
400114b4:	80 a0 80 03 	cmp  %g2, %g3                                  
400114b8:	02 bf ff de 	be  40011430 <rtems_task_mode+0xf4>            
400114bc:	01 00 00 00 	nop                                            
       (!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
400114c0:	c4 08 a0 70 	ldub  [ %g2 + 0x70 ], %g2                      
400114c4:	80 a0 a0 00 	cmp  %g2, 0                                    
400114c8:	02 bf ff da 	be  40011430 <rtems_task_mode+0xf4>            <== NEVER TAKEN
400114cc:	01 00 00 00 	nop                                            
    _Thread_Dispatch_necessary = true;                                
400114d0:	82 10 20 01 	mov  1, %g1	! 1 <PROM_START+0x1>               
400114d4:	c2 2c 20 0c 	stb  %g1, [ %l0 + 0xc ]                        
    }                                                                 
  }                                                                   
                                                                      
  if ( _System_state_Is_up( _System_state_Get() ) ) {                 
     if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
      _Thread_Dispatch();                                             
400114d8:	40 00 02 95 	call  40011f2c <_Thread_Dispatch>              
400114dc:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
400114e0:	82 10 20 00 	clr  %g1	! 0 <PROM_START>                      
}                                                                     
400114e4:	81 c7 e0 08 	ret                                            
400114e8:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      

4000bd44 <rtems_task_set_priority>: rtems_status_code rtems_task_set_priority( rtems_id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) {
4000bd44:	9d e3 bf 98 	save  %sp, -104, %sp                           
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
                                                                      
  if ( new_priority != RTEMS_CURRENT_PRIORITY &&                      
4000bd48:	80 a6 60 00 	cmp  %i1, 0                                    
4000bd4c:	02 80 00 08 	be  4000bd6c <rtems_task_set_priority+0x28>    
4000bd50:	80 a6 a0 00 	cmp  %i2, 0                                    
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (            
  rtems_task_priority the_priority                                    
)                                                                     
{                                                                     
  return (  ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&             
            ( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );             
4000bd54:	03 10 00 6a 	sethi  %hi(0x4001a800), %g1                    
4000bd58:	c4 08 61 9c 	ldub  [ %g1 + 0x19c ], %g2	! 4001a99c <rtems_maximum_priority>
 */                                                                   
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (            
  rtems_task_priority the_priority                                    
)                                                                     
{                                                                     
  return (  ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&             
4000bd5c:	80 a6 40 02 	cmp  %i1, %g2                                  
4000bd60:	18 80 00 1e 	bgu  4000bdd8 <rtems_task_set_priority+0x94>   
4000bd64:	82 10 20 13 	mov  0x13, %g1                                 
       !_RTEMS_tasks_Priority_is_valid( new_priority ) )              
    return RTEMS_INVALID_PRIORITY;                                    
                                                                      
  if ( !old_priority )                                                
4000bd68:	80 a6 a0 00 	cmp  %i2, 0                                    
4000bd6c:	02 80 00 1b 	be  4000bdd8 <rtems_task_set_priority+0x94>    
4000bd70:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_thread = _Thread_Get( id, &location );                          
4000bd74:	90 10 00 18 	mov  %i0, %o0                                  
4000bd78:	40 00 0a 22 	call  4000e600 <_Thread_Get>                   
4000bd7c:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
4000bd80:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4000bd84:	80 a0 60 00 	cmp  %g1, 0                                    
4000bd88:	12 80 00 16 	bne  4000bde0 <rtems_task_set_priority+0x9c>   
4000bd8c:	82 10 20 04 	mov  4, %g1                                    
                                                                      
    case OBJECTS_LOCAL:                                               
      /* XXX need helper to "convert" from core priority */           
      *old_priority = the_thread->current_priority;                   
4000bd90:	c2 02 20 14 	ld  [ %o0 + 0x14 ], %g1                        
      if ( new_priority != RTEMS_CURRENT_PRIORITY ) {                 
4000bd94:	80 a6 60 00 	cmp  %i1, 0                                    
4000bd98:	02 80 00 0d 	be  4000bdcc <rtems_task_set_priority+0x88>    
4000bd9c:	c2 26 80 00 	st  %g1, [ %i2 ]                               
        the_thread->real_priority = new_priority;                     
        if ( the_thread->resource_count == 0 ||                       
4000bda0:	c2 02 20 1c 	ld  [ %o0 + 0x1c ], %g1                        
4000bda4:	80 a0 60 00 	cmp  %g1, 0                                    
4000bda8:	02 80 00 06 	be  4000bdc0 <rtems_task_set_priority+0x7c>    
4000bdac:	f2 22 20 18 	st  %i1, [ %o0 + 0x18 ]                        
4000bdb0:	c2 02 20 14 	ld  [ %o0 + 0x14 ], %g1                        
4000bdb4:	80 a6 40 01 	cmp  %i1, %g1                                  
4000bdb8:	1a 80 00 05 	bcc  4000bdcc <rtems_task_set_priority+0x88>   <== ALWAYS TAKEN
4000bdbc:	01 00 00 00 	nop                                            
             the_thread->current_priority > new_priority )            
          _Thread_Change_priority( the_thread, new_priority, false ); 
4000bdc0:	92 10 00 19 	mov  %i1, %o1                                  
4000bdc4:	40 00 08 c9 	call  4000e0e8 <_Thread_Change_priority>       
4000bdc8:	94 10 20 00 	clr  %o2                                       
      }                                                               
      _Thread_Enable_dispatch();                                      
4000bdcc:	40 00 0a 01 	call  4000e5d0 <_Thread_Enable_dispatch>       
4000bdd0:	01 00 00 00 	nop                                            
      return RTEMS_SUCCESSFUL;                                        
4000bdd4:	82 10 20 00 	clr  %g1	! 0 <PROM_START>                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
4000bdd8:	81 c7 e0 08 	ret                                            
4000bddc:	91 e8 00 01 	restore  %g0, %g1, %o0                         
4000bde0:	81 c7 e0 08 	ret                                            
4000bde4:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      

40006148 <rtems_task_variable_delete>: rtems_status_code rtems_task_variable_delete( rtems_id tid, void **ptr ) {
40006148:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Thread_Control        *the_thread;                                  
  Objects_Locations      location;                                    
  rtems_task_variable_t *tvp, *prev;                                  
                                                                      
  if ( !ptr )                                                         
4000614c:	80 a6 60 00 	cmp  %i1, 0                                    
40006150:	02 80 00 1e 	be  400061c8 <rtems_task_variable_delete+0x80> 
40006154:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  prev = NULL;                                                        
                                                                      
  the_thread = _Thread_Get (tid, &location);                          
40006158:	90 10 00 18 	mov  %i0, %o0                                  
4000615c:	40 00 08 b1 	call  40008420 <_Thread_Get>                   
40006160:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch (location) {                                                 
40006164:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40006168:	80 a0 60 00 	cmp  %g1, 0                                    
4000616c:	12 80 00 19 	bne  400061d0 <rtems_task_variable_delete+0x88>
40006170:	82 10 20 04 	mov  4, %g1                                    
                                                                      
    case OBJECTS_LOCAL:                                               
      tvp = the_thread->task_variables;                               
40006174:	c2 02 21 58 	ld  [ %o0 + 0x158 ], %g1                       
      while (tvp) {                                                   
40006178:	80 a0 60 00 	cmp  %g1, 0                                    
4000617c:	02 80 00 10 	be  400061bc <rtems_task_variable_delete+0x74> 
40006180:	01 00 00 00 	nop                                            
        if (tvp->ptr == ptr) {                                        
40006184:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
40006188:	80 a0 80 19 	cmp  %g2, %i1                                  
4000618c:	32 80 00 09 	bne,a   400061b0 <rtems_task_variable_delete+0x68>
40006190:	d2 00 40 00 	ld  [ %g1 ], %o1                               
          if (prev)                                                   
            prev->next = tvp->next;                                   
          else                                                        
            the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
40006194:	10 80 00 18 	b  400061f4 <rtems_task_variable_delete+0xac>  
40006198:	c4 00 40 00 	ld  [ %g1 ], %g2                               
  switch (location) {                                                 
                                                                      
    case OBJECTS_LOCAL:                                               
      tvp = the_thread->task_variables;                               
      while (tvp) {                                                   
        if (tvp->ptr == ptr) {                                        
4000619c:	80 a0 80 19 	cmp  %g2, %i1                                  
400061a0:	22 80 00 0e 	be,a   400061d8 <rtems_task_variable_delete+0x90>
400061a4:	c4 02 40 00 	ld  [ %o1 ], %g2                               
400061a8:	82 10 00 09 	mov  %o1, %g1                                  
          _RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );  
          _Thread_Enable_dispatch();                                  
          return RTEMS_SUCCESSFUL;                                    
        }                                                             
        prev = tvp;                                                   
        tvp = (rtems_task_variable_t *)tvp->next;                     
400061ac:	d2 00 40 00 	ld  [ %g1 ], %o1                               
  the_thread = _Thread_Get (tid, &location);                          
  switch (location) {                                                 
                                                                      
    case OBJECTS_LOCAL:                                               
      tvp = the_thread->task_variables;                               
      while (tvp) {                                                   
400061b0:	80 a2 60 00 	cmp  %o1, 0                                    
400061b4:	32 bf ff fa 	bne,a   4000619c <rtems_task_variable_delete+0x54><== ALWAYS TAKEN
400061b8:	c4 02 60 04 	ld  [ %o1 + 4 ], %g2                           
          return RTEMS_SUCCESSFUL;                                    
        }                                                             
        prev = tvp;                                                   
        tvp = (rtems_task_variable_t *)tvp->next;                     
      }                                                               
      _Thread_Enable_dispatch();                                      
400061bc:	40 00 08 8d 	call  400083f0 <_Thread_Enable_dispatch>       
400061c0:	01 00 00 00 	nop                                            
      return RTEMS_INVALID_ADDRESS;                                   
400061c4:	82 10 20 09 	mov  9, %g1	! 9 <PROM_START+0x9>               
    case OBJECTS_ERROR:                                               
        break;                                                        
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
400061c8:	81 c7 e0 08 	ret                                            
400061cc:	91 e8 00 01 	restore  %g0, %g1, %o0                         
400061d0:	81 c7 e0 08 	ret                                            
400061d4:	91 e8 00 01 	restore  %g0, %g1, %o0                         
    case OBJECTS_LOCAL:                                               
      tvp = the_thread->task_variables;                               
      while (tvp) {                                                   
        if (tvp->ptr == ptr) {                                        
          if (prev)                                                   
            prev->next = tvp->next;                                   
400061d8:	c4 20 40 00 	st  %g2, [ %g1 ]                               
          else                                                        
            the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
                                                                      
          _RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );  
400061dc:	40 00 00 2e 	call  40006294 <_RTEMS_Tasks_Invoke_task_variable_dtor>
400061e0:	01 00 00 00 	nop                                            
          _Thread_Enable_dispatch();                                  
400061e4:	40 00 08 83 	call  400083f0 <_Thread_Enable_dispatch>       
400061e8:	01 00 00 00 	nop                                            
          return RTEMS_SUCCESSFUL;                                    
400061ec:	10 bf ff f7 	b  400061c8 <rtems_task_variable_delete+0x80>  
400061f0:	82 10 20 00 	clr  %g1	! 0 <PROM_START>                      
      while (tvp) {                                                   
        if (tvp->ptr == ptr) {                                        
          if (prev)                                                   
            prev->next = tvp->next;                                   
          else                                                        
            the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
400061f4:	92 10 00 01 	mov  %g1, %o1                                  
400061f8:	10 bf ff f9 	b  400061dc <rtems_task_variable_delete+0x94>  
400061fc:	c4 22 21 58 	st  %g2, [ %o0 + 0x158 ]                       
                                                                      

40006200 <rtems_task_variable_get>: rtems_status_code rtems_task_variable_get( rtems_id tid, void **ptr, void **result ) {
40006200:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Thread_Control        *the_thread;                                  
  Objects_Locations      location;                                    
  rtems_task_variable_t *tvp;                                         
                                                                      
  if ( !ptr )                                                         
40006204:	80 a6 60 00 	cmp  %i1, 0                                    
40006208:	02 80 00 1b 	be  40006274 <rtems_task_variable_get+0x74>    
4000620c:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !result )                                                      
40006210:	80 a6 a0 00 	cmp  %i2, 0                                    
40006214:	02 80 00 18 	be  40006274 <rtems_task_variable_get+0x74>    
40006218:	90 10 00 18 	mov  %i0, %o0                                  
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_thread = _Thread_Get (tid, &location);                          
4000621c:	40 00 08 81 	call  40008420 <_Thread_Get>                   
40006220:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch (location) {                                                 
40006224:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40006228:	80 a0 60 00 	cmp  %g1, 0                                    
4000622c:	12 80 00 14 	bne  4000627c <rtems_task_variable_get+0x7c>   
40006230:	82 10 20 04 	mov  4, %g1                                    
                                                                      
    case OBJECTS_LOCAL:                                               
      /*                                                              
       *  Figure out if the variable is in this task's list.          
       */                                                             
      tvp = the_thread->task_variables;                               
40006234:	c2 02 21 58 	ld  [ %o0 + 0x158 ], %g1                       
      while (tvp) {                                                   
40006238:	80 a0 60 00 	cmp  %g1, 0                                    
4000623c:	32 80 00 07 	bne,a   40006258 <rtems_task_variable_get+0x58>
40006240:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
40006244:	30 80 00 10 	b,a   40006284 <rtems_task_variable_get+0x84>  
40006248:	80 a0 60 00 	cmp  %g1, 0                                    
4000624c:	02 80 00 0e 	be  40006284 <rtems_task_variable_get+0x84>    <== NEVER TAKEN
40006250:	01 00 00 00 	nop                                            
        if (tvp->ptr == ptr) {                                        
40006254:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
40006258:	80 a0 80 19 	cmp  %g2, %i1                                  
4000625c:	32 bf ff fb 	bne,a   40006248 <rtems_task_variable_get+0x48>
40006260:	c2 00 40 00 	ld  [ %g1 ], %g1                               
	  /*                                                                 
	   * Should this return the current (i.e not the                     
	   * saved) value if `tid' is the current task?                      
	   */                                                                
          *result = tvp->tval;                                        
40006264:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
          _Thread_Enable_dispatch();                                  
40006268:	40 00 08 62 	call  400083f0 <_Thread_Enable_dispatch>       
4000626c:	c2 26 80 00 	st  %g1, [ %i2 ]                               
          return RTEMS_SUCCESSFUL;                                    
40006270:	82 10 20 00 	clr  %g1                                       
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
  return RTEMS_INVALID_ID;                                            
}                                                                     
40006274:	81 c7 e0 08 	ret                                            
40006278:	91 e8 00 01 	restore  %g0, %g1, %o0                         
4000627c:	81 c7 e0 08 	ret                                            
40006280:	91 e8 00 01 	restore  %g0, %g1, %o0                         
          _Thread_Enable_dispatch();                                  
          return RTEMS_SUCCESSFUL;                                    
        }                                                             
        tvp = (rtems_task_variable_t *)tvp->next;                     
      }                                                               
      _Thread_Enable_dispatch();                                      
40006284:	40 00 08 5b 	call  400083f0 <_Thread_Enable_dispatch>       
40006288:	01 00 00 00 	nop                                            
      return RTEMS_INVALID_ADDRESS;                                   
4000628c:	10 bf ff fa 	b  40006274 <rtems_task_variable_get+0x74>     
40006290:	82 10 20 09 	mov  9, %g1	! 9 <PROM_START+0x9>               
                                                                      

40005cf0 <rtems_termios_baud_to_index>: rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) {
40005cf0:	80 a2 20 09 	cmp  %o0, 9                                    
40005cf4:	02 80 00 1c 	be  40005d64 <rtems_termios_baud_to_index+0x74>
40005cf8:	82 10 20 09 	mov  9, %g1                                    
40005cfc:	80 a2 20 09 	cmp  %o0, 9                                    
40005d00:	08 80 00 1b 	bleu  40005d6c <rtems_termios_baud_to_index+0x7c>
40005d04:	80 a2 20 04 	cmp  %o0, 4                                    
40005d08:	80 a2 20 0e 	cmp  %o0, 0xe                                  
40005d0c:	02 80 00 16 	be  40005d64 <rtems_termios_baud_to_index+0x74>
40005d10:	82 10 20 0e 	mov  0xe, %g1                                  
40005d14:	80 a2 20 0e 	cmp  %o0, 0xe                                  
40005d18:	08 80 00 28 	bleu  40005db8 <rtems_termios_baud_to_index+0xc8>
40005d1c:	80 a2 20 0b 	cmp  %o0, 0xb                                  
40005d20:	05 00 00 04 	sethi  %hi(0x1000), %g2                        
40005d24:	86 10 a0 02 	or  %g2, 2, %g3	! 1002 <PROM_START+0x1002>     
40005d28:	80 a2 00 03 	cmp  %o0, %g3                                  
40005d2c:	02 80 00 0e 	be  40005d64 <rtems_termios_baud_to_index+0x74>
40005d30:	82 10 20 11 	mov  0x11, %g1                                 
40005d34:	80 a2 00 03 	cmp  %o0, %g3                                  
40005d38:	08 80 00 3a 	bleu  40005e20 <rtems_termios_baud_to_index+0x130>
40005d3c:	80 a2 20 0f 	cmp  %o0, 0xf                                  
40005d40:	86 10 a0 03 	or  %g2, 3, %g3                                
40005d44:	80 a2 00 03 	cmp  %o0, %g3                                  
40005d48:	02 80 00 07 	be  40005d64 <rtems_termios_baud_to_index+0x74>
40005d4c:	82 10 20 12 	mov  0x12, %g1                                 
40005d50:	84 10 a0 04 	or  %g2, 4, %g2                                
40005d54:	80 a2 00 02 	cmp  %o0, %g2                                  
40005d58:	02 80 00 03 	be  40005d64 <rtems_termios_baud_to_index+0x74>
40005d5c:	82 10 20 13 	mov  0x13, %g1                                 
    case B38400:    baud_index = 15;  break;                          
    case B57600:    baud_index = 16;  break;                          
    case B115200:   baud_index = 17;  break;                          
    case B230400:   baud_index = 18;  break;                          
    case B460800:   baud_index = 19;  break;                          
    default:        baud_index = -1;  break;                          
40005d60:	82 10 3f ff 	mov  -1, %g1                                   
  }                                                                   
                                                                      
  return baud_index;                                                  
}                                                                     
40005d64:	81 c3 e0 08 	retl                                           
40005d68:	90 10 00 01 	mov  %g1, %o0                                  
  rtems_termios_baud_t termios_baud                                   
)                                                                     
{                                                                     
  int baud_index;                                                     
                                                                      
  switch (termios_baud) {                                             
40005d6c:	02 bf ff fe 	be  40005d64 <rtems_termios_baud_to_index+0x74>
40005d70:	82 10 20 04 	mov  4, %g1                                    
40005d74:	80 a2 20 04 	cmp  %o0, 4                                    
40005d78:	08 80 00 1d 	bleu  40005dec <rtems_termios_baud_to_index+0xfc>
40005d7c:	80 a2 20 01 	cmp  %o0, 1                                    
40005d80:	80 a2 20 06 	cmp  %o0, 6                                    
40005d84:	02 bf ff f8 	be  40005d64 <rtems_termios_baud_to_index+0x74>
40005d88:	82 10 20 06 	mov  6, %g1                                    
40005d8c:	80 a2 20 06 	cmp  %o0, 6                                    
40005d90:	0a bf ff f5 	bcs  40005d64 <rtems_termios_baud_to_index+0x74>
40005d94:	82 10 20 05 	mov  5, %g1                                    
40005d98:	80 a2 20 07 	cmp  %o0, 7                                    
40005d9c:	02 bf ff f2 	be  40005d64 <rtems_termios_baud_to_index+0x74>
40005da0:	82 10 20 07 	mov  7, %g1                                    
40005da4:	80 a2 20 08 	cmp  %o0, 8                                    
40005da8:	02 bf ff ef 	be  40005d64 <rtems_termios_baud_to_index+0x74><== ALWAYS TAKEN
40005dac:	82 10 20 08 	mov  8, %g1                                    
    case B38400:    baud_index = 15;  break;                          
    case B57600:    baud_index = 16;  break;                          
    case B115200:   baud_index = 17;  break;                          
    case B230400:   baud_index = 18;  break;                          
    case B460800:   baud_index = 19;  break;                          
    default:        baud_index = -1;  break;                          
40005db0:	10 bf ff ed 	b  40005d64 <rtems_termios_baud_to_index+0x74> <== NOT EXECUTED
40005db4:	82 10 3f ff 	mov  -1, %g1                                   <== NOT EXECUTED
  rtems_termios_baud_t termios_baud                                   
)                                                                     
{                                                                     
  int baud_index;                                                     
                                                                      
  switch (termios_baud) {                                             
40005db8:	02 bf ff eb 	be  40005d64 <rtems_termios_baud_to_index+0x74>
40005dbc:	82 10 20 0b 	mov  0xb, %g1                                  
40005dc0:	80 a2 20 0b 	cmp  %o0, 0xb                                  
40005dc4:	0a bf ff e8 	bcs  40005d64 <rtems_termios_baud_to_index+0x74>
40005dc8:	82 10 20 0a 	mov  0xa, %g1                                  
40005dcc:	80 a2 20 0c 	cmp  %o0, 0xc                                  
40005dd0:	02 bf ff e5 	be  40005d64 <rtems_termios_baud_to_index+0x74>
40005dd4:	82 10 20 0c 	mov  0xc, %g1                                  
40005dd8:	80 a2 20 0d 	cmp  %o0, 0xd                                  
40005ddc:	02 bf ff e2 	be  40005d64 <rtems_termios_baud_to_index+0x74><== ALWAYS TAKEN
40005de0:	82 10 20 0d 	mov  0xd, %g1                                  
    case B38400:    baud_index = 15;  break;                          
    case B57600:    baud_index = 16;  break;                          
    case B115200:   baud_index = 17;  break;                          
    case B230400:   baud_index = 18;  break;                          
    case B460800:   baud_index = 19;  break;                          
    default:        baud_index = -1;  break;                          
40005de4:	10 bf ff e0 	b  40005d64 <rtems_termios_baud_to_index+0x74> <== NOT EXECUTED
40005de8:	82 10 3f ff 	mov  -1, %g1                                   <== NOT EXECUTED
  rtems_termios_baud_t termios_baud                                   
)                                                                     
{                                                                     
  int baud_index;                                                     
                                                                      
  switch (termios_baud) {                                             
40005dec:	02 bf ff de 	be  40005d64 <rtems_termios_baud_to_index+0x74>
40005df0:	82 10 20 01 	mov  1, %g1                                    
40005df4:	80 a2 20 01 	cmp  %o0, 1                                    
40005df8:	0a bf ff db 	bcs  40005d64 <rtems_termios_baud_to_index+0x74>
40005dfc:	82 10 20 00 	clr  %g1                                       
40005e00:	80 a2 20 02 	cmp  %o0, 2                                    
40005e04:	02 bf ff d8 	be  40005d64 <rtems_termios_baud_to_index+0x74>
40005e08:	82 10 20 02 	mov  2, %g1                                    
40005e0c:	80 a2 20 03 	cmp  %o0, 3                                    
40005e10:	02 bf ff d5 	be  40005d64 <rtems_termios_baud_to_index+0x74><== ALWAYS TAKEN
40005e14:	82 10 20 03 	mov  3, %g1                                    
    case B38400:    baud_index = 15;  break;                          
    case B57600:    baud_index = 16;  break;                          
    case B115200:   baud_index = 17;  break;                          
    case B230400:   baud_index = 18;  break;                          
    case B460800:   baud_index = 19;  break;                          
    default:        baud_index = -1;  break;                          
40005e18:	10 bf ff d3 	b  40005d64 <rtems_termios_baud_to_index+0x74> <== NOT EXECUTED
40005e1c:	82 10 3f ff 	mov  -1, %g1                                   <== NOT EXECUTED
  rtems_termios_baud_t termios_baud                                   
)                                                                     
{                                                                     
  int baud_index;                                                     
                                                                      
  switch (termios_baud) {                                             
40005e20:	02 bf ff d1 	be  40005d64 <rtems_termios_baud_to_index+0x74>
40005e24:	82 10 20 0f 	mov  0xf, %g1                                  
40005e28:	84 10 a0 01 	or  %g2, 1, %g2                                
40005e2c:	80 a2 00 02 	cmp  %o0, %g2                                  
40005e30:	12 bf ff cc 	bne  40005d60 <rtems_termios_baud_to_index+0x70><== NEVER TAKEN
40005e34:	82 10 20 10 	mov  0x10, %g1                                 
40005e38:	30 bf ff cb 	b,a   40005d64 <rtems_termios_baud_to_index+0x74>
                                                                      

40005074 <rtems_termios_close>: rtems_interrupt_enable (level); } rtems_status_code rtems_termios_close (void *arg) {
40005074:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_libio_open_close_args_t *args = arg;                          
  struct rtems_termios_tty *tty = args->iop->data1;                   
  rtems_status_code sc;                                               
                                                                      
  sc = rtems_semaphore_obtain(                                        
40005078:	39 10 00 7b 	sethi  %hi(0x4001ec00), %i4                    
                                                                      
rtems_status_code                                                     
rtems_termios_close (void *arg)                                       
{                                                                     
  rtems_libio_open_close_args_t *args = arg;                          
  struct rtems_termios_tty *tty = args->iop->data1;                   
4000507c:	c2 06 00 00 	ld  [ %i0 ], %g1                               
  rtems_status_code sc;                                               
                                                                      
  sc = rtems_semaphore_obtain(                                        
40005080:	d0 07 21 70 	ld  [ %i4 + 0x170 ], %o0                       
                                                                      
rtems_status_code                                                     
rtems_termios_close (void *arg)                                       
{                                                                     
  rtems_libio_open_close_args_t *args = arg;                          
  struct rtems_termios_tty *tty = args->iop->data1;                   
40005084:	fa 00 60 30 	ld  [ %g1 + 0x30 ], %i5                        
  rtems_status_code sc;                                               
                                                                      
  sc = rtems_semaphore_obtain(                                        
40005088:	92 10 20 00 	clr  %o1                                       
4000508c:	40 00 08 c0 	call  4000738c <rtems_semaphore_obtain>        
40005090:	94 10 20 00 	clr  %o2                                       
    rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);            
  if (sc != RTEMS_SUCCESSFUL)                                         
40005094:	80 a2 20 00 	cmp  %o0, 0                                    
40005098:	12 80 00 6e 	bne  40005250 <rtems_termios_close+0x1dc>      <== NEVER TAKEN
4000509c:	01 00 00 00 	nop                                            
    rtems_fatal_error_occurred (sc);                                  
  if (--tty->refcount == 0) {                                         
400050a0:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
400050a4:	82 00 7f ff 	add  %g1, -1, %g1                              
400050a8:	80 a0 60 00 	cmp  %g1, 0                                    
400050ac:	12 80 00 39 	bne  40005190 <rtems_termios_close+0x11c>      
400050b0:	c2 27 60 08 	st  %g1, [ %i5 + 8 ]                           
    if (rtems_termios_linesw[tty->t_line].l_close != NULL) {          
400050b4:	c4 07 60 cc 	ld  [ %i5 + 0xcc ], %g2                        
400050b8:	03 10 00 7a 	sethi  %hi(0x4001e800), %g1                    
400050bc:	85 28 a0 05 	sll  %g2, 5, %g2                               
400050c0:	82 10 62 ac 	or  %g1, 0x2ac, %g1                            
400050c4:	82 00 40 02 	add  %g1, %g2, %g1                             
400050c8:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
400050cc:	80 a0 60 00 	cmp  %g1, 0                                    
400050d0:	22 80 00 42 	be,a   400051d8 <rtems_termios_close+0x164>    
400050d4:	d0 07 60 18 	ld  [ %i5 + 0x18 ], %o0                        
      /*                                                              
       * call discipline-specific close                               
       */                                                             
      sc = rtems_termios_linesw[tty->t_line].l_close(tty);            
400050d8:	9f c0 40 00 	call  %g1                                      
400050dc:	90 10 00 1d 	mov  %i5, %o0                                  
      }                                                               
      drainOutput (tty);                                              
      rtems_semaphore_release (tty->osem);                            
    }                                                                 
                                                                      
    if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {    
400050e0:	c2 07 60 b4 	ld  [ %i5 + 0xb4 ], %g1                        
400050e4:	80 a0 60 02 	cmp  %g1, 2                                    
400050e8:	22 80 00 4f 	be,a   40005224 <rtems_termios_close+0x1b0>    <== NEVER TAKEN
400050ec:	d0 07 60 c4 	ld  [ %i5 + 0xc4 ], %o0                        <== NOT EXECUTED
        rtems_fatal_error_occurred (sc);                              
      sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
      if (sc != RTEMS_SUCCESSFUL)                                     
        rtems_fatal_error_occurred (sc);                              
    }                                                                 
    if (tty->device.lastClose)                                        
400050f0:	c2 07 60 9c 	ld  [ %i5 + 0x9c ], %g1                        
400050f4:	80 a0 60 00 	cmp  %g1, 0                                    
400050f8:	22 80 00 07 	be,a   40005114 <rtems_termios_close+0xa0>     <== ALWAYS TAKEN
400050fc:	c2 07 40 00 	ld  [ %i5 ], %g1                               
       (*tty->device.lastClose)(tty->major, tty->minor, arg);         
40005100:	d0 07 60 0c 	ld  [ %i5 + 0xc ], %o0                         <== NOT EXECUTED
40005104:	d2 07 60 10 	ld  [ %i5 + 0x10 ], %o1                        <== NOT EXECUTED
40005108:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
4000510c:	94 10 00 18 	mov  %i0, %o2                                  <== NOT EXECUTED
    if (tty->forw == NULL) {                                          
40005110:	c2 07 40 00 	ld  [ %i5 ], %g1                               <== NOT EXECUTED
40005114:	80 a0 60 00 	cmp  %g1, 0                                    
40005118:	02 80 00 29 	be  400051bc <rtems_termios_close+0x148>       
4000511c:	c4 07 60 04 	ld  [ %i5 + 4 ], %g2                           
      rtems_termios_ttyTail = tty->back;                              
      if ( rtems_termios_ttyTail != NULL ) {                          
        rtems_termios_ttyTail->forw = NULL;                           
      }                                                               
    } else {                                                          
      tty->forw->back = tty->back;                                    
40005120:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
40005124:	c4 07 60 04 	ld  [ %i5 + 4 ], %g2                           
    }                                                                 
                                                                      
    if (tty->back == NULL) {                                          
40005128:	80 a0 a0 00 	cmp  %g2, 0                                    
4000512c:	22 80 00 21 	be,a   400051b0 <rtems_termios_close+0x13c>    <== ALWAYS TAKEN
40005130:	05 10 00 7b 	sethi  %hi(0x4001ec00), %g2                    
      rtems_termios_ttyHead = tty->forw;                              
      if ( rtems_termios_ttyHead != NULL ) {                          
        rtems_termios_ttyHead->back = NULL;                           
      }                                                               
    } else {                                                          
      tty->back->forw = tty->forw;                                    
40005134:	c2 20 80 00 	st  %g1, [ %g2 ]                               <== NOT EXECUTED
    }                                                                 
                                                                      
    rtems_semaphore_delete (tty->isem);                               
40005138:	40 00 08 5e 	call  400072b0 <rtems_semaphore_delete>        
4000513c:	d0 07 60 14 	ld  [ %i5 + 0x14 ], %o0                        
    rtems_semaphore_delete (tty->osem);                               
40005140:	40 00 08 5c 	call  400072b0 <rtems_semaphore_delete>        
40005144:	d0 07 60 18 	ld  [ %i5 + 0x18 ], %o0                        
    rtems_semaphore_delete (tty->rawOutBuf.Semaphore);                
40005148:	40 00 08 5a 	call  400072b0 <rtems_semaphore_delete>        
4000514c:	d0 07 60 8c 	ld  [ %i5 + 0x8c ], %o0                        
    if ((tty->device.pollRead == NULL) ||                             
40005150:	c2 07 60 a0 	ld  [ %i5 + 0xa0 ], %g1                        
40005154:	80 a0 60 00 	cmp  %g1, 0                                    
40005158:	02 80 00 13 	be  400051a4 <rtems_termios_close+0x130>       
4000515c:	01 00 00 00 	nop                                            
40005160:	c2 07 60 b4 	ld  [ %i5 + 0xb4 ], %g1                        
40005164:	80 a0 60 02 	cmp  %g1, 2                                    
40005168:	02 80 00 0f 	be  400051a4 <rtems_termios_close+0x130>       
4000516c:	01 00 00 00 	nop                                            
        (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))    
      rtems_semaphore_delete (tty->rawInBuf.Semaphore);               
    free (tty->rawInBuf.theBuf);                                      
40005170:	7f ff f7 ae 	call  40003028 <free>                          
40005174:	d0 07 60 58 	ld  [ %i5 + 0x58 ], %o0                        
    free (tty->rawOutBuf.theBuf);                                     
40005178:	7f ff f7 ac 	call  40003028 <free>                          
4000517c:	d0 07 60 7c 	ld  [ %i5 + 0x7c ], %o0                        
    free (tty->cbuf);                                                 
40005180:	7f ff f7 aa 	call  40003028 <free>                          
40005184:	d0 07 60 1c 	ld  [ %i5 + 0x1c ], %o0                        
    free (tty);                                                       
40005188:	7f ff f7 a8 	call  40003028 <free>                          
4000518c:	90 10 00 1d 	mov  %i5, %o0                                  
  }                                                                   
  rtems_semaphore_release (rtems_termios_ttyMutex);                   
40005190:	d0 07 21 70 	ld  [ %i4 + 0x170 ], %o0                       
40005194:	40 00 08 cd 	call  400074c8 <rtems_semaphore_release>       
40005198:	b0 10 20 00 	clr  %i0                                       
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
4000519c:	81 c7 e0 08 	ret                                            
400051a0:	81 e8 00 00 	restore                                        
    rtems_semaphore_delete (tty->isem);                               
    rtems_semaphore_delete (tty->osem);                               
    rtems_semaphore_delete (tty->rawOutBuf.Semaphore);                
    if ((tty->device.pollRead == NULL) ||                             
        (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))    
      rtems_semaphore_delete (tty->rawInBuf.Semaphore);               
400051a4:	40 00 08 43 	call  400072b0 <rtems_semaphore_delete>        
400051a8:	d0 07 60 68 	ld  [ %i5 + 0x68 ], %o0                        
400051ac:	30 bf ff f1 	b,a   40005170 <rtems_termios_close+0xfc>      
    }                                                                 
                                                                      
    if (tty->back == NULL) {                                          
      rtems_termios_ttyHead = tty->forw;                              
      if ( rtems_termios_ttyHead != NULL ) {                          
        rtems_termios_ttyHead->back = NULL;                           
400051b0:	c0 20 60 04 	clr  [ %g1 + 4 ]                               
    } else {                                                          
      tty->forw->back = tty->back;                                    
    }                                                                 
                                                                      
    if (tty->back == NULL) {                                          
      rtems_termios_ttyHead = tty->forw;                              
400051b4:	10 bf ff e1 	b  40005138 <rtems_termios_close+0xc4>         
400051b8:	c2 20 a1 78 	st  %g1, [ %g2 + 0x178 ]                       
        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;                              
400051bc:	03 10 00 7b 	sethi  %hi(0x4001ec00), %g1                    
      if ( rtems_termios_ttyTail != NULL ) {                          
400051c0:	80 a0 a0 00 	cmp  %g2, 0                                    
400051c4:	02 80 00 25 	be  40005258 <rtems_termios_close+0x1e4>       <== ALWAYS TAKEN
400051c8:	c4 20 61 74 	st  %g2, [ %g1 + 0x174 ]                       
        rtems_termios_ttyTail->forw = NULL;                           
400051cc:	c0 20 80 00 	clr  [ %g2 ]                                   <== NOT EXECUTED
400051d0:	10 bf ff d9 	b  40005134 <rtems_termios_close+0xc0>         <== NOT EXECUTED
400051d4:	c2 07 40 00 	ld  [ %i5 ], %g1                               <== NOT EXECUTED
      sc = rtems_termios_linesw[tty->t_line].l_close(tty);            
    } else {                                                          
      /*                                                              
       * default: just flush output buffer                            
       */                                                             
      sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
400051d8:	92 10 20 00 	clr  %o1                                       
400051dc:	40 00 08 6c 	call  4000738c <rtems_semaphore_obtain>        
400051e0:	94 10 20 00 	clr  %o2                                       
      if (sc != RTEMS_SUCCESSFUL) {                                   
400051e4:	80 a2 20 00 	cmp  %o0, 0                                    
400051e8:	12 80 00 1a 	bne  40005250 <rtems_termios_close+0x1dc>      <== NEVER TAKEN
400051ec:	01 00 00 00 	nop                                            
drainOutput (struct rtems_termios_tty *tty)                           
{                                                                     
  rtems_interrupt_level level;                                        
  rtems_status_code sc;                                               
                                                                      
  if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {           
400051f0:	c2 07 60 b4 	ld  [ %i5 + 0xb4 ], %g1                        
400051f4:	80 a0 60 00 	cmp  %g1, 0                                    
400051f8:	02 80 00 04 	be  40005208 <rtems_termios_close+0x194>       
400051fc:	01 00 00 00 	nop                                            
40005200:	7f ff fe 72 	call  40004bc8 <drainOutput.part.0>            
40005204:	90 10 00 1d 	mov  %i5, %o0                                  
      sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
      if (sc != RTEMS_SUCCESSFUL) {                                   
        rtems_fatal_error_occurred (sc);                              
      }                                                               
      drainOutput (tty);                                              
      rtems_semaphore_release (tty->osem);                            
40005208:	40 00 08 b0 	call  400074c8 <rtems_semaphore_release>       
4000520c:	d0 07 60 18 	ld  [ %i5 + 0x18 ], %o0                        
    }                                                                 
                                                                      
    if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {    
40005210:	c2 07 60 b4 	ld  [ %i5 + 0xb4 ], %g1                        
40005214:	80 a0 60 02 	cmp  %g1, 2                                    
40005218:	32 bf ff b7 	bne,a   400050f4 <rtems_termios_close+0x80>    
4000521c:	c2 07 60 9c 	ld  [ %i5 + 0x9c ], %g1                        
      /*                                                              
       * send "terminate" to I/O tasks                                
       */                                                             
      sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT );
40005220:	d0 07 60 c4 	ld  [ %i5 + 0xc4 ], %o0                        
40005224:	40 00 07 21 	call  40006ea8 <rtems_event_send>              
40005228:	92 10 20 01 	mov  1, %o1                                    
      if (sc != RTEMS_SUCCESSFUL)                                     
4000522c:	80 a2 20 00 	cmp  %o0, 0                                    
40005230:	12 80 00 08 	bne  40005250 <rtems_termios_close+0x1dc>      <== NEVER TAKEN
40005234:	01 00 00 00 	nop                                            
        rtems_fatal_error_occurred (sc);                              
      sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
40005238:	d0 07 60 c8 	ld  [ %i5 + 0xc8 ], %o0                        
4000523c:	40 00 07 1b 	call  40006ea8 <rtems_event_send>              
40005240:	92 10 20 01 	mov  1, %o1                                    
      if (sc != RTEMS_SUCCESSFUL)                                     
40005244:	80 a2 20 00 	cmp  %o0, 0                                    
40005248:	22 bf ff ab 	be,a   400050f4 <rtems_termios_close+0x80>     <== ALWAYS TAKEN
4000524c:	c2 07 60 9c 	ld  [ %i5 + 0x9c ], %g1                        
        rtems_fatal_error_occurred (sc);                              
40005250:	40 00 0a 34 	call  40007b20 <rtems_fatal_error_occurred>    <== NOT EXECUTED
40005254:	01 00 00 00 	nop                                            <== NOT EXECUTED
    } else {                                                          
      tty->forw->back = tty->back;                                    
    }                                                                 
                                                                      
    if (tty->back == NULL) {                                          
      rtems_termios_ttyHead = tty->forw;                              
40005258:	03 10 00 7b 	sethi  %hi(0x4001ec00), %g1                    
4000525c:	10 bf ff b7 	b  40005138 <rtems_termios_close+0xc4>         
40005260:	c0 20 61 78 	clr  [ %g1 + 0x178 ]	! 4001ed78 <rtems_termios_ttyHead>
                                                                      

4000675c <rtems_termios_dequeue_characters>: * for each transmitted character. * It returns number of characters left to transmit */ int rtems_termios_dequeue_characters (void *ttyp, int len) {
4000675c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc;                                               
                                                                      
  /*                                                                  
   * sum up character count already sent                              
   */                                                                 
  tty->t_dqlen += len;                                                
40006760:	c4 06 20 90 	ld  [ %i0 + 0x90 ], %g2                        
                                                                      
  if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {      
40006764:	c2 06 20 b4 	ld  [ %i0 + 0xb4 ], %g1                        
  rtems_status_code sc;                                               
                                                                      
  /*                                                                  
   * sum up character count already sent                              
   */                                                                 
  tty->t_dqlen += len;                                                
40006768:	b2 00 80 19 	add  %g2, %i1, %i1                             
4000676c:	f2 26 20 90 	st  %i1, [ %i0 + 0x90 ]                        
                                                                      
  if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {      
40006770:	80 a0 60 02 	cmp  %g1, 2                                    
40006774:	02 80 00 10 	be  400067b4 <rtems_termios_dequeue_characters+0x58>
40006778:	90 10 00 18 	mov  %i0, %o0                                  
    if (sc != RTEMS_SUCCESSFUL)                                       
      rtems_fatal_error_occurred (sc);                                
    return 0; /* nothing to output in IRQ... */                       
  }                                                                   
                                                                      
  if (tty->t_line == PPPDISC ) {                                      
4000677c:	c2 06 20 cc 	ld  [ %i0 + 0xcc ], %g1                        
40006780:	80 a0 60 05 	cmp  %g1, 5                                    
40006784:	02 80 00 04 	be  40006794 <rtems_termios_dequeue_characters+0x38>
40006788:	03 10 00 7a 	sethi  %hi(0x4001e800), %g1                    
      rtems_termios_linesw[tty->t_line].l_start(tty);                 
    }                                                                 
    return 0; /* nothing to output in IRQ... */                       
  }                                                                   
                                                                      
  return rtems_termios_refill_transmitter(tty);                       
4000678c:	7f ff f8 73 	call  40004958 <rtems_termios_refill_transmitter>
40006790:	81 e8 00 00 	restore                                        
                                                                      
  if (tty->t_line == PPPDISC ) {                                      
    /*                                                                
     * call any line discipline start function                        
     */                                                               
    if (rtems_termios_linesw[tty->t_line].l_start != NULL) {          
40006794:	c2 00 63 60 	ld  [ %g1 + 0x360 ], %g1                       
40006798:	80 a0 60 00 	cmp  %g1, 0                                    
4000679c:	02 80 00 04 	be  400067ac <rtems_termios_dequeue_characters+0x50><== NEVER TAKEN
400067a0:	01 00 00 00 	nop                                            
      rtems_termios_linesw[tty->t_line].l_start(tty);                 
400067a4:	9f c0 40 00 	call  %g1                                      
400067a8:	01 00 00 00 	nop                                            
    }                                                                 
    return 0; /* nothing to output in IRQ... */                       
  }                                                                   
                                                                      
  return rtems_termios_refill_transmitter(tty);                       
}                                                                     
400067ac:	81 c7 e0 08 	ret                                            
400067b0:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      
  if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {      
    /*                                                                
     * send wake up to transmitter task                               
     */                                                               
    sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);     
400067b4:	d0 06 20 c8 	ld  [ %i0 + 0xc8 ], %o0                        
400067b8:	40 00 01 bc 	call  40006ea8 <rtems_event_send>              
400067bc:	92 10 20 02 	mov  2, %o1                                    
    if (sc != RTEMS_SUCCESSFUL)                                       
400067c0:	80 a2 20 00 	cmp  %o0, 0                                    
400067c4:	02 bf ff fa 	be  400067ac <rtems_termios_dequeue_characters+0x50><== ALWAYS TAKEN
400067c8:	01 00 00 00 	nop                                            
      rtems_fatal_error_occurred (sc);                                
400067cc:	40 00 04 d5 	call  40007b20 <rtems_fatal_error_occurred>    <== NOT EXECUTED
                                                                      

400063b4 <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, const char *buf, int len) {
400063b4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  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) {             
400063b8:	c2 06 20 cc 	ld  [ %i0 + 0xcc ], %g1                        
400063bc:	37 10 00 7a 	sethi  %hi(0x4001e800), %i3                    
400063c0:	83 28 60 05 	sll  %g1, 5, %g1                               
400063c4:	b6 16 e2 ac 	or  %i3, 0x2ac, %i3                            
400063c8:	82 06 c0 01 	add  %i3, %g1, %g1                             
400063cc:	c2 00 60 10 	ld  [ %g1 + 0x10 ], %g1                        
400063d0:	80 a0 60 00 	cmp  %g1, 0                                    
400063d4:	02 80 00 23 	be  40006460 <rtems_termios_enqueue_raw_characters+0xac>
400063d8:	b8 10 00 18 	mov  %i0, %i4                                  
 * NOTE: This routine runs in the context of the                      
 *       device receive interrupt handler.                            
 * Returns the number of characters dropped because of overflow.      
 */                                                                   
int                                                                   
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
400063dc:	b0 06 bf ff 	add  %i2, -1, %i0                              
  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--) {                                                   
400063e0:	80 a6 a0 00 	cmp  %i2, 0                                    
400063e4:	12 80 00 08 	bne  40006404 <rtems_termios_enqueue_raw_characters+0x50><== ALWAYS TAKEN
400063e8:	ba 10 20 00 	clr  %i5                                       
    }                                                                 
                                                                      
    /*                                                                
     * check to see if rcv wakeup callback was set                    
     */                                                               
    if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) { 
400063ec:	10 80 00 0d 	b  40006420 <rtems_termios_enqueue_raw_characters+0x6c><== NOT EXECUTED
400063f0:	c2 07 20 e4 	ld  [ %i4 + 0xe4 ], %g1                        <== NOT EXECUTED
400063f4:	ba 07 60 01 	inc  %i5                                       
400063f8:	83 28 60 05 	sll  %g1, 5, %g1                               
400063fc:	82 06 c0 01 	add  %i3, %g1, %g1                             
40006400:	c2 00 60 10 	ld  [ %g1 + 0x10 ], %g1                        
  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);                
40006404:	d0 4e 40 1d 	ldsb  [ %i1 + %i5 ], %o0                       
40006408:	9f c0 40 00 	call  %g1                                      
4000640c:	92 10 00 1c 	mov  %i4, %o1                                  
  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--) {                                                   
40006410:	80 a7 40 18 	cmp  %i5, %i0                                  
40006414:	32 bf ff f8 	bne,a   400063f4 <rtems_termios_enqueue_raw_characters+0x40>
40006418:	c2 07 20 cc 	ld  [ %i4 + 0xcc ], %g1                        
    }                                                                 
                                                                      
    /*                                                                
     * check to see if rcv wakeup callback was set                    
     */                                                               
    if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) { 
4000641c:	c2 07 20 e4 	ld  [ %i4 + 0xe4 ], %g1                        
40006420:	80 a0 60 00 	cmp  %g1, 0                                    
40006424:	12 80 00 0d 	bne  40006458 <rtems_termios_enqueue_raw_characters+0xa4><== NEVER TAKEN
40006428:	01 00 00 00 	nop                                            
4000642c:	c2 07 20 dc 	ld  [ %i4 + 0xdc ], %g1                        
40006430:	80 a0 60 00 	cmp  %g1, 0                                    
40006434:	02 80 00 07 	be  40006450 <rtems_termios_enqueue_raw_characters+0x9c>
40006438:	b0 10 20 00 	clr  %i0                                       
      (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);     
4000643c:	d2 07 20 e0 	ld  [ %i4 + 0xe0 ], %o1                        
40006440:	9f c0 40 00 	call  %g1                                      
40006444:	90 07 20 30 	add  %i4, 0x30, %o0                            
      tty->tty_rcvwakeup = 1;                                         
40006448:	82 10 20 01 	mov  1, %g1                                    
4000644c:	c2 27 20 e4 	st  %g1, [ %i4 + 0xe4 ]                        
40006450:	81 c7 e0 08 	ret                                            
40006454:	81 e8 00 00 	restore                                        
        }                                                             
    return 0;                                                         
40006458:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000645c:	91 e8 20 00 	restore  %g0, 0, %o0                           <== NOT EXECUTED
 * NOTE: This routine runs in the context of the                      
 *       device receive interrupt handler.                            
 * Returns the number of characters dropped because of overflow.      
 */                                                                   
int                                                                   
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
40006460:	b4 06 40 1a 	add  %i1, %i2, %i2                             
40006464:	a0 10 20 00 	clr  %l0                                       
40006468:	b0 10 20 00 	clr  %i0                                       
                                                                      
        /*                                                            
         * 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); 
4000646c:	a2 07 20 30 	add  %i4, 0x30, %l1                            
              (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,                          
                (void *)&(tty->termios.c_cc[VSTOP]), 1);              
40006470:	a4 07 20 4a 	add  %i4, 0x4a, %l2                            
      tty->tty_rcvwakeup = 1;                                         
        }                                                             
    return 0;                                                         
  }                                                                   
                                                                      
  while (len--) {                                                     
40006474:	80 a6 40 1a 	cmp  %i1, %i2                                  
40006478:	22 80 00 28 	be,a   40006518 <rtems_termios_enqueue_raw_characters+0x164>
4000647c:	c2 07 20 78 	ld  [ %i4 + 0x78 ], %g1                        
    c = *buf++;                                                       
    /* FIXME: implement IXANY: any character restarts output */       
    /* if incoming XON/XOFF controls outgoing stream: */              
    if (tty->flow_ctrl & FL_MDXON) {                                  
40006480:	c2 07 20 b8 	ld  [ %i4 + 0xb8 ], %g1                        
        }                                                             
    return 0;                                                         
  }                                                                   
                                                                      
  while (len--) {                                                     
    c = *buf++;                                                       
40006484:	fa 0e 40 00 	ldub  [ %i1 ], %i5                             
    /* FIXME: implement IXANY: any character restarts output */       
    /* if incoming XON/XOFF controls outgoing stream: */              
    if (tty->flow_ctrl & FL_MDXON) {                                  
40006488:	80 88 62 00 	btst  0x200, %g1                               
4000648c:	02 80 00 0b 	be  400064b8 <rtems_termios_enqueue_raw_characters+0x104>
40006490:	b2 06 60 01 	inc  %i1                                       
      /* if received char is V_STOP and V_START (both are equal value) */
      if (c == tty->termios.c_cc[VSTOP]) {                            
40006494:	c4 0f 20 4a 	ldub  [ %i4 + 0x4a ], %g2                      
40006498:	83 2f 60 18 	sll  %i5, 0x18, %g1                            
4000649c:	83 38 60 18 	sra  %g1, 0x18, %g1                            
400064a0:	80 a0 40 02 	cmp  %g1, %g2                                  
400064a4:	02 80 00 5c 	be  40006614 <rtems_termios_enqueue_raw_characters+0x260>
400064a8:	c4 0f 20 49 	ldub  [ %i4 + 0x49 ], %g2                      
          /* stop output                             */               
          tty->flow_ctrl |= FL_ORCVXOF;                               
        }                                                             
        flow_rcv = true;                                              
      }                                                               
      else if (c == tty->termios.c_cc[VSTART]) {                      
400064ac:	80 a0 40 02 	cmp  %g1, %g2                                  
400064b0:	02 80 00 61 	be  40006634 <rtems_termios_enqueue_raw_characters+0x280><== NEVER TAKEN
400064b4:	01 00 00 00 	nop                                            
        /* restart output  */                                         
        tty->flow_ctrl &= ~FL_ORCVXOF;                                
        flow_rcv = true;                                              
      }                                                               
    }                                                                 
    if (flow_rcv) {                                                   
400064b8:	80 8c 20 ff 	btst  0xff, %l0                                
400064bc:	02 80 00 1d 	be  40006530 <rtems_termios_enqueue_raw_characters+0x17c><== ALWAYS TAKEN
400064c0:	01 00 00 00 	nop                                            
      /* restart output according to FL_ORCVXOF flag */               
      if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {   
400064c4:	c2 07 20 b8 	ld  [ %i4 + 0xb8 ], %g1                        
400064c8:	82 08 60 30 	and  %g1, 0x30, %g1                            
400064cc:	80 a0 60 20 	cmp  %g1, 0x20                                 
400064d0:	12 bf ff ea 	bne  40006478 <rtems_termios_enqueue_raw_characters+0xc4><== ALWAYS TAKEN
400064d4:	80 a6 40 1a 	cmp  %i1, %i2                                  
        /* disable interrupts    */                                   
        rtems_interrupt_disable(level);                               
400064d8:	7f ff ee f3 	call  400020a4 <sparc_disable_interrupts>      <== NOT EXECUTED
400064dc:	01 00 00 00 	nop                                            <== NOT EXECUTED
400064e0:	ba 10 00 08 	mov  %o0, %i5                                  <== NOT EXECUTED
        tty->flow_ctrl &= ~FL_OSTOP;                                  
400064e4:	c4 07 20 b8 	ld  [ %i4 + 0xb8 ], %g2                        <== NOT EXECUTED
        /* check for chars in output buffer (or rob_state?) */        
        if (tty->rawOutBufState != rob_idle) {                        
400064e8:	c2 07 20 94 	ld  [ %i4 + 0x94 ], %g1                        <== 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;                                  
400064ec:	84 08 bf df 	and  %g2, -33, %g2                             <== NOT EXECUTED
400064f0:	c4 27 20 b8 	st  %g2, [ %i4 + 0xb8 ]                        <== NOT EXECUTED
        /* check for chars in output buffer (or rob_state?) */        
        if (tty->rawOutBufState != rob_idle) {                        
400064f4:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
400064f8:	12 80 00 57 	bne  40006654 <rtems_termios_enqueue_raw_characters+0x2a0><== NOT EXECUTED
400064fc:	01 00 00 00 	nop                                            <== NOT EXECUTED
          /* if chars available, call write function... */            
          (*tty->device.write)(                                       
            tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
        }                                                             
        /* reenable interrupts */                                     
        rtems_interrupt_enable(level);                                
40006500:	7f ff ee ed 	call  400020b4 <sparc_enable_interrupts>       <== NOT EXECUTED
40006504:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
      tty->tty_rcvwakeup = 1;                                         
        }                                                             
    return 0;                                                         
  }                                                                   
                                                                      
  while (len--) {                                                     
40006508:	80 a6 40 1a 	cmp  %i1, %i2                                  <== NOT EXECUTED
4000650c:	12 bf ff dd 	bne  40006480 <rtems_termios_enqueue_raw_characters+0xcc><== NOT EXECUTED
40006510:	01 00 00 00 	nop                                            <== NOT EXECUTED
        }                                                             
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  tty->rawInBufDropped += dropped;                                    
40006514:	c2 07 20 78 	ld  [ %i4 + 0x78 ], %g1                        <== NOT EXECUTED
  rtems_semaphore_release (tty->rawInBuf.Semaphore);                  
40006518:	d0 07 20 68 	ld  [ %i4 + 0x68 ], %o0                        
        }                                                             
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  tty->rawInBufDropped += dropped;                                    
4000651c:	82 00 40 18 	add  %g1, %i0, %g1                             
  rtems_semaphore_release (tty->rawInBuf.Semaphore);                  
40006520:	40 00 03 ea 	call  400074c8 <rtems_semaphore_release>       
40006524:	c2 27 20 78 	st  %g1, [ %i4 + 0x78 ]                        
  return dropped;                                                     
40006528:	81 c7 e0 08 	ret                                            
4000652c:	81 e8 00 00 	restore                                        
        }                                                             
        /* reenable interrupts */                                     
        rtems_interrupt_enable(level);                                
      }                                                               
    } else {                                                          
      newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;        
40006530:	d0 07 20 60 	ld  [ %i4 + 0x60 ], %o0                        
40006534:	d2 07 20 64 	ld  [ %i4 + 0x64 ], %o1                        
40006538:	40 00 49 7b 	call  40018b24 <.urem>                         
4000653c:	90 02 20 01 	inc  %o0                                       
      /* if chars_in_buffer > highwater                */             
      rtems_interrupt_disable(level);                                 
40006540:	7f ff ee d9 	call  400020a4 <sparc_disable_interrupts>      
40006544:	b6 10 00 08 	mov  %o0, %i3                                  
40006548:	a6 10 00 08 	mov  %o0, %l3                                  
      if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)       
4000654c:	c2 07 20 5c 	ld  [ %i4 + 0x5c ], %g1                        
40006550:	d0 07 20 64 	ld  [ %i4 + 0x64 ], %o0                        
            % tty->rawInBuf.Size) > tty->highwater) &&                
40006554:	d2 07 20 64 	ld  [ %i4 + 0x64 ], %o1                        
      }                                                               
    } 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)       
40006558:	90 22 00 01 	sub  %o0, %g1, %o0                             
            % tty->rawInBuf.Size) > tty->highwater) &&                
4000655c:	40 00 49 72 	call  40018b24 <.urem>                         
40006560:	90 02 00 1b 	add  %o0, %i3, %o0                             
      }                                                               
    } 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)       
40006564:	c2 07 20 c0 	ld  [ %i4 + 0xc0 ], %g1                        
40006568:	80 a2 00 01 	cmp  %o0, %g1                                  
4000656c:	08 80 00 13 	bleu  400065b8 <rtems_termios_enqueue_raw_characters+0x204><== ALWAYS TAKEN
40006570:	01 00 00 00 	nop                                            
            % tty->rawInBuf.Size) > tty->highwater) &&                
          !(tty->flow_ctrl & FL_IREQXOF)) {                           
40006574:	c2 07 20 b8 	ld  [ %i4 + 0xb8 ], %g1                        <== NOT EXECUTED
    } else {                                                          
      newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;        
      /* if chars_in_buffer > highwater                */             
      rtems_interrupt_disable(level);                                 
      if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)       
            % tty->rawInBuf.Size) > tty->highwater) &&                
40006578:	80 88 60 01 	btst  1, %g1                                   <== NOT EXECUTED
4000657c:	12 80 00 0f 	bne  400065b8 <rtems_termios_enqueue_raw_characters+0x204><== NOT EXECUTED
40006580:	01 00 00 00 	nop                                            <== NOT EXECUTED
          !(tty->flow_ctrl & FL_IREQXOF)) {                           
        /* incoming data stream should be stopped */                  
        tty->flow_ctrl |= FL_IREQXOF;                                 
40006584:	c2 07 20 b8 	ld  [ %i4 + 0xb8 ], %g1                        <== NOT EXECUTED
40006588:	82 10 60 01 	or  %g1, 1, %g1                                <== NOT EXECUTED
4000658c:	c2 27 20 b8 	st  %g1, [ %i4 + 0xb8 ]                        <== NOT EXECUTED
        if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))                
40006590:	c2 07 20 b8 	ld  [ %i4 + 0xb8 ], %g1                        <== NOT EXECUTED
40006594:	82 08 64 02 	and  %g1, 0x402, %g1                           <== NOT EXECUTED
40006598:	80 a0 64 00 	cmp  %g1, 0x400                                <== NOT EXECUTED
            ==                (FL_MDXOF             ) ) {             
          if ((tty->flow_ctrl & FL_OSTOP) ||                          
4000659c:	c2 07 20 b8 	ld  [ %i4 + 0xb8 ], %g1                        <== NOT EXECUTED
      if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)       
            % tty->rawInBuf.Size) > tty->highwater) &&                
          !(tty->flow_ctrl & FL_IREQXOF)) {                           
        /* incoming data stream should be stopped */                  
        tty->flow_ctrl |= FL_IREQXOF;                                 
        if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))                
400065a0:	02 80 00 35 	be  40006674 <rtems_termios_enqueue_raw_characters+0x2c0><== NOT EXECUTED
400065a4:	80 88 60 20 	btst  0x20, %g1                                <== NOT EXECUTED
            /*    call write function here                 */         
            tty->flow_ctrl |= FL_ISNTXOF;                             
            (*tty->device.write)(tty->minor,                          
                (void *)&(tty->termios.c_cc[VSTOP]), 1);              
          }                                                           
        } else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
400065a8:	82 08 61 04 	and  %g1, 0x104, %g1                           <== NOT EXECUTED
400065ac:	80 a0 61 00 	cmp  %g1, 0x100                                <== NOT EXECUTED
400065b0:	02 80 00 40 	be  400066b0 <rtems_termios_enqueue_raw_characters+0x2fc><== NOT EXECUTED
400065b4:	01 00 00 00 	nop                                            <== NOT EXECUTED
          }                                                           
        }                                                             
      }                                                               
                                                                      
      /* reenable interrupts */                                       
      rtems_interrupt_enable(level);                                  
400065b8:	7f ff ee bf 	call  400020b4 <sparc_enable_interrupts>       
400065bc:	90 10 00 13 	mov  %l3, %o0                                  
                                                                      
      if (newTail == tty->rawInBuf.Head) {                            
400065c0:	c2 07 20 5c 	ld  [ %i4 + 0x5c ], %g1                        
400065c4:	80 a0 40 1b 	cmp  %g1, %i3                                  
400065c8:	22 bf ff ab 	be,a   40006474 <rtems_termios_enqueue_raw_characters+0xc0><== NEVER TAKEN
400065cc:	b0 06 20 01 	inc  %i0                                       <== NOT EXECUTED
        dropped++;                                                    
      } else {                                                        
        tty->rawInBuf.theBuf[newTail] = c;                            
400065d0:	c2 07 20 58 	ld  [ %i4 + 0x58 ], %g1                        
400065d4:	fa 28 40 1b 	stb  %i5, [ %g1 + %i3 ]                        
        tty->rawInBuf.Tail = newTail;                                 
                                                                      
        /*                                                            
         * check to see if rcv wakeup callback was set                
         */                                                           
        if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
400065d8:	c2 07 20 e4 	ld  [ %i4 + 0xe4 ], %g1                        
                                                                      
      if (newTail == tty->rawInBuf.Head) {                            
        dropped++;                                                    
      } else {                                                        
        tty->rawInBuf.theBuf[newTail] = c;                            
        tty->rawInBuf.Tail = newTail;                                 
400065dc:	f6 27 20 60 	st  %i3, [ %i4 + 0x60 ]                        
                                                                      
        /*                                                            
         * check to see if rcv wakeup callback was set                
         */                                                           
        if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
400065e0:	80 a0 60 00 	cmp  %g1, 0                                    
400065e4:	12 bf ff a5 	bne  40006478 <rtems_termios_enqueue_raw_characters+0xc4><== NEVER TAKEN
400065e8:	80 a6 40 1a 	cmp  %i1, %i2                                  
400065ec:	c2 07 20 dc 	ld  [ %i4 + 0xdc ], %g1                        
400065f0:	80 a0 60 00 	cmp  %g1, 0                                    
400065f4:	02 bf ff a1 	be  40006478 <rtems_termios_enqueue_raw_characters+0xc4><== ALWAYS TAKEN
400065f8:	80 a6 40 1a 	cmp  %i1, %i2                                  
          (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); 
400065fc:	d2 07 20 e0 	ld  [ %i4 + 0xe0 ], %o1                        <== NOT EXECUTED
40006600:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
40006604:	90 10 00 11 	mov  %l1, %o0                                  <== NOT EXECUTED
          tty->tty_rcvwakeup = 1;                                     
40006608:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
4000660c:	10 bf ff 9a 	b  40006474 <rtems_termios_enqueue_raw_characters+0xc0><== NOT EXECUTED
40006610:	c2 27 20 e4 	st  %g1, [ %i4 + 0xe4 ]                        <== NOT EXECUTED
    /* FIXME: implement IXANY: any character restarts output */       
    /* if incoming XON/XOFF controls outgoing stream: */              
    if (tty->flow_ctrl & FL_MDXON) {                                  
      /* if received char is V_STOP and V_START (both are equal value) */
      if (c == tty->termios.c_cc[VSTOP]) {                            
        if (c == tty->termios.c_cc[VSTART]) {                         
40006614:	80 a0 40 02 	cmp  %g1, %g2                                  
          /* received VSTOP and VSTART==VSTOP? */                     
          /* then toggle "stop output" status  */                     
          tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;               
40006618:	c2 07 20 b8 	ld  [ %i4 + 0xb8 ], %g1                        
    /* FIXME: implement IXANY: any character restarts output */       
    /* if incoming XON/XOFF controls outgoing stream: */              
    if (tty->flow_ctrl & FL_MDXON) {                                  
      /* if received char is V_STOP and V_START (both are equal value) */
      if (c == tty->termios.c_cc[VSTOP]) {                            
        if (c == tty->termios.c_cc[VSTART]) {                         
4000661c:	22 80 00 0b 	be,a   40006648 <rtems_termios_enqueue_raw_characters+0x294><== NEVER TAKEN
40006620:	82 18 60 10 	xor  %g1, 0x10, %g1                            <== NOT EXECUTED
          tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;               
        }                                                             
        else {                                                        
          /* VSTOP received (other code than VSTART) */               
          /* stop output                             */               
          tty->flow_ctrl |= FL_ORCVXOF;                               
40006624:	82 10 60 10 	or  %g1, 0x10, %g1                             
 * NOTE: This routine runs in the context of the                      
 *       device receive interrupt handler.                            
 * Returns the number of characters dropped because of overflow.      
 */                                                                   
int                                                                   
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
40006628:	a0 10 20 01 	mov  1, %l0                                    
          tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;               
        }                                                             
        else {                                                        
          /* VSTOP received (other code than VSTART) */               
          /* stop output                             */               
          tty->flow_ctrl |= FL_ORCVXOF;                               
4000662c:	c2 27 20 b8 	st  %g1, [ %i4 + 0xb8 ]                        
40006630:	30 bf ff a5 	b,a   400064c4 <rtems_termios_enqueue_raw_characters+0x110>
        flow_rcv = true;                                              
      }                                                               
      else if (c == tty->termios.c_cc[VSTART]) {                      
        /* VSTART received */                                         
        /* restart output  */                                         
        tty->flow_ctrl &= ~FL_ORCVXOF;                                
40006634:	c2 07 20 b8 	ld  [ %i4 + 0xb8 ], %g1                        <== NOT EXECUTED
 * NOTE: This routine runs in the context of the                      
 *       device receive interrupt handler.                            
 * Returns the number of characters dropped because of overflow.      
 */                                                                   
int                                                                   
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
40006638:	a0 10 20 01 	mov  1, %l0                                    <== NOT EXECUTED
        flow_rcv = true;                                              
      }                                                               
      else if (c == tty->termios.c_cc[VSTART]) {                      
        /* VSTART received */                                         
        /* restart output  */                                         
        tty->flow_ctrl &= ~FL_ORCVXOF;                                
4000663c:	82 08 7f ef 	and  %g1, -17, %g1                             <== NOT EXECUTED
40006640:	c2 27 20 b8 	st  %g1, [ %i4 + 0xb8 ]                        <== NOT EXECUTED
40006644:	30 bf ff a0 	b,a   400064c4 <rtems_termios_enqueue_raw_characters+0x110><== NOT EXECUTED
 * NOTE: This routine runs in the context of the                      
 *       device receive interrupt handler.                            
 * Returns the number of characters dropped because of overflow.      
 */                                                                   
int                                                                   
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
40006648:	a0 10 20 01 	mov  1, %l0                                    <== 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;               
4000664c:	c2 27 20 b8 	st  %g1, [ %i4 + 0xb8 ]                        <== NOT EXECUTED
40006650:	30 bf ff 9d 	b,a   400064c4 <rtems_termios_enqueue_raw_characters+0x110><== NOT EXECUTED
        tty->flow_ctrl &= ~FL_OSTOP;                                  
        /* check for chars in output buffer (or rob_state?) */        
        if (tty->rawOutBufState != rob_idle) {                        
          /* if chars available, call write function... */            
          (*tty->device.write)(                                       
            tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
40006654:	c4 07 20 84 	ld  [ %i4 + 0x84 ], %g2                        <== 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)(                                       
40006658:	d2 07 20 7c 	ld  [ %i4 + 0x7c ], %o1                        <== NOT EXECUTED
4000665c:	c2 07 20 a4 	ld  [ %i4 + 0xa4 ], %g1                        <== NOT EXECUTED
40006660:	d0 07 20 10 	ld  [ %i4 + 0x10 ], %o0                        <== NOT EXECUTED
40006664:	92 02 40 02 	add  %o1, %g2, %o1                             <== NOT EXECUTED
40006668:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
4000666c:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
40006670:	30 bf ff a4 	b,a   40006500 <rtems_termios_enqueue_raw_characters+0x14c><== NOT EXECUTED
          !(tty->flow_ctrl & FL_IREQXOF)) {                           
        /* incoming data stream should be stopped */                  
        tty->flow_ctrl |= FL_IREQXOF;                                 
        if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))                
            ==                (FL_MDXOF             ) ) {             
          if ((tty->flow_ctrl & FL_OSTOP) ||                          
40006674:	12 80 00 06 	bne  4000668c <rtems_termios_enqueue_raw_characters+0x2d8><== NOT EXECUTED
40006678:	01 00 00 00 	nop                                            <== NOT EXECUTED
4000667c:	c2 07 20 94 	ld  [ %i4 + 0x94 ], %g1                        <== NOT EXECUTED
40006680:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40006684:	12 bf ff cd 	bne  400065b8 <rtems_termios_enqueue_raw_characters+0x204><== NOT EXECUTED
40006688:	01 00 00 00 	nop                                            <== NOT EXECUTED
              (tty->rawOutBufState == rob_idle)) {                    
            /* if tx is stopped due to XOFF or out of data */         
            /*    call write function here                 */         
            tty->flow_ctrl |= FL_ISNTXOF;                             
4000668c:	c4 07 20 b8 	ld  [ %i4 + 0xb8 ], %g2                        <== NOT EXECUTED
            (*tty->device.write)(tty->minor,                          
40006690:	c2 07 20 a4 	ld  [ %i4 + 0xa4 ], %g1                        <== NOT EXECUTED
40006694:	d0 07 20 10 	ld  [ %i4 + 0x10 ], %o0                        <== NOT EXECUTED
            ==                (FL_MDXOF             ) ) {             
          if ((tty->flow_ctrl & FL_OSTOP) ||                          
              (tty->rawOutBufState == rob_idle)) {                    
            /* if tx is stopped due to XOFF or out of data */         
            /*    call write function here                 */         
            tty->flow_ctrl |= FL_ISNTXOF;                             
40006698:	84 10 a0 02 	or  %g2, 2, %g2                                <== NOT EXECUTED
            (*tty->device.write)(tty->minor,                          
4000669c:	92 10 00 12 	mov  %l2, %o1                                  <== NOT EXECUTED
            ==                (FL_MDXOF             ) ) {             
          if ((tty->flow_ctrl & FL_OSTOP) ||                          
              (tty->rawOutBufState == rob_idle)) {                    
            /* if tx is stopped due to XOFF or out of data */         
            /*    call write function here                 */         
            tty->flow_ctrl |= FL_ISNTXOF;                             
400066a0:	c4 27 20 b8 	st  %g2, [ %i4 + 0xb8 ]                        <== NOT EXECUTED
            (*tty->device.write)(tty->minor,                          
400066a4:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
400066a8:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
400066ac:	30 bf ff c3 	b,a   400065b8 <rtems_termios_enqueue_raw_characters+0x204><== NOT EXECUTED
                (void *)&(tty->termios.c_cc[VSTOP]), 1);              
          }                                                           
        } else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
          tty->flow_ctrl |= FL_IRTSOFF;                               
400066b0:	c4 07 20 b8 	ld  [ %i4 + 0xb8 ], %g2                        <== NOT EXECUTED
          /* deactivate RTS line */                                   
          if (tty->device.stopRemoteTx != NULL) {                     
400066b4:	c2 07 20 ac 	ld  [ %i4 + 0xac ], %g1                        <== NOT EXECUTED
            tty->flow_ctrl |= FL_ISNTXOF;                             
            (*tty->device.write)(tty->minor,                          
                (void *)&(tty->termios.c_cc[VSTOP]), 1);              
          }                                                           
        } else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
          tty->flow_ctrl |= FL_IRTSOFF;                               
400066b8:	84 10 a0 04 	or  %g2, 4, %g2                                <== NOT EXECUTED
400066bc:	c4 27 20 b8 	st  %g2, [ %i4 + 0xb8 ]                        <== NOT EXECUTED
          /* deactivate RTS line */                                   
          if (tty->device.stopRemoteTx != NULL) {                     
400066c0:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
400066c4:	02 bf ff bd 	be  400065b8 <rtems_termios_enqueue_raw_characters+0x204><== NOT EXECUTED
400066c8:	01 00 00 00 	nop                                            <== NOT EXECUTED
            tty->device.stopRemoteTx(tty->minor);                     
400066cc:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
400066d0:	d0 07 20 10 	ld  [ %i4 + 0x10 ], %o0                        <== NOT EXECUTED
400066d4:	30 bf ff b9 	b,a   400065b8 <rtems_termios_enqueue_raw_characters+0x204><== NOT EXECUTED
                                                                      

40005284 <rtems_termios_ioctl>: } } rtems_status_code rtems_termios_ioctl (void *arg) {
40005284:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_libio_ioctl_args_t *args = arg;                               
  struct rtems_termios_tty *tty = args->iop->data1;                   
40005288:	c2 06 00 00 	ld  [ %i0 ], %g1                               
  struct ttywakeup         *wakeup = (struct ttywakeup *)args->buffer;
4000528c:	f6 06 20 08 	ld  [ %i0 + 8 ], %i3                           
                                                                      
rtems_status_code                                                     
rtems_termios_ioctl (void *arg)                                       
{                                                                     
  rtems_libio_ioctl_args_t *args = arg;                               
  struct rtems_termios_tty *tty = args->iop->data1;                   
40005290:	fa 00 60 30 	ld  [ %g1 + 0x30 ], %i5                        
  }                                                                   
}                                                                     
                                                                      
rtems_status_code                                                     
rtems_termios_ioctl (void *arg)                                       
{                                                                     
40005294:	b8 10 00 18 	mov  %i0, %i4                                  
  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);
40005298:	d0 07 60 18 	ld  [ %i5 + 0x18 ], %o0                        
4000529c:	92 10 20 00 	clr  %o1                                       
  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;                                             
400052a0:	c0 26 20 0c 	clr  [ %i0 + 0xc ]                             
  sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
400052a4:	40 00 08 3a 	call  4000738c <rtems_semaphore_obtain>        
400052a8:	94 10 20 00 	clr  %o2                                       
  if (sc != RTEMS_SUCCESSFUL) {                                       
400052ac:	b0 92 20 00 	orcc  %o0, 0, %i0                              
400052b0:	12 80 00 23 	bne  4000533c <rtems_termios_ioctl+0xb8>       <== NEVER TAKEN
400052b4:	01 00 00 00 	nop                                            
    return sc;                                                        
  }                                                                   
  switch (args->command) {                                            
400052b8:	c2 07 20 04 	ld  [ %i4 + 4 ], %g1                           
400052bc:	80 a0 60 05 	cmp  %g1, 5                                    
400052c0:	22 80 00 1a 	be,a   40005328 <rtems_termios_ioctl+0xa4>     
400052c4:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
400052c8:	18 80 00 1f 	bgu  40005344 <rtems_termios_ioctl+0xc0>       
400052cc:	05 10 01 19 	sethi  %hi(0x40046400), %g2                    
400052d0:	80 a0 60 02 	cmp  %g1, 2                                    
400052d4:	22 80 00 2f 	be,a   40005390 <rtems_termios_ioctl+0x10c>    
400052d8:	d2 07 20 08 	ld  [ %i4 + 8 ], %o1                           
400052dc:	18 80 00 bf 	bgu  400055d8 <rtems_termios_ioctl+0x354>      
400052e0:	80 a0 60 03 	cmp  %g1, 3                                    
400052e4:	80 a0 60 01 	cmp  %g1, 1                                    
400052e8:	22 80 00 d0 	be,a   40005628 <rtems_termios_ioctl+0x3a4>    <== ALWAYS TAKEN
400052ec:	d0 07 20 08 	ld  [ %i4 + 8 ], %o0                           
  default:                                                            
    if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {          
400052f0:	c4 07 60 cc 	ld  [ %i5 + 0xcc ], %g2                        <== NOT EXECUTED
400052f4:	03 10 00 7a 	sethi  %hi(0x4001e800), %g1                    
400052f8:	85 28 a0 05 	sll  %g2, 5, %g2                               
400052fc:	82 10 62 ac 	or  %g1, 0x2ac, %g1                            
40005300:	82 00 40 02 	add  %g1, %g2, %g1                             
40005304:	c2 00 60 18 	ld  [ %g1 + 0x18 ], %g1                        
40005308:	80 a0 60 00 	cmp  %g1, 0                                    
4000530c:	02 80 00 0a 	be  40005334 <rtems_termios_ioctl+0xb0>        
40005310:	b0 10 20 0a 	mov  0xa, %i0                                  
      sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);       
40005314:	90 10 00 1d 	mov  %i5, %o0                                  
40005318:	9f c0 40 00 	call  %g1                                      
4000531c:	92 10 00 1c 	mov  %i4, %o1                                  
40005320:	10 80 00 05 	b  40005334 <rtems_termios_ioctl+0xb0>         
40005324:	b0 10 00 08 	mov  %o0, %i0                                  
        break;                                                        
    }                                                                 
    break;                                                            
                                                                      
  case RTEMS_IO_SNDWAKEUP:                                            
    tty->tty_snd = *wakeup;                                           
40005328:	c2 27 60 d4 	st  %g1, [ %i5 + 0xd4 ]                        
4000532c:	c2 06 e0 04 	ld  [ %i3 + 4 ], %g1                           
40005330:	c2 27 60 d8 	st  %g1, [ %i5 + 0xd8 ]                        
      *(int *)args->buffer = tty->ccount - tty->cindex + rawnc;       
    }                                                                 
    break;                                                            
  }                                                                   
                                                                      
  rtems_semaphore_release (tty->osem);                                
40005334:	40 00 08 65 	call  400074c8 <rtems_semaphore_release>       
40005338:	d0 07 60 18 	ld  [ %i5 + 0x18 ], %o0                        
  return sc;                                                          
}                                                                     
4000533c:	81 c7 e0 08 	ret                                            
40005340:	81 e8 00 00 	restore                                        
  args->ioctl_return = 0;                                             
  sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
  if (sc != RTEMS_SUCCESSFUL) {                                       
    return sc;                                                        
  }                                                                   
  switch (args->command) {                                            
40005344:	84 10 a2 7f 	or  %g2, 0x27f, %g2                            
40005348:	80 a0 40 02 	cmp  %g1, %g2                                  
4000534c:	02 80 00 77 	be  40005528 <rtems_termios_ioctl+0x2a4>       <== NEVER TAKEN
40005350:	01 00 00 00 	nop                                            
40005354:	38 80 00 81 	bgu,a   40005558 <rtems_termios_ioctl+0x2d4>   
40005358:	05 10 01 1d 	sethi  %hi(0x40047400), %g2                    
4000535c:	80 a0 60 06 	cmp  %g1, 6                                    
40005360:	32 bf ff e5 	bne,a   400052f4 <rtems_termios_ioctl+0x70>    
40005364:	c4 07 60 cc 	ld  [ %i5 + 0xcc ], %g2                        
  case RTEMS_IO_TCDRAIN:                                              
    drainOutput (tty);                                                
    break;                                                            
                                                                      
  case RTEMS_IO_TCFLUSH:                                              
    switch ((intptr_t) args->buffer) {                                
40005368:	c2 07 20 08 	ld  [ %i4 + 8 ], %g1                           
4000536c:	80 a0 60 01 	cmp  %g1, 1                                    
40005370:	02 80 00 c3 	be  4000567c <rtems_termios_ioctl+0x3f8>       
40005374:	80 a0 60 02 	cmp  %g1, 2                                    
40005378:	02 80 00 d1 	be  400056bc <rtems_termios_ioctl+0x438>       
4000537c:	80 a0 60 00 	cmp  %g1, 0                                    
40005380:	02 80 00 d6 	be  400056d8 <rtems_termios_ioctl+0x454>       
40005384:	01 00 00 00 	nop                                            
      case TCIOFLUSH:                                                 
        flushOutput (tty);                                            
        flushInput (tty);                                             
        break;                                                        
      default:                                                        
        sc = RTEMS_INVALID_NAME;                                      
40005388:	10 bf ff eb 	b  40005334 <rtems_termios_ioctl+0xb0>         
4000538c:	b0 10 20 03 	mov  3, %i0	! 3 <PROM_START+0x3>               
  case RTEMS_IO_GET_ATTRIBUTES:                                       
    *(struct termios *)args->buffer = tty->termios;                   
    break;                                                            
                                                                      
  case RTEMS_IO_SET_ATTRIBUTES:                                       
    tty->termios = *(struct termios *)args->buffer;                   
40005390:	94 10 20 24 	mov  0x24, %o2                                 
40005394:	b8 07 60 30 	add  %i5, 0x30, %i4                            
40005398:	40 00 2b 3b 	call  40010084 <memcpy>                        
4000539c:	90 10 00 1c 	mov  %i4, %o0                                  
  /*                                                                  
   * check for flow control options to be switched off                
   */                                                                 
                                                                      
  /* check for outgoing XON/XOFF flow control switched off */         
  if (( tty->flow_ctrl & FL_MDXON) &&                                 
400053a0:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
400053a4:	80 88 62 00 	btst  0x200, %g1                               
400053a8:	02 80 00 19 	be  4000540c <rtems_termios_ioctl+0x188>       
400053ac:	01 00 00 00 	nop                                            
      !(tty->termios.c_iflag & IXON)) {                               
400053b0:	c2 07 60 30 	ld  [ %i5 + 0x30 ], %g1                        
  /*                                                                  
   * check for flow control options to be switched off                
   */                                                                 
                                                                      
  /* check for outgoing XON/XOFF flow control switched off */         
  if (( tty->flow_ctrl & FL_MDXON) &&                                 
400053b4:	80 88 64 00 	btst  0x400, %g1                               
400053b8:	12 80 00 15 	bne  4000540c <rtems_termios_ioctl+0x188>      
400053bc:	01 00 00 00 	nop                                            
      !(tty->termios.c_iflag & IXON)) {                               
    /* clear related flags in flow_ctrl */                            
    tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);                       
400053c0:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
400053c4:	82 08 7d ef 	and  %g1, -529, %g1                            
400053c8:	c2 27 60 b8 	st  %g1, [ %i5 + 0xb8 ]                        
                                                                      
    /* has output been stopped due to received XOFF? */               
    if (tty->flow_ctrl & FL_OSTOP) {                                  
400053cc:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
400053d0:	80 88 60 20 	btst  0x20, %g1                                
400053d4:	02 80 00 0e 	be  4000540c <rtems_termios_ioctl+0x188>       <== ALWAYS TAKEN
400053d8:	01 00 00 00 	nop                                            
      /* disable interrupts    */                                     
      rtems_interrupt_disable(level);                                 
400053dc:	7f ff f3 32 	call  400020a4 <sparc_disable_interrupts>      <== NOT EXECUTED
400053e0:	01 00 00 00 	nop                                            <== NOT EXECUTED
400053e4:	b6 10 00 08 	mov  %o0, %i3                                  <== NOT EXECUTED
      tty->flow_ctrl &= ~FL_OSTOP;                                    
400053e8:	c4 07 60 b8 	ld  [ %i5 + 0xb8 ], %g2                        <== NOT EXECUTED
      /* check for chars in output buffer (or rob_state?) */          
      if (tty->rawOutBufState != rob_idle) {                          
400053ec:	c2 07 60 94 	ld  [ %i5 + 0x94 ], %g1                        <== 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;                                    
400053f0:	84 08 bf df 	and  %g2, -33, %g2                             <== NOT EXECUTED
400053f4:	c4 27 60 b8 	st  %g2, [ %i5 + 0xb8 ]                        <== NOT EXECUTED
      /* check for chars in output buffer (or rob_state?) */          
      if (tty->rawOutBufState != rob_idle) {                          
400053f8:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
400053fc:	12 80 00 c4 	bne  4000570c <rtems_termios_ioctl+0x488>      <== NOT EXECUTED
40005400:	01 00 00 00 	nop                                            <== NOT EXECUTED
        /* if chars available, call write function... */              
        (*tty->device.write)(                                         
          tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); 
      }                                                               
      /* reenable interrupts */                                       
      rtems_interrupt_enable(level);                                  
40005404:	7f ff f3 2c 	call  400020b4 <sparc_enable_interrupts>       <== NOT EXECUTED
40005408:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
    }                                                                 
  }                                                                   
  /* check for incoming XON/XOFF flow control switched off */         
  if (( tty->flow_ctrl & FL_MDXOF) && !(tty->termios.c_iflag & IXOFF)) {
4000540c:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
40005410:	80 88 64 00 	btst  0x400, %g1                               
40005414:	02 80 00 0d 	be  40005448 <rtems_termios_ioctl+0x1c4>       
40005418:	01 00 00 00 	nop                                            
4000541c:	c4 07 60 30 	ld  [ %i5 + 0x30 ], %g2                        
40005420:	03 00 00 04 	sethi  %hi(0x1000), %g1                        
40005424:	80 88 80 01 	btst  %g2, %g1                                 
40005428:	12 80 00 08 	bne  40005448 <rtems_termios_ioctl+0x1c4>      <== NEVER TAKEN
4000542c:	01 00 00 00 	nop                                            
    /* clear related flags in flow_ctrl */                            
    tty->flow_ctrl &= ~(FL_MDXOF);                                    
40005430:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
40005434:	82 08 7b ff 	and  %g1, -1025, %g1                           
40005438:	c2 27 60 b8 	st  %g1, [ %i5 + 0xb8 ]                        
    /* FIXME: what happens, if we had sent XOFF but not yet XON? */   
    tty->flow_ctrl &= ~(FL_ISNTXOF);                                  
4000543c:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
40005440:	82 08 7f fd 	and  %g1, -3, %g1                              
40005444:	c2 27 60 b8 	st  %g1, [ %i5 + 0xb8 ]                        
  }                                                                   
                                                                      
  /* check for incoming RTS/CTS flow control switched off */          
  if (( tty->flow_ctrl & FL_MDRTS) && !(tty->termios.c_cflag & CRTSCTS)) {
40005448:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
4000544c:	80 88 61 00 	btst  0x100, %g1                               
40005450:	02 80 00 16 	be  400054a8 <rtems_termios_ioctl+0x224>       <== ALWAYS TAKEN
40005454:	c2 07 60 38 	ld  [ %i5 + 0x38 ], %g1                        
40005458:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4000545c:	06 80 00 93 	bl  400056a8 <rtems_termios_ioctl+0x424>       <== NOT EXECUTED
40005460:	01 00 00 00 	nop                                            <== NOT EXECUTED
    /* clear related flags in flow_ctrl */                            
    tty->flow_ctrl &= ~(FL_MDRTS);                                    
40005464:	c4 07 60 b8 	ld  [ %i5 + 0xb8 ], %g2                        <== NOT EXECUTED
40005468:	84 08 be ff 	and  %g2, -257, %g2                            <== NOT EXECUTED
4000546c:	c4 27 60 b8 	st  %g2, [ %i5 + 0xb8 ]                        <== NOT EXECUTED
                                                                      
    /* restart remote Tx, if it was stopped */                        
    if ((tty->flow_ctrl & FL_IRTSOFF) && (tty->device.startRemoteTx != NULL)) {
40005470:	c4 07 60 b8 	ld  [ %i5 + 0xb8 ], %g2                        <== NOT EXECUTED
40005474:	80 88 a0 04 	btst  4, %g2                                   <== NOT EXECUTED
40005478:	02 80 00 09 	be  4000549c <rtems_termios_ioctl+0x218>       <== NOT EXECUTED
4000547c:	01 00 00 00 	nop                                            <== NOT EXECUTED
40005480:	c4 07 60 b0 	ld  [ %i5 + 0xb0 ], %g2                        <== NOT EXECUTED
40005484:	80 a0 a0 00 	cmp  %g2, 0                                    <== NOT EXECUTED
40005488:	02 80 00 05 	be  4000549c <rtems_termios_ioctl+0x218>       <== NOT EXECUTED
4000548c:	01 00 00 00 	nop                                            <== NOT EXECUTED
      tty->device.startRemoteTx(tty->minor);                          
40005490:	9f c0 80 00 	call  %g2                                      <== NOT EXECUTED
40005494:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        <== NOT EXECUTED
40005498:	c2 07 60 38 	ld  [ %i5 + 0x38 ], %g1                        <== NOT EXECUTED
    }                                                                 
    tty->flow_ctrl &= ~(FL_IRTSOFF);                                  
4000549c:	c4 07 60 b8 	ld  [ %i5 + 0xb8 ], %g2                        <== NOT EXECUTED
400054a0:	84 08 bf fb 	and  %g2, -5, %g2                              <== NOT EXECUTED
400054a4:	c4 27 60 b8 	st  %g2, [ %i5 + 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) {                               
400054a8:	80 a0 60 00 	cmp  %g1, 0                                    
400054ac:	06 80 00 7f 	bl  400056a8 <rtems_termios_ioctl+0x424>       <== NEVER TAKEN
400054b0:	01 00 00 00 	nop                                            
    tty->flow_ctrl |= FL_MDRTS;                                       
  }                                                                   
  /* check for incoming XON/XOF flow control switched on */           
  if (tty->termios.c_iflag & IXOFF) {                                 
400054b4:	c2 07 60 30 	ld  [ %i5 + 0x30 ], %g1                        
400054b8:	05 00 00 04 	sethi  %hi(0x1000), %g2                        
400054bc:	80 88 40 02 	btst  %g1, %g2                                 
400054c0:	02 80 00 06 	be  400054d8 <rtems_termios_ioctl+0x254>       
400054c4:	80 88 64 00 	btst  0x400, %g1                               
    tty->flow_ctrl |= FL_MDXOF;                                       
400054c8:	c4 07 60 b8 	ld  [ %i5 + 0xb8 ], %g2                        
400054cc:	84 10 a4 00 	or  %g2, 0x400, %g2                            
400054d0:	c4 27 60 b8 	st  %g2, [ %i5 + 0xb8 ]                        
  }                                                                   
  /* check for outgoing XON/XOF flow control switched on */           
  if (tty->termios.c_iflag & IXON) {                                  
400054d4:	80 88 64 00 	btst  0x400, %g1                               
400054d8:	22 80 00 06 	be,a   400054f0 <rtems_termios_ioctl+0x26c>    
400054dc:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        
    tty->flow_ctrl |= FL_MDXON;                                       
400054e0:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
400054e4:	82 10 62 00 	or  %g1, 0x200, %g1                            
400054e8:	c2 27 60 b8 	st  %g1, [ %i5 + 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) {                              
400054ec:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        
400054f0:	80 88 60 02 	btst  2, %g1                                   
400054f4:	02 80 00 51 	be  40005638 <rtems_termios_ioctl+0x3b4>       
400054f8:	01 00 00 00 	nop                                            
          tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;      
        else                                                          
          tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;       
      } else {                                                        
        if (tty->termios.c_cc[VMIN]) {                                
          tty->rawInBufSemaphoreOptions = RTEMS_WAIT;                 
400054fc:	c0 27 60 6c 	clr  [ %i5 + 0x6c ]                            
          tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;           
40005500:	c0 27 60 70 	clr  [ %i5 + 0x70 ]                            
          tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;      
40005504:	c0 27 60 74 	clr  [ %i5 + 0x74 ]                            
        } else {                                                      
          tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;              
        }                                                             
      }                                                               
    }                                                                 
    if (tty->device.setAttributes)                                    
40005508:	c2 07 60 a8 	ld  [ %i5 + 0xa8 ], %g1                        
4000550c:	80 a0 60 00 	cmp  %g1, 0                                    
40005510:	02 bf ff 89 	be  40005334 <rtems_termios_ioctl+0xb0>        
40005514:	01 00 00 00 	nop                                            
      (*tty->device.setAttributes)(tty->minor, &tty->termios);        
40005518:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        
4000551c:	9f c0 40 00 	call  %g1                                      
40005520:	92 10 00 1c 	mov  %i4, %o1                                  
40005524:	30 bf ff 84 	b,a   40005334 <rtems_termios_ioctl+0xb0>      
  case TIOCGETD:                                                      
    *(int*)(args->buffer)=tty->t_line;                                
    break;                                                            
#endif                                                                
   case FIONREAD: {                                                   
      int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;            
40005528:	c4 07 60 60 	ld  [ %i5 + 0x60 ], %g2                        <== NOT EXECUTED
4000552c:	c2 07 60 5c 	ld  [ %i5 + 0x5c ], %g1                        <== NOT EXECUTED
      if ( rawnc < 0 )                                                
40005530:	82 a0 80 01 	subcc  %g2, %g1, %g1                           <== NOT EXECUTED
40005534:	0c 80 00 5a 	bneg  4000569c <rtems_termios_ioctl+0x418>     <== NOT EXECUTED
40005538:	01 00 00 00 	nop                                            <== NOT EXECUTED
        rawnc += tty->rawInBuf.Size;                                  
      /* Half guess that this is the right operation */               
      *(int *)args->buffer = tty->ccount - tty->cindex + rawnc;       
4000553c:	c8 07 60 20 	ld  [ %i5 + 0x20 ], %g4                        <== NOT EXECUTED
40005540:	c4 07 60 24 	ld  [ %i5 + 0x24 ], %g2                        <== NOT EXECUTED
40005544:	c6 07 20 08 	ld  [ %i4 + 8 ], %g3                           <== NOT EXECUTED
40005548:	84 21 00 02 	sub  %g4, %g2, %g2                             <== NOT EXECUTED
4000554c:	82 00 80 01 	add  %g2, %g1, %g1                             <== NOT EXECUTED
    }                                                                 
    break;                                                            
40005550:	10 bf ff 79 	b  40005334 <rtems_termios_ioctl+0xb0>         <== NOT EXECUTED
40005554:	c2 20 c0 00 	st  %g1, [ %g3 ]                               <== NOT EXECUTED
  args->ioctl_return = 0;                                             
  sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
  if (sc != RTEMS_SUCCESSFUL) {                                       
    return sc;                                                        
  }                                                                   
  switch (args->command) {                                            
40005558:	84 10 a0 1a 	or  %g2, 0x1a, %g2                             
4000555c:	80 a0 40 02 	cmp  %g1, %g2                                  
40005560:	02 80 00 2e 	be  40005618 <rtems_termios_ioctl+0x394>       
40005564:	05 20 01 1d 	sethi  %hi(0x80047400), %g2                    
40005568:	84 10 a0 1b 	or  %g2, 0x1b, %g2	! 8004741b <LEON_REG+0x4741b>
4000556c:	80 a0 40 02 	cmp  %g1, %g2                                  
40005570:	32 bf ff 61 	bne,a   400052f4 <rtems_termios_ioctl+0x70>    <== NEVER TAKEN
40005574:	c4 07 60 cc 	ld  [ %i5 + 0xcc ], %g2                        <== NOT EXECUTED
#if 1 /* FIXME */                                                     
  case TIOCSETD:                                                      
    /*                                                                
     * close old line discipline                                      
     */                                                               
    if (rtems_termios_linesw[tty->t_line].l_close != NULL) {          
40005578:	c2 07 60 cc 	ld  [ %i5 + 0xcc ], %g1                        
4000557c:	37 10 00 7a 	sethi  %hi(0x4001e800), %i3                    
40005580:	83 28 60 05 	sll  %g1, 5, %g1                               
40005584:	b6 16 e2 ac 	or  %i3, 0x2ac, %i3                            
40005588:	82 06 c0 01 	add  %i3, %g1, %g1                             
4000558c:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
40005590:	80 a0 60 00 	cmp  %g1, 0                                    
40005594:	22 80 00 06 	be,a   400055ac <rtems_termios_ioctl+0x328>    
40005598:	c2 07 20 08 	ld  [ %i4 + 8 ], %g1                           
      sc = rtems_termios_linesw[tty->t_line].l_close(tty);            
4000559c:	9f c0 40 00 	call  %g1                                      
400055a0:	90 10 00 1d 	mov  %i5, %o0                                  
400055a4:	b0 10 00 08 	mov  %o0, %i0                                  
    }                                                                 
    tty->t_line=*(int*)(args->buffer);                                
400055a8:	c2 07 20 08 	ld  [ %i4 + 8 ], %g1                           
400055ac:	c2 00 40 00 	ld  [ %g1 ], %g1                               
    tty->t_sc = NULL; /* ensure that no more valid data */            
400055b0:	c0 27 60 d0 	clr  [ %i5 + 0xd0 ]                            
    /*                                                                
     * open new line discipline                                       
     */                                                               
    if (rtems_termios_linesw[tty->t_line].l_open != NULL) {           
400055b4:	85 28 60 05 	sll  %g1, 5, %g2                               
400055b8:	c4 06 c0 02 	ld  [ %i3 + %g2 ], %g2                         
400055bc:	80 a0 a0 00 	cmp  %g2, 0                                    
400055c0:	02 bf ff 5d 	be  40005334 <rtems_termios_ioctl+0xb0>        
400055c4:	c2 27 60 cc 	st  %g1, [ %i5 + 0xcc ]                        
      sc = rtems_termios_linesw[tty->t_line].l_open(tty);             
400055c8:	9f c0 80 00 	call  %g2                                      
400055cc:	90 10 00 1d 	mov  %i5, %o0                                  
400055d0:	10 bf ff 59 	b  40005334 <rtems_termios_ioctl+0xb0>         
400055d4:	b0 10 00 08 	mov  %o0, %i0                                  
  args->ioctl_return = 0;                                             
  sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
  if (sc != RTEMS_SUCCESSFUL) {                                       
    return sc;                                                        
  }                                                                   
  switch (args->command) {                                            
400055d8:	02 80 00 09 	be  400055fc <rtems_termios_ioctl+0x378>       
400055dc:	80 a0 60 04 	cmp  %g1, 4                                    
400055e0:	32 bf ff 45 	bne,a   400052f4 <rtems_termios_ioctl+0x70>    <== NEVER TAKEN
400055e4:	c4 07 60 cc 	ld  [ %i5 + 0xcc ], %g2                        <== NOT EXECUTED
  case RTEMS_IO_SNDWAKEUP:                                            
    tty->tty_snd = *wakeup;                                           
    break;                                                            
                                                                      
  case RTEMS_IO_RCVWAKEUP:                                            
    tty->tty_rcv = *wakeup;                                           
400055e8:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
400055ec:	c2 27 60 dc 	st  %g1, [ %i5 + 0xdc ]                        
400055f0:	c2 06 e0 04 	ld  [ %i3 + 4 ], %g1                           
    break;                                                            
400055f4:	10 bf ff 50 	b  40005334 <rtems_termios_ioctl+0xb0>         
400055f8:	c2 27 60 e0 	st  %g1, [ %i5 + 0xe0 ]                        
drainOutput (struct rtems_termios_tty *tty)                           
{                                                                     
  rtems_interrupt_level level;                                        
  rtems_status_code sc;                                               
                                                                      
  if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {           
400055fc:	c2 07 60 b4 	ld  [ %i5 + 0xb4 ], %g1                        
40005600:	80 a0 60 00 	cmp  %g1, 0                                    
40005604:	02 bf ff 4c 	be  40005334 <rtems_termios_ioctl+0xb0>        <== ALWAYS TAKEN
40005608:	01 00 00 00 	nop                                            
4000560c:	7f ff fd 6f 	call  40004bc8 <drainOutput.part.0>            <== NOT EXECUTED
40005610:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40005614:	30 bf ff 48 	b,a   40005334 <rtems_termios_ioctl+0xb0>      <== 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;                                
40005618:	c4 07 60 cc 	ld  [ %i5 + 0xcc ], %g2                        
4000561c:	c2 07 20 08 	ld  [ %i4 + 8 ], %g1                           
    break;                                                            
40005620:	10 bf ff 45 	b  40005334 <rtems_termios_ioctl+0xb0>         
40005624:	c4 20 40 00 	st  %g2, [ %g1 ]                               
      sc = RTEMS_INVALID_NUMBER;                                      
    }                                                                 
    break;                                                            
                                                                      
  case RTEMS_IO_GET_ATTRIBUTES:                                       
    *(struct termios *)args->buffer = tty->termios;                   
40005628:	92 07 60 30 	add  %i5, 0x30, %o1                            
4000562c:	40 00 2a 96 	call  40010084 <memcpy>                        
40005630:	94 10 20 24 	mov  0x24, %o2                                 
    break;                                                            
40005634:	30 bf ff 40 	b,a   40005334 <rtems_termios_ioctl+0xb0>      
      tty->rawInBufSemaphoreOptions = RTEMS_WAIT;                     
      tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;               
      tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;          
    } else {                                                          
      tty->vtimeTicks = tty->termios.c_cc[VTIME] *                    
                    rtems_clock_get_ticks_per_second() / 10;          
40005638:	40 00 05 8d 	call  40006c6c <rtems_clock_get_ticks_per_second>
4000563c:	f6 0f 60 46 	ldub  [ %i5 + 0x46 ], %i3                      
    if (tty->termios.c_lflag & ICANON) {                              
      tty->rawInBufSemaphoreOptions = RTEMS_WAIT;                     
      tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;               
      tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;          
    } else {                                                          
      tty->vtimeTicks = tty->termios.c_cc[VTIME] *                    
40005640:	40 00 4c 53 	call  4001878c <.umul>                         
40005644:	92 10 00 1b 	mov  %i3, %o1                                  
                    rtems_clock_get_ticks_per_second() / 10;          
40005648:	40 00 4c 8b 	call  40018874 <.udiv>                         
4000564c:	92 10 20 0a 	mov  0xa, %o1                                  
      if (tty->termios.c_cc[VTIME]) {                                 
40005650:	c2 0f 60 46 	ldub  [ %i5 + 0x46 ], %g1                      
    if (tty->termios.c_lflag & ICANON) {                              
      tty->rawInBufSemaphoreOptions = RTEMS_WAIT;                     
      tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;               
      tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;          
    } else {                                                          
      tty->vtimeTicks = tty->termios.c_cc[VTIME] *                    
40005654:	d0 27 60 54 	st  %o0, [ %i5 + 0x54 ]                        
                    rtems_clock_get_ticks_per_second() / 10;          
      if (tty->termios.c_cc[VTIME]) {                                 
40005658:	80 a0 60 00 	cmp  %g1, 0                                    
4000565c:	02 80 00 26 	be  400056f4 <rtems_termios_ioctl+0x470>       
40005660:	c2 0f 60 47 	ldub  [ %i5 + 0x47 ], %g1                      
        tty->rawInBufSemaphoreOptions = RTEMS_WAIT;                   
40005664:	c0 27 60 6c 	clr  [ %i5 + 0x6c ]                            
        tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;              
        if (tty->termios.c_cc[VMIN])                                  
40005668:	80 a0 60 00 	cmp  %g1, 0                                    
4000566c:	12 bf ff a6 	bne  40005504 <rtems_termios_ioctl+0x280>      
40005670:	d0 27 60 70 	st  %o0, [ %i5 + 0x70 ]                        
          tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;      
        else                                                          
          tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;       
40005674:	10 bf ff a5 	b  40005508 <rtems_termios_ioctl+0x284>        
40005678:	d0 27 60 74 	st  %o0, [ %i5 + 0x74 ]                        
static void                                                           
flushOutput (struct rtems_termios_tty *tty)                           
{                                                                     
  rtems_interrupt_level level;                                        
                                                                      
  rtems_interrupt_disable (level);                                    
4000567c:	7f ff f2 8a 	call  400020a4 <sparc_disable_interrupts>      
40005680:	01 00 00 00 	nop                                            
  tty->rawOutBuf.Tail = 0;                                            
40005684:	c0 27 60 84 	clr  [ %i5 + 0x84 ]                            
  tty->rawOutBuf.Head = 0;                                            
40005688:	c0 27 60 80 	clr  [ %i5 + 0x80 ]                            
  tty->rawOutBufState = rob_idle;                                     
4000568c:	c0 27 60 94 	clr  [ %i5 + 0x94 ]                            
  rtems_interrupt_enable (level);                                     
40005690:	7f ff f2 89 	call  400020b4 <sparc_enable_interrupts>       
40005694:	01 00 00 00 	nop                                            
40005698:	30 bf ff 27 	b,a   40005334 <rtems_termios_ioctl+0xb0>      
    break;                                                            
#endif                                                                
   case FIONREAD: {                                                   
      int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;            
      if ( rawnc < 0 )                                                
        rawnc += tty->rawInBuf.Size;                                  
4000569c:	c4 07 60 64 	ld  [ %i5 + 0x64 ], %g2                        <== NOT EXECUTED
400056a0:	10 bf ff a7 	b  4000553c <rtems_termios_ioctl+0x2b8>        <== NOT EXECUTED
400056a4:	82 00 40 02 	add  %g1, %g2, %g1                             <== NOT EXECUTED
  /*                                                                  
   * check for flow control options to be switched on                 
   */                                                                 
  /* check for incoming RTS/CTS flow control switched on */           
  if (tty->termios.c_cflag & CRTSCTS) {                               
    tty->flow_ctrl |= FL_MDRTS;                                       
400056a8:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        <== NOT EXECUTED
400056ac:	82 10 61 00 	or  %g1, 0x100, %g1                            <== NOT EXECUTED
400056b0:	c2 27 60 b8 	st  %g1, [ %i5 + 0xb8 ]                        <== NOT EXECUTED
  }                                                                   
  /* check for incoming XON/XOF flow control switched on */           
  if (tty->termios.c_iflag & IXOFF) {                                 
400056b4:	10 bf ff 81 	b  400054b8 <rtems_termios_ioctl+0x234>        <== NOT EXECUTED
400056b8:	c2 07 60 30 	ld  [ %i5 + 0x30 ], %g1                        <== NOT EXECUTED
static void                                                           
flushOutput (struct rtems_termios_tty *tty)                           
{                                                                     
  rtems_interrupt_level level;                                        
                                                                      
  rtems_interrupt_disable (level);                                    
400056bc:	7f ff f2 7a 	call  400020a4 <sparc_disable_interrupts>      
400056c0:	01 00 00 00 	nop                                            
  tty->rawOutBuf.Tail = 0;                                            
400056c4:	c0 27 60 84 	clr  [ %i5 + 0x84 ]                            
  tty->rawOutBuf.Head = 0;                                            
400056c8:	c0 27 60 80 	clr  [ %i5 + 0x80 ]                            
  tty->rawOutBufState = rob_idle;                                     
400056cc:	c0 27 60 94 	clr  [ %i5 + 0x94 ]                            
  rtems_interrupt_enable (level);                                     
400056d0:	7f ff f2 79 	call  400020b4 <sparc_enable_interrupts>       
400056d4:	01 00 00 00 	nop                                            
static void                                                           
flushInput (struct rtems_termios_tty *tty)                            
{                                                                     
  rtems_interrupt_level level;                                        
                                                                      
  rtems_interrupt_disable (level);                                    
400056d8:	7f ff f2 73 	call  400020a4 <sparc_disable_interrupts>      
400056dc:	01 00 00 00 	nop                                            
  tty->rawInBuf.Tail = 0;                                             
400056e0:	c0 27 60 60 	clr  [ %i5 + 0x60 ]                            
  tty->rawInBuf.Head = 0;                                             
400056e4:	c0 27 60 5c 	clr  [ %i5 + 0x5c ]                            
  rtems_interrupt_enable (level);                                     
400056e8:	7f ff f2 73 	call  400020b4 <sparc_enable_interrupts>       
400056ec:	01 00 00 00 	nop                                            
400056f0:	30 bf ff 11 	b,a   40005334 <rtems_termios_ioctl+0xb0>      
        if (tty->termios.c_cc[VMIN])                                  
          tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;      
        else                                                          
          tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;       
      } else {                                                        
        if (tty->termios.c_cc[VMIN]) {                                
400056f4:	80 a0 60 00 	cmp  %g1, 0                                    
400056f8:	32 bf ff 82 	bne,a   40005500 <rtems_termios_ioctl+0x27c>   <== NEVER TAKEN
400056fc:	c0 27 60 6c 	clr  [ %i5 + 0x6c ]                            <== NOT EXECUTED
          tty->rawInBufSemaphoreOptions = RTEMS_WAIT;                 
          tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;           
          tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;      
        } else {                                                      
          tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;              
40005700:	82 10 20 01 	mov  1, %g1                                    
40005704:	10 bf ff 81 	b  40005508 <rtems_termios_ioctl+0x284>        
40005708:	c2 27 60 6c 	st  %g1, [ %i5 + 0x6c ]                        
      tty->flow_ctrl &= ~FL_OSTOP;                                    
      /* check for chars in output buffer (or rob_state?) */          
      if (tty->rawOutBufState != rob_idle) {                          
        /* if chars available, call write function... */              
        (*tty->device.write)(                                         
          tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); 
4000570c:	c4 07 60 84 	ld  [ %i5 + 0x84 ], %g2                        <== 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)(                                         
40005710:	d2 07 60 7c 	ld  [ %i5 + 0x7c ], %o1                        <== NOT EXECUTED
40005714:	c2 07 60 a4 	ld  [ %i5 + 0xa4 ], %g1                        <== NOT EXECUTED
40005718:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        <== NOT EXECUTED
4000571c:	92 02 40 02 	add  %o1, %g2, %o1                             <== NOT EXECUTED
40005720:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
40005724:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
40005728:	30 bf ff 37 	b,a   40005404 <rtems_termios_ioctl+0x180>     <== NOT EXECUTED
                                                                      

40004c44 <rtems_termios_open>: rtems_device_major_number major, rtems_device_minor_number minor, void *arg, const rtems_termios_callbacks *callbacks ) {
40004c44:	9d e3 bf a0 	save  %sp, -96, %sp                            
  struct rtems_termios_tty *tty;                                      
                                                                      
  /*                                                                  
   * See if the device has already been opened                        
   */                                                                 
  sc = rtems_semaphore_obtain(                                        
40004c48:	23 10 00 7b 	sethi  %hi(0x4001ec00), %l1                    
40004c4c:	d0 04 61 70 	ld  [ %l1 + 0x170 ], %o0	! 4001ed70 <rtems_termios_ttyMutex>
40004c50:	92 10 20 00 	clr  %o1                                       
40004c54:	94 10 20 00 	clr  %o2                                       
40004c58:	40 00 09 cd 	call  4000738c <rtems_semaphore_obtain>        
40004c5c:	b8 10 00 18 	mov  %i0, %i4                                  
    rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);            
  if (sc != RTEMS_SUCCESSFUL)                                         
40004c60:	80 a2 20 00 	cmp  %o0, 0                                    
40004c64:	12 80 00 28 	bne  40004d04 <rtems_termios_open+0xc0>        <== NEVER TAKEN
40004c68:	a0 10 00 08 	mov  %o0, %l0                                  
    return sc;                                                        
                                                                      
  for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) { 
40004c6c:	25 10 00 7b 	sethi  %hi(0x4001ec00), %l2                    
40004c70:	f0 04 a1 78 	ld  [ %l2 + 0x178 ], %i0	! 4001ed78 <rtems_termios_ttyHead>
40004c74:	80 a6 20 00 	cmp  %i0, 0                                    
40004c78:	02 80 00 25 	be  40004d0c <rtems_termios_open+0xc8>         
40004c7c:	ba 10 00 18 	mov  %i0, %i5                                  
    if ((tty->major == major) && (tty->minor == minor))               
40004c80:	10 80 00 06 	b  40004c98 <rtems_termios_open+0x54>          
40004c84:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
  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) { 
40004c88:	80 a7 60 00 	cmp  %i5, 0                                    
40004c8c:	02 80 00 21 	be  40004d10 <rtems_termios_open+0xcc>         <== ALWAYS TAKEN
40004c90:	90 10 20 01 	mov  1, %o0                                    
    if ((tty->major == major) && (tty->minor == minor))               
40004c94:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         <== NOT EXECUTED
40004c98:	80 a0 40 1c 	cmp  %g1, %i4                                  
40004c9c:	32 bf ff fb 	bne,a   40004c88 <rtems_termios_open+0x44>     
40004ca0:	fa 07 40 00 	ld  [ %i5 ], %i5                               
40004ca4:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
40004ca8:	80 a0 40 19 	cmp  %g1, %i1                                  
40004cac:	32 bf ff f7 	bne,a   40004c88 <rtems_termios_open+0x44>     <== NEVER TAKEN
40004cb0:	fa 07 40 00 	ld  [ %i5 ], %i5                               <== NOT EXECUTED
     */                                                               
    if (c++ == 'z')                                                   
      c = 'a';                                                        
                                                                      
  }                                                                   
  args->iop->data1 = tty;                                             
40004cb4:	c4 06 80 00 	ld  [ %i2 ], %g2                               
  if (!tty->refcount++) {                                             
40004cb8:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
     */                                                               
    if (c++ == 'z')                                                   
      c = 'a';                                                        
                                                                      
  }                                                                   
  args->iop->data1 = tty;                                             
40004cbc:	fa 20 a0 30 	st  %i5, [ %g2 + 0x30 ]                        
  if (!tty->refcount++) {                                             
40004cc0:	84 00 60 01 	add  %g1, 1, %g2                               
40004cc4:	80 a0 60 00 	cmp  %g1, 0                                    
40004cc8:	12 80 00 0d 	bne  40004cfc <rtems_termios_open+0xb8>        
40004ccc:	c4 27 60 08 	st  %g2, [ %i5 + 8 ]                           
    if (tty->device.firstOpen)                                        
40004cd0:	c2 07 60 98 	ld  [ %i5 + 0x98 ], %g1                        
40004cd4:	80 a0 60 00 	cmp  %g1, 0                                    
40004cd8:	02 80 00 05 	be  40004cec <rtems_termios_open+0xa8>         <== ALWAYS TAKEN
40004cdc:	90 10 00 1c 	mov  %i4, %o0                                  
      (*tty->device.firstOpen)(major, minor, arg);                    
40004ce0:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
40004ce4:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
40004ce8:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
                                                                      
    /*                                                                
     * start I/O tasks, if needed                                     
     */                                                               
    if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {    
40004cec:	c2 07 60 b4 	ld  [ %i5 + 0xb4 ], %g1                        
40004cf0:	80 a0 60 02 	cmp  %g1, 2                                    
40004cf4:	22 80 00 9e 	be,a   40004f6c <rtems_termios_open+0x328>     
40004cf8:	d0 07 60 c4 	ld  [ %i5 + 0xc4 ], %o0                        
        tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
      if (sc != RTEMS_SUCCESSFUL)                                     
        rtems_fatal_error_occurred (sc);                              
    }                                                                 
  }                                                                   
  rtems_semaphore_release (rtems_termios_ttyMutex);                   
40004cfc:	40 00 09 f3 	call  400074c8 <rtems_semaphore_release>       
40004d00:	d0 04 61 70 	ld  [ %l1 + 0x170 ], %o0                       
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
40004d04:	81 c7 e0 08 	ret                                            
40004d08:	91 e8 00 10 	restore  %g0, %l0, %o0                         
    static char c = 'a';                                              
                                                                      
    /*                                                                
     * Create a new device                                            
     */                                                               
    tty = calloc (1, sizeof (struct rtems_termios_tty));              
40004d0c:	90 10 20 01 	mov  1, %o0                                    
40004d10:	7f ff f8 17 	call  40002d6c <calloc>                        
40004d14:	92 10 20 e8 	mov  0xe8, %o1                                 
    if (tty == NULL) {                                                
40004d18:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40004d1c:	02 80 00 a9 	be  40004fc0 <rtems_termios_open+0x37c>        
40004d20:	03 10 00 78 	sethi  %hi(0x4001e000), %g1                    
      return RTEMS_NO_MEMORY;                                         
    }                                                                 
    /*                                                                
     * allocate raw input buffer                                      
     */                                                               
    tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;                       
40004d24:	c2 00 63 dc 	ld  [ %g1 + 0x3dc ], %g1	! 4001e3dc <rtems_termios_raw_input_size>
40004d28:	c2 27 60 64 	st  %g1, [ %i5 + 0x64 ]                        
    tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);               
40004d2c:	d0 07 60 64 	ld  [ %i5 + 0x64 ], %o0                        
40004d30:	7f ff f9 98 	call  40003390 <malloc>                        
40004d34:	01 00 00 00 	nop                                            
40004d38:	d0 27 60 58 	st  %o0, [ %i5 + 0x58 ]                        
    if (tty->rawInBuf.theBuf == NULL) {                               
40004d3c:	80 a2 20 00 	cmp  %o0, 0                                    
40004d40:	02 80 00 9e 	be  40004fb8 <rtems_termios_open+0x374>        
40004d44:	a6 10 00 08 	mov  %o0, %l3                                  
      return RTEMS_NO_MEMORY;                                         
    }                                                                 
    /*                                                                
     * allocate raw output buffer                                     
     */                                                               
    tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;                     
40004d48:	03 10 00 78 	sethi  %hi(0x4001e000), %g1                    
40004d4c:	c2 00 63 e0 	ld  [ %g1 + 0x3e0 ], %g1	! 4001e3e0 <rtems_termios_raw_output_size>
40004d50:	c2 27 60 88 	st  %g1, [ %i5 + 0x88 ]                        
    tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);             
40004d54:	d0 07 60 88 	ld  [ %i5 + 0x88 ], %o0                        
40004d58:	7f ff f9 8e 	call  40003390 <malloc>                        
40004d5c:	01 00 00 00 	nop                                            
40004d60:	d0 27 60 7c 	st  %o0, [ %i5 + 0x7c ]                        
    if (tty->rawOutBuf.theBuf == NULL) {                              
40004d64:	80 a2 20 00 	cmp  %o0, 0                                    
40004d68:	02 80 00 92 	be  40004fb0 <rtems_termios_open+0x36c>        
40004d6c:	a8 10 00 08 	mov  %o0, %l4                                  
      return RTEMS_NO_MEMORY;                                         
    }                                                                 
    /*                                                                
     * allocate cooked buffer                                         
     */                                                               
    tty->cbuf  = malloc (CBUFSIZE);                                   
40004d70:	03 10 00 78 	sethi  %hi(0x4001e000), %g1                    
40004d74:	7f ff f9 87 	call  40003390 <malloc>                        
40004d78:	d0 00 63 e4 	ld  [ %g1 + 0x3e4 ], %o0	! 4001e3e4 <rtems_termios_cbufsize>
    if (tty->cbuf == NULL) {                                          
40004d7c:	80 a2 20 00 	cmp  %o0, 0                                    
40004d80:	02 80 00 8a 	be  40004fa8 <rtems_termios_open+0x364>        
40004d84:	d0 27 60 1c 	st  %o0, [ %i5 + 0x1c ]                        
      return RTEMS_NO_MEMORY;                                         
    }                                                                 
    /*                                                                
     * Initialize wakeup callbacks                                    
     */                                                               
    tty->tty_snd.sw_pfn = NULL;                                       
40004d88:	c0 27 60 d4 	clr  [ %i5 + 0xd4 ]                            
    tty->tty_snd.sw_arg = NULL;                                       
40004d8c:	c0 27 60 d8 	clr  [ %i5 + 0xd8 ]                            
    tty->tty_rcv.sw_pfn = NULL;                                       
40004d90:	c0 27 60 dc 	clr  [ %i5 + 0xdc ]                            
    tty->tty_rcv.sw_arg = NULL;                                       
40004d94:	c0 27 60 e0 	clr  [ %i5 + 0xe0 ]                            
    tty->tty_rcvwakeup  = 0;                                          
40004d98:	c0 27 60 e4 	clr  [ %i5 + 0xe4 ]                            
                                                                      
    /*                                                                
     * link tty                                                       
     */                                                               
    tty->forw = rtems_termios_ttyHead;                                
40004d9c:	f0 27 40 00 	st  %i0, [ %i5 ]                               
    tty->back = NULL;                                                 
    if (rtems_termios_ttyHead != NULL)                                
40004da0:	80 a6 20 00 	cmp  %i0, 0                                    
40004da4:	02 80 00 03 	be  40004db0 <rtems_termios_open+0x16c>        
40004da8:	c0 27 60 04 	clr  [ %i5 + 4 ]                               
      rtems_termios_ttyHead->back = tty;                              
40004dac:	fa 26 20 04 	st  %i5, [ %i0 + 4 ]                           
    rtems_termios_ttyHead = tty;                                      
    if (rtems_termios_ttyTail == NULL)                                
40004db0:	03 10 00 7b 	sethi  %hi(0x4001ec00), %g1                    
40004db4:	c4 00 61 74 	ld  [ %g1 + 0x174 ], %g2	! 4001ed74 <rtems_termios_ttyTail>
40004db8:	80 a0 a0 00 	cmp  %g2, 0                                    
40004dbc:	02 80 00 ac 	be  4000506c <rtems_termios_open+0x428>        
40004dc0:	fa 24 a1 78 	st  %i5, [ %l2 + 0x178 ]                       
                                                                      
    /*                                                                
     * Set up mutex semaphores                                        
     */                                                               
    sc = rtems_semaphore_create (                                     
      rtems_build_name ('T', 'R', 'i', c),                            
40004dc4:	31 10 00 78 	sethi  %hi(0x4001e000), %i0                    
40004dc8:	d0 4e 23 e8 	ldsb  [ %i0 + 0x3e8 ], %o0	! 4001e3e8 <c.6875> 
    tty->major = major;                                               
                                                                      
    /*                                                                
     * Set up mutex semaphores                                        
     */                                                               
    sc = rtems_semaphore_create (                                     
40004dcc:	03 15 14 9a 	sethi  %hi(0x54526800), %g1                    
40004dd0:	82 10 61 00 	or  %g1, 0x100, %g1	! 54526900 <RAM_END+0x14126900>
      rtems_termios_ttyHead->back = tty;                              
    rtems_termios_ttyHead = tty;                                      
    if (rtems_termios_ttyTail == NULL)                                
      rtems_termios_ttyTail = tty;                                    
                                                                      
    tty->minor = minor;                                               
40004dd4:	f2 27 60 10 	st  %i1, [ %i5 + 0x10 ]                        
    tty->major = major;                                               
40004dd8:	f8 27 60 0c 	st  %i4, [ %i5 + 0xc ]                         
                                                                      
    /*                                                                
     * Set up mutex semaphores                                        
     */                                                               
    sc = rtems_semaphore_create (                                     
40004ddc:	92 10 20 01 	mov  1, %o1                                    
40004de0:	94 10 20 54 	mov  0x54, %o2                                 
40004de4:	90 12 00 01 	or  %o0, %g1, %o0                              
40004de8:	96 10 20 00 	clr  %o3                                       
40004dec:	40 00 08 c0 	call  400070ec <rtems_semaphore_create>        
40004df0:	98 07 60 14 	add  %i5, 0x14, %o4                            
      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)                                       
40004df4:	80 a2 20 00 	cmp  %o0, 0                                    
40004df8:	12 80 00 84 	bne  40005008 <rtems_termios_open+0x3c4>       
40004dfc:	03 15 14 9b 	sethi  %hi(0x54526c00), %g1                    
      rtems_fatal_error_occurred (sc);                                
    sc = rtems_semaphore_create (                                     
      rtems_build_name ('T', 'R', 'o', c),                            
40004e00:	d0 4e 23 e8 	ldsb  [ %i0 + 0x3e8 ], %o0                     
      RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
      RTEMS_NO_PRIORITY,                                              
      &tty->isem);                                                    
    if (sc != RTEMS_SUCCESSFUL)                                       
      rtems_fatal_error_occurred (sc);                                
    sc = rtems_semaphore_create (                                     
40004e04:	82 10 63 00 	or  %g1, 0x300, %g1                            
40004e08:	92 10 20 01 	mov  1, %o1                                    
40004e0c:	94 10 20 54 	mov  0x54, %o2                                 
40004e10:	90 12 00 01 	or  %o0, %g1, %o0                              
40004e14:	96 10 20 00 	clr  %o3                                       
40004e18:	40 00 08 b5 	call  400070ec <rtems_semaphore_create>        
40004e1c:	98 07 60 18 	add  %i5, 0x18, %o4                            
      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)                                       
40004e20:	80 a2 20 00 	cmp  %o0, 0                                    
40004e24:	12 80 00 79 	bne  40005008 <rtems_termios_open+0x3c4>       
40004e28:	03 15 14 9e 	sethi  %hi(0x54527800), %g1                    
      rtems_fatal_error_occurred (sc);                                
    sc = rtems_semaphore_create (                                     
      rtems_build_name ('T', 'R', 'x', c),                            
40004e2c:	d0 4e 23 e8 	ldsb  [ %i0 + 0x3e8 ], %o0                     
      RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
      RTEMS_NO_PRIORITY,                                              
      &tty->osem);                                                    
    if (sc != RTEMS_SUCCESSFUL)                                       
      rtems_fatal_error_occurred (sc);                                
    sc = rtems_semaphore_create (                                     
40004e30:	92 10 20 00 	clr  %o1                                       
40004e34:	90 12 00 01 	or  %o0, %g1, %o0                              
40004e38:	94 10 20 20 	mov  0x20, %o2                                 
40004e3c:	96 10 20 00 	clr  %o3                                       
40004e40:	40 00 08 ab 	call  400070ec <rtems_semaphore_create>        
40004e44:	98 07 60 8c 	add  %i5, 0x8c, %o4                            
      rtems_build_name ('T', 'R', 'x', c),                            
      0,                                                              
      RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_FIFO,                     
      RTEMS_NO_PRIORITY,                                              
      &tty->rawOutBuf.Semaphore);                                     
    if (sc != RTEMS_SUCCESSFUL)                                       
40004e48:	80 a2 20 00 	cmp  %o0, 0                                    
40004e4c:	12 80 00 6f 	bne  40005008 <rtems_termios_open+0x3c4>       
40004e50:	92 10 00 1b 	mov  %i3, %o1                                  
      rtems_fatal_error_occurred (sc);                                
    tty->rawOutBufState = rob_idle;                                   
40004e54:	c0 27 60 94 	clr  [ %i5 + 0x94 ]                            
                                                                      
    /*                                                                
     * Set callbacks                                                  
     */                                                               
    tty->device = *callbacks;                                         
40004e58:	90 07 60 98 	add  %i5, 0x98, %o0                            
40004e5c:	40 00 2c 8a 	call  40010084 <memcpy>                        
40004e60:	94 10 20 20 	mov  0x20, %o2                                 
                                                                      
    /*                                                                
     * Create I/O tasks                                               
     */                                                               
    if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {    
40004e64:	c2 07 60 b4 	ld  [ %i5 + 0xb4 ], %g1                        
40004e68:	80 a0 60 02 	cmp  %g1, 2                                    
40004e6c:	02 80 00 69 	be  40005010 <rtems_termios_open+0x3cc>        
40004e70:	d0 4e 23 e8 	ldsb  [ %i0 + 0x3e8 ], %o0                     
           &tty->rxTaskId);                                           
      if (sc != RTEMS_SUCCESSFUL)                                     
        rtems_fatal_error_occurred (sc);                              
                                                                      
    }                                                                 
    if ((tty->device.pollRead == NULL) ||                             
40004e74:	c2 07 60 a0 	ld  [ %i5 + 0xa0 ], %g1                        
40004e78:	80 a0 60 00 	cmp  %g1, 0                                    
40004e7c:	02 80 00 58 	be  40004fdc <rtems_termios_open+0x398>        
40004e80:	d0 4e 23 e8 	ldsb  [ %i0 + 0x3e8 ], %o0                     
40004e84:	c2 07 60 b4 	ld  [ %i5 + 0xb4 ], %g1                        
40004e88:	80 a0 60 02 	cmp  %g1, 2                                    
40004e8c:	02 80 00 55 	be  40004fe0 <rtems_termios_open+0x39c>        
40004e90:	03 15 14 9c 	sethi  %hi(0x54527000), %g1                    
    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;                                               
40004e94:	c0 27 60 b8 	clr  [ %i5 + 0xb8 ]                            
    /*                                                                
     * set low/highwater mark for XON/XOFF support                    
     */                                                               
    tty->lowwater  = tty->rawInBuf.Size * 1/2;                        
40004e98:	c4 07 60 64 	ld  [ %i5 + 0x64 ], %g2                        
    tty->highwater = tty->rawInBuf.Size * 3/4;                        
40004e9c:	c2 07 60 64 	ld  [ %i5 + 0x64 ], %g1                        
    /*                                                                
     * Bump name characer                                             
     */                                                               
    if (c++ == 'z')                                                   
40004ea0:	c6 4e 23 e8 	ldsb  [ %i0 + 0x3e8 ], %g3                     
    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;                        
40004ea4:	89 28 60 01 	sll  %g1, 1, %g4                               
40004ea8:	82 01 00 01 	add  %g4, %g1, %g1                             
                                                                      
    /*                                                                
     * Set default parameters                                         
     */                                                               
    tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;           
    tty->termios.c_oflag = OPOST | ONLCR | XTABS;                     
40004eac:	09 00 00 06 	sethi  %hi(0x1800), %g4                        
40004eb0:	88 11 20 05 	or  %g4, 5, %g4	! 1805 <PROM_START+0x1805>     
40004eb4:	c8 27 60 34 	st  %g4, [ %i5 + 0x34 ]                        
    tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;              
40004eb8:	88 10 28 bd 	mov  0x8bd, %g4                                
40004ebc:	c8 27 60 38 	st  %g4, [ %i5 + 0x38 ]                        
    tty->termios.c_lflag =                                            
40004ec0:	09 00 00 20 	sethi  %hi(0x8000), %g4                        
40004ec4:	88 11 22 3b 	or  %g4, 0x23b, %g4	! 823b <PROM_START+0x823b> 
40004ec8:	c8 27 60 3c 	st  %g4, [ %i5 + 0x3c ]                        
       ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;       
                                                                      
    tty->termios.c_cc[VINTR] = '\003';                                
40004ecc:	88 10 20 03 	mov  3, %g4                                    
40004ed0:	c8 2f 60 41 	stb  %g4, [ %i5 + 0x41 ]                       
    tty->termios.c_cc[VQUIT] = '\034';                                
40004ed4:	88 10 20 1c 	mov  0x1c, %g4                                 
40004ed8:	c8 2f 60 42 	stb  %g4, [ %i5 + 0x42 ]                       
    tty->termios.c_cc[VERASE] = '\177';                               
40004edc:	88 10 20 7f 	mov  0x7f, %g4                                 
40004ee0:	c8 2f 60 43 	stb  %g4, [ %i5 + 0x43 ]                       
    tty->termios.c_cc[VKILL] = '\025';                                
40004ee4:	88 10 20 15 	mov  0x15, %g4                                 
40004ee8:	c8 2f 60 44 	stb  %g4, [ %i5 + 0x44 ]                       
    tty->termios.c_cc[VEOF] = '\004';                                 
40004eec:	88 10 20 04 	mov  4, %g4                                    
40004ef0:	c8 2f 60 45 	stb  %g4, [ %i5 + 0x45 ]                       
    tty->termios.c_cc[VEOL] = '\000';                                 
    tty->termios.c_cc[VEOL2] = '\000';                                
    tty->termios.c_cc[VSTART] = '\021';                               
40004ef4:	88 10 20 11 	mov  0x11, %g4                                 
40004ef8:	c8 2f 60 49 	stb  %g4, [ %i5 + 0x49 ]                       
    tty->termios.c_cc[VSTOP] = '\023';                                
40004efc:	88 10 20 13 	mov  0x13, %g4                                 
40004f00:	c8 2f 60 4a 	stb  %g4, [ %i5 + 0x4a ]                       
    tty->termios.c_cc[VSUSP] = '\032';                                
40004f04:	88 10 20 1a 	mov  0x1a, %g4                                 
40004f08:	c8 2f 60 4b 	stb  %g4, [ %i5 + 0x4b ]                       
    tty->termios.c_cc[VREPRINT] = '\022';                             
40004f0c:	88 10 20 12 	mov  0x12, %g4                                 
40004f10:	c8 2f 60 4d 	stb  %g4, [ %i5 + 0x4d ]                       
    tty->termios.c_cc[VDISCARD] = '\017';                             
40004f14:	88 10 20 0f 	mov  0xf, %g4                                  
40004f18:	c8 2f 60 4e 	stb  %g4, [ %i5 + 0x4e ]                       
    tty->termios.c_cc[VWERASE] = '\027';                              
40004f1c:	88 10 20 17 	mov  0x17, %g4                                 
    /* 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;                        
40004f20:	85 30 a0 01 	srl  %g2, 1, %g2                               
    tty->highwater = tty->rawInBuf.Size * 3/4;                        
40004f24:	83 30 60 02 	srl  %g1, 2, %g1                               
    }                                                                 
                                                                      
    /*                                                                
     * Set default parameters                                         
     */                                                               
    tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;           
40004f28:	37 00 00 09 	sethi  %hi(0x2400), %i3                        
    tty->termios.c_cc[VSTART] = '\021';                               
    tty->termios.c_cc[VSTOP] = '\023';                                
    tty->termios.c_cc[VSUSP] = '\032';                                
    tty->termios.c_cc[VREPRINT] = '\022';                             
    tty->termios.c_cc[VDISCARD] = '\017';                             
    tty->termios.c_cc[VWERASE] = '\027';                              
40004f2c:	c8 2f 60 4f 	stb  %g4, [ %i5 + 0x4f ]                       
    }                                                                 
                                                                      
    /*                                                                
     * Set default parameters                                         
     */                                                               
    tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;           
40004f30:	b6 16 e1 02 	or  %i3, 0x102, %i3                            
    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';                               
40004f34:	88 10 20 16 	mov  0x16, %g4                                 
    /* 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;                        
40004f38:	c4 27 60 bc 	st  %g2, [ %i5 + 0xbc ]                        
    tty->highwater = tty->rawInBuf.Size * 3/4;                        
40004f3c:	c2 27 60 c0 	st  %g1, [ %i5 + 0xc0 ]                        
    }                                                                 
                                                                      
    /*                                                                
     * Set default parameters                                         
     */                                                               
    tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;           
40004f40:	f6 27 60 30 	st  %i3, [ %i5 + 0x30 ]                        
    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';                                 
40004f44:	c0 2f 60 4c 	clrb  [ %i5 + 0x4c ]                           
    tty->termios.c_cc[VEOL2] = '\000';                                
40004f48:	c0 2f 60 51 	clrb  [ %i5 + 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';                               
40004f4c:	c8 2f 60 50 	stb  %g4, [ %i5 + 0x50 ]                       
    tty->lowwater  = tty->rawInBuf.Size * 1/2;                        
    tty->highwater = tty->rawInBuf.Size * 3/4;                        
    /*                                                                
     * Bump name characer                                             
     */                                                               
    if (c++ == 'z')                                                   
40004f50:	03 10 00 78 	sethi  %hi(0x4001e000), %g1                    
40004f54:	80 a0 e0 7a 	cmp  %g3, 0x7a                                 
40004f58:	02 80 00 1e 	be  40004fd0 <rtems_termios_open+0x38c>        
40004f5c:	c4 0e 23 e8 	ldub  [ %i0 + 0x3e8 ], %g2                     
40004f60:	84 00 a0 01 	inc  %g2                                       
40004f64:	10 bf ff 54 	b  40004cb4 <rtems_termios_open+0x70>          
40004f68:	c4 28 63 e8 	stb  %g2, [ %g1 + 0x3e8 ]                      
                                                                      
    /*                                                                
     * start I/O tasks, if needed                                     
     */                                                               
    if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {    
      sc = rtems_task_start(                                          
40004f6c:	94 10 00 1d 	mov  %i5, %o2                                  
40004f70:	13 10 00 19 	sethi  %hi(0x40006400), %o1                    
40004f74:	40 00 0a 39 	call  40007858 <rtems_task_start>              
40004f78:	92 12 62 d8 	or  %o1, 0x2d8, %o1	! 400066d8 <rtems_termios_rxdaemon>
        tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty);
      if (sc != RTEMS_SUCCESSFUL)                                     
40004f7c:	80 a2 20 00 	cmp  %o0, 0                                    
40004f80:	12 80 00 22 	bne  40005008 <rtems_termios_open+0x3c4>       <== NEVER TAKEN
40004f84:	94 10 00 1d 	mov  %i5, %o2                                  
        rtems_fatal_error_occurred (sc);                              
                                                                      
      sc = rtems_task_start(                                          
40004f88:	d0 07 60 c8 	ld  [ %i5 + 0xc8 ], %o0                        
40004f8c:	13 10 00 12 	sethi  %hi(0x40004800), %o1                    
40004f90:	40 00 0a 32 	call  40007858 <rtems_task_start>              
40004f94:	92 12 63 58 	or  %o1, 0x358, %o1	! 40004b58 <rtems_termios_txdaemon>
        tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
      if (sc != RTEMS_SUCCESSFUL)                                     
40004f98:	80 a2 20 00 	cmp  %o0, 0                                    
40004f9c:	02 bf ff 58 	be  40004cfc <rtems_termios_open+0xb8>         <== ALWAYS TAKEN
40004fa0:	01 00 00 00 	nop                                            
40004fa4:	30 80 00 19 	b,a   40005008 <rtems_termios_open+0x3c4>      <== NOT EXECUTED
    /*                                                                
     * allocate cooked buffer                                         
     */                                                               
    tty->cbuf  = malloc (CBUFSIZE);                                   
    if (tty->cbuf == NULL) {                                          
            free((void *)(tty->rawOutBuf.theBuf));                    
40004fa8:	7f ff f8 20 	call  40003028 <free>                          
40004fac:	90 10 00 14 	mov  %l4, %o0                                  
            free((void *)(tty->rawInBuf.theBuf));                     
40004fb0:	7f ff f8 1e 	call  40003028 <free>                          
40004fb4:	90 10 00 13 	mov  %l3, %o0                                  
            free(tty);                                                
40004fb8:	7f ff f8 1c 	call  40003028 <free>                          
40004fbc:	90 10 00 1d 	mov  %i5, %o0                                  
      rtems_semaphore_release (rtems_termios_ttyMutex);               
40004fc0:	d0 04 61 70 	ld  [ %l1 + 0x170 ], %o0                       
40004fc4:	40 00 09 41 	call  400074c8 <rtems_semaphore_release>       
40004fc8:	a0 10 20 1a 	mov  0x1a, %l0                                 
      return RTEMS_NO_MEMORY;                                         
40004fcc:	30 bf ff 4e 	b,a   40004d04 <rtems_termios_open+0xc0>       
    tty->highwater = tty->rawInBuf.Size * 3/4;                        
    /*                                                                
     * Bump name characer                                             
     */                                                               
    if (c++ == 'z')                                                   
      c = 'a';                                                        
40004fd0:	84 10 20 61 	mov  0x61, %g2                                 
40004fd4:	10 bf ff 38 	b  40004cb4 <rtems_termios_open+0x70>          
40004fd8:	c4 28 63 e8 	stb  %g2, [ %g1 + 0x3e8 ]                      
        rtems_fatal_error_occurred (sc);                              
                                                                      
    }                                                                 
    if ((tty->device.pollRead == NULL) ||                             
        (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){   
      sc = rtems_semaphore_create (                                   
40004fdc:	03 15 14 9c 	sethi  %hi(0x54527000), %g1                    
40004fe0:	82 10 62 00 	or  %g1, 0x200, %g1	! 54527200 <RAM_END+0x14127200>
40004fe4:	92 10 20 00 	clr  %o1                                       
40004fe8:	94 10 20 24 	mov  0x24, %o2                                 
40004fec:	90 12 00 01 	or  %o0, %g1, %o0                              
40004ff0:	96 10 20 00 	clr  %o3                                       
40004ff4:	40 00 08 3e 	call  400070ec <rtems_semaphore_create>        
40004ff8:	98 07 60 68 	add  %i5, 0x68, %o4                            
        rtems_build_name ('T', 'R', 'r', c),                          
        0,                                                            
        RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_PRIORITY,               
        RTEMS_NO_PRIORITY,                                            
        &tty->rawInBuf.Semaphore);                                    
      if (sc != RTEMS_SUCCESSFUL)                                     
40004ffc:	80 a2 20 00 	cmp  %o0, 0                                    
40005000:	02 bf ff a5 	be  40004e94 <rtems_termios_open+0x250>        <== ALWAYS TAKEN
40005004:	01 00 00 00 	nop                                            
        rtems_fatal_error_occurred (sc);                              
                                                                      
      sc = rtems_task_start(                                          
        tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
      if (sc != RTEMS_SUCCESSFUL)                                     
        rtems_fatal_error_occurred (sc);                              
40005008:	40 00 0a c6 	call  40007b20 <rtems_fatal_error_occurred>    
4000500c:	01 00 00 00 	nop                                            
                                                                      
    /*                                                                
     * Create I/O tasks                                               
     */                                                               
    if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {    
      sc = rtems_task_create (                                        
40005010:	03 15 1e 15 	sethi  %hi(0x54785400), %g1                    
40005014:	92 10 20 0a 	mov  0xa, %o1                                  
40005018:	90 12 00 01 	or  %o0, %g1, %o0                              
4000501c:	94 10 24 00 	mov  0x400, %o2                                
40005020:	96 10 25 00 	mov  0x500, %o3                                
40005024:	98 10 20 00 	clr  %o4                                       
40005028:	40 00 09 68 	call  400075c8 <rtems_task_create>             
4000502c:	9a 07 60 c8 	add  %i5, 0xc8, %o5                            
           TERMIOS_TXTASK_STACKSIZE,                                  
           RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |                    
           RTEMS_NO_ASR,                                              
           RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,                     
           &tty->txTaskId);                                           
      if (sc != RTEMS_SUCCESSFUL)                                     
40005030:	80 a2 20 00 	cmp  %o0, 0                                    
40005034:	12 bf ff f5 	bne  40005008 <rtems_termios_open+0x3c4>       <== NEVER TAKEN
40005038:	03 14 9e 15 	sethi  %hi(0x52785400), %g1                    
        rtems_fatal_error_occurred (sc);                              
      sc = rtems_task_create (                                        
                                   rtems_build_name ('R', 'x', 'T', c),
4000503c:	d0 4e 23 e8 	ldsb  [ %i0 + 0x3e8 ], %o0                     
           RTEMS_NO_ASR,                                              
           RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,                     
           &tty->txTaskId);                                           
      if (sc != RTEMS_SUCCESSFUL)                                     
        rtems_fatal_error_occurred (sc);                              
      sc = rtems_task_create (                                        
40005040:	92 10 20 09 	mov  9, %o1                                    
40005044:	90 12 00 01 	or  %o0, %g1, %o0                              
40005048:	94 10 24 00 	mov  0x400, %o2                                
4000504c:	96 10 25 00 	mov  0x500, %o3                                
40005050:	98 10 20 00 	clr  %o4                                       
40005054:	40 00 09 5d 	call  400075c8 <rtems_task_create>             
40005058:	9a 07 60 c4 	add  %i5, 0xc4, %o5                            
           TERMIOS_RXTASK_STACKSIZE,                                  
           RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |                    
           RTEMS_NO_ASR,                                              
           RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,                     
           &tty->rxTaskId);                                           
      if (sc != RTEMS_SUCCESSFUL)                                     
4000505c:	80 a2 20 00 	cmp  %o0, 0                                    
40005060:	22 bf ff 86 	be,a   40004e78 <rtems_termios_open+0x234>     <== ALWAYS TAKEN
40005064:	c2 07 60 a0 	ld  [ %i5 + 0xa0 ], %g1                        
40005068:	30 bf ff e8 	b,a   40005008 <rtems_termios_open+0x3c4>      <== NOT EXECUTED
    tty->back = NULL;                                                 
    if (rtems_termios_ttyHead != NULL)                                
      rtems_termios_ttyHead->back = tty;                              
    rtems_termios_ttyHead = tty;                                      
    if (rtems_termios_ttyTail == NULL)                                
      rtems_termios_ttyTail = tty;                                    
4000506c:	10 bf ff 56 	b  40004dc4 <rtems_termios_open+0x180>         
40005070:	fa 20 61 74 	st  %i5, [ %g1 + 0x174 ]                       
                                                                      

4000572c <rtems_termios_puts>: * Send characters to device-specific code */ void rtems_termios_puts ( const void *_buf, size_t len, struct rtems_termios_tty *tty) {
4000572c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  const unsigned char *buf = _buf;                                    
  unsigned int newHead;                                               
  rtems_interrupt_level level;                                        
  rtems_status_code sc;                                               
                                                                      
  if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {           
40005730:	c2 06 a0 b4 	ld  [ %i2 + 0xb4 ], %g1                        
40005734:	80 a0 60 00 	cmp  %g1, 0                                    
40005738:	22 80 00 44 	be,a   40005848 <rtems_termios_puts+0x11c>     
4000573c:	c2 06 a0 a4 	ld  [ %i2 + 0xa4 ], %g1                        
    (*tty->device.write)(tty->minor, buf, len);                       
    return;                                                           
  }                                                                   
  newHead = tty->rawOutBuf.Head;                                      
40005740:	e0 06 a0 80 	ld  [ %i2 + 0x80 ], %l0                        
     * with interrupts enabled.                                       
     */                                                               
    newHead = (newHead + 1) % tty->rawOutBuf.Size;                    
    rtems_interrupt_disable (level);                                  
    while (newHead == tty->rawOutBuf.Tail) {                          
      tty->rawOutBufState = rob_wait;                                 
40005744:	b6 10 20 02 	mov  2, %i3                                    
  if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {           
    (*tty->device.write)(tty->minor, buf, len);                       
    return;                                                           
  }                                                                   
  newHead = tty->rawOutBuf.Head;                                      
  while (len) {                                                       
40005748:	80 a6 60 00 	cmp  %i1, 0                                    
4000574c:	02 80 00 34 	be  4000581c <rtems_termios_puts+0xf0>         <== NEVER TAKEN
40005750:	a2 10 20 01 	mov  1, %l1                                    
     *  len -= ncopy                                                  
     *                                                                
     * To minimize latency, the memcpy should be done                 
     * with interrupts enabled.                                       
     */                                                               
    newHead = (newHead + 1) % tty->rawOutBuf.Size;                    
40005754:	d2 06 a0 88 	ld  [ %i2 + 0x88 ], %o1                        
40005758:	40 00 4c f3 	call  40018b24 <.urem>                         
4000575c:	90 04 20 01 	add  %l0, 1, %o0                               
    rtems_interrupt_disable (level);                                  
40005760:	7f ff f2 51 	call  400020a4 <sparc_disable_interrupts>      
40005764:	a0 10 00 08 	mov  %o0, %l0                                  
40005768:	ba 10 00 08 	mov  %o0, %i5                                  
    while (newHead == tty->rawOutBuf.Tail) {                          
4000576c:	f8 06 a0 84 	ld  [ %i2 + 0x84 ], %i4                        
40005770:	80 a7 00 10 	cmp  %i4, %l0                                  
40005774:	32 80 00 14 	bne,a   400057c4 <rtems_termios_puts+0x98>     
40005778:	c6 0e 00 00 	ldub  [ %i0 ], %g3                             
      tty->rawOutBufState = rob_wait;                                 
4000577c:	f6 26 a0 94 	st  %i3, [ %i2 + 0x94 ]                        
      rtems_interrupt_enable (level);                                 
40005780:	7f ff f2 4d 	call  400020b4 <sparc_enable_interrupts>       
40005784:	90 10 00 1d 	mov  %i5, %o0                                  
      sc = rtems_semaphore_obtain(                                    
40005788:	d0 06 a0 8c 	ld  [ %i2 + 0x8c ], %o0                        
4000578c:	92 10 20 00 	clr  %o1                                       
40005790:	40 00 06 ff 	call  4000738c <rtems_semaphore_obtain>        
40005794:	94 10 20 00 	clr  %o2                                       
        tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);      
      if (sc != RTEMS_SUCCESSFUL)                                     
40005798:	80 a2 20 00 	cmp  %o0, 0                                    
4000579c:	12 80 00 31 	bne  40005860 <rtems_termios_puts+0x134>       <== NEVER TAKEN
400057a0:	01 00 00 00 	nop                                            
        rtems_fatal_error_occurred (sc);                              
      rtems_interrupt_disable (level);                                
400057a4:	7f ff f2 40 	call  400020a4 <sparc_disable_interrupts>      
400057a8:	01 00 00 00 	nop                                            
400057ac:	ba 10 00 08 	mov  %o0, %i5                                  
     * 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) {                          
400057b0:	c2 06 a0 84 	ld  [ %i2 + 0x84 ], %g1                        
400057b4:	80 a0 40 1c 	cmp  %g1, %i4                                  
400057b8:	22 bf ff f2 	be,a   40005780 <rtems_termios_puts+0x54>      <== NEVER TAKEN
400057bc:	f6 26 a0 94 	st  %i3, [ %i2 + 0x94 ]                        <== NOT EXECUTED
        tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);      
      if (sc != RTEMS_SUCCESSFUL)                                     
        rtems_fatal_error_occurred (sc);                              
      rtems_interrupt_disable (level);                                
    }                                                                 
    tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;              
400057c0:	c6 0e 00 00 	ldub  [ %i0 ], %g3                             
400057c4:	c2 06 a0 80 	ld  [ %i2 + 0x80 ], %g1                        
400057c8:	c4 06 a0 7c 	ld  [ %i2 + 0x7c ], %g2                        
400057cc:	b0 06 20 01 	inc  %i0                                       
400057d0:	c6 28 80 01 	stb  %g3, [ %g2 + %g1 ]                        
    tty->rawOutBuf.Head = newHead;                                    
    if (tty->rawOutBufState == rob_idle) {                            
400057d4:	c2 06 a0 94 	ld  [ %i2 + 0x94 ], %g1                        
      if (sc != RTEMS_SUCCESSFUL)                                     
        rtems_fatal_error_occurred (sc);                              
      rtems_interrupt_disable (level);                                
    }                                                                 
    tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;              
    tty->rawOutBuf.Head = newHead;                                    
400057d8:	e0 26 a0 80 	st  %l0, [ %i2 + 0x80 ]                        
    if (tty->rawOutBufState == rob_idle) {                            
400057dc:	80 a0 60 00 	cmp  %g1, 0                                    
400057e0:	12 80 00 0a 	bne  40005808 <rtems_termios_puts+0xdc>        
400057e4:	01 00 00 00 	nop                                            
      /* check, whether XOFF has been received */                     
      if (!(tty->flow_ctrl & FL_ORCVXOF)) {                           
400057e8:	c2 06 a0 b8 	ld  [ %i2 + 0xb8 ], %g1                        
400057ec:	80 88 60 10 	btst  0x10, %g1                                
400057f0:	02 80 00 0d 	be  40005824 <rtems_termios_puts+0xf8>         <== ALWAYS TAKEN
400057f4:	01 00 00 00 	nop                                            
        (*tty->device.write)(                                         
          tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); 
      } else {                                                        
        /* remember that output has been stopped due to flow ctrl*/   
        tty->flow_ctrl |= FL_OSTOP;                                   
400057f8:	c2 06 a0 b8 	ld  [ %i2 + 0xb8 ], %g1                        <== NOT EXECUTED
400057fc:	82 10 60 20 	or  %g1, 0x20, %g1                             <== NOT EXECUTED
40005800:	c2 26 a0 b8 	st  %g1, [ %i2 + 0xb8 ]                        <== NOT EXECUTED
      }                                                               
      tty->rawOutBufState = rob_busy;                                 
40005804:	e2 26 a0 94 	st  %l1, [ %i2 + 0x94 ]                        <== NOT EXECUTED
    }                                                                 
    rtems_interrupt_enable (level);                                   
40005808:	7f ff f2 2b 	call  400020b4 <sparc_enable_interrupts>       
4000580c:	90 10 00 1d 	mov  %i5, %o0                                  
  if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {           
    (*tty->device.write)(tty->minor, buf, len);                       
    return;                                                           
  }                                                                   
  newHead = tty->rawOutBuf.Head;                                      
  while (len) {                                                       
40005810:	b2 86 7f ff 	addcc  %i1, -1, %i1                            
40005814:	12 bf ff d0 	bne  40005754 <rtems_termios_puts+0x28>        
40005818:	01 00 00 00 	nop                                            
4000581c:	81 c7 e0 08 	ret                                            
40005820:	81 e8 00 00 	restore                                        
    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, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); 
40005824:	c4 06 a0 84 	ld  [ %i2 + 0x84 ], %g2                        
    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)(                                         
40005828:	d2 06 a0 7c 	ld  [ %i2 + 0x7c ], %o1                        
4000582c:	c2 06 a0 a4 	ld  [ %i2 + 0xa4 ], %g1                        
40005830:	d0 06 a0 10 	ld  [ %i2 + 0x10 ], %o0                        
40005834:	92 02 40 02 	add  %o1, %g2, %o1                             
40005838:	9f c0 40 00 	call  %g1                                      
4000583c:	94 10 20 01 	mov  1, %o2                                    
          tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); 
      } else {                                                        
        /* remember that output has been stopped due to flow ctrl*/   
        tty->flow_ctrl |= FL_OSTOP;                                   
      }                                                               
      tty->rawOutBufState = rob_busy;                                 
40005840:	10 bf ff f2 	b  40005808 <rtems_termios_puts+0xdc>          
40005844:	e2 26 a0 94 	st  %l1, [ %i2 + 0x94 ]                        
  unsigned int newHead;                                               
  rtems_interrupt_level level;                                        
  rtems_status_code sc;                                               
                                                                      
  if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {           
    (*tty->device.write)(tty->minor, buf, len);                       
40005848:	d0 06 a0 10 	ld  [ %i2 + 0x10 ], %o0                        
4000584c:	92 10 00 18 	mov  %i0, %o1                                  
40005850:	9f c0 40 00 	call  %g1                                      
40005854:	94 10 00 19 	mov  %i1, %o2                                  
    return;                                                           
40005858:	81 c7 e0 08 	ret                                            
4000585c:	81 e8 00 00 	restore                                        
      tty->rawOutBufState = rob_wait;                                 
      rtems_interrupt_enable (level);                                 
      sc = rtems_semaphore_obtain(                                    
        tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);      
      if (sc != RTEMS_SUCCESSFUL)                                     
        rtems_fatal_error_occurred (sc);                              
40005860:	40 00 08 b0 	call  40007b20 <rtems_fatal_error_occurred>    <== NOT EXECUTED
                                                                      

40005fbc <rtems_termios_read>: return RTEMS_SUCCESSFUL; } rtems_status_code rtems_termios_read (void *arg) {
40005fbc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_libio_rw_args_t *args = arg;                                  
  struct rtems_termios_tty *tty = args->iop->data1;                   
40005fc0:	c2 06 00 00 	ld  [ %i0 ], %g1                               
  uint32_t   count = args->count;                                     
40005fc4:	f6 06 20 14 	ld  [ %i0 + 0x14 ], %i3                        
                                                                      
rtems_status_code                                                     
rtems_termios_read (void *arg)                                        
{                                                                     
  rtems_libio_rw_args_t *args = arg;                                  
  struct rtems_termios_tty *tty = args->iop->data1;                   
40005fc8:	fa 00 60 30 	ld  [ %g1 + 0x30 ], %i5                        
  uint32_t   count = args->count;                                     
  char      *buffer = args->buffer;                                   
40005fcc:	e4 06 20 10 	ld  [ %i0 + 0x10 ], %l2                        
  rtems_status_code sc;                                               
                                                                      
  sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
40005fd0:	d0 07 60 14 	ld  [ %i5 + 0x14 ], %o0                        
40005fd4:	92 10 20 00 	clr  %o1                                       
40005fd8:	40 00 04 ed 	call  4000738c <rtems_semaphore_obtain>        
40005fdc:	94 10 20 00 	clr  %o2                                       
  if (sc != RTEMS_SUCCESSFUL)                                         
40005fe0:	a0 92 20 00 	orcc  %o0, 0, %l0                              
40005fe4:	12 80 00 10 	bne  40006024 <rtems_termios_read+0x68>        <== NEVER TAKEN
40005fe8:	03 10 00 7a 	sethi  %hi(0x4001e800), %g1                    
    return sc;                                                        
                                                                      
  if (rtems_termios_linesw[tty->t_line].l_read != NULL) {             
40005fec:	c4 07 60 cc 	ld  [ %i5 + 0xcc ], %g2                        
40005ff0:	85 28 a0 05 	sll  %g2, 5, %g2                               
40005ff4:	82 10 62 ac 	or  %g1, 0x2ac, %g1                            
40005ff8:	82 00 40 02 	add  %g1, %g2, %g1                             
40005ffc:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
40006000:	80 a0 60 00 	cmp  %g1, 0                                    
40006004:	02 80 00 0a 	be  4000602c <rtems_termios_read+0x70>         
40006008:	90 10 00 1d 	mov  %i5, %o0                                  
    sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);          
4000600c:	9f c0 40 00 	call  %g1                                      
40006010:	92 10 00 18 	mov  %i0, %o1                                  
40006014:	a0 10 00 08 	mov  %o0, %l0                                  
    tty->tty_rcvwakeup = 0;                                           
    rtems_semaphore_release (tty->isem);                              
40006018:	d0 07 60 14 	ld  [ %i5 + 0x14 ], %o0                        
4000601c:	40 00 05 2b 	call  400074c8 <rtems_semaphore_release>       
40006020:	c0 27 60 e4 	clr  [ %i5 + 0xe4 ]                            
  }                                                                   
  args->bytes_moved = args->count - count;                            
  tty->tty_rcvwakeup = 0;                                             
  rtems_semaphore_release (tty->isem);                                
  return sc;                                                          
}                                                                     
40006024:	81 c7 e0 08 	ret                                            
40006028:	91 e8 00 10 	restore  %g0, %l0, %o0                         
    tty->tty_rcvwakeup = 0;                                           
    rtems_semaphore_release (tty->isem);                              
    return sc;                                                        
  }                                                                   
                                                                      
  if (tty->cindex == tty->ccount) {                                   
4000602c:	c4 07 60 24 	ld  [ %i5 + 0x24 ], %g2                        
40006030:	c2 07 60 20 	ld  [ %i5 + 0x20 ], %g1                        
40006034:	80 a0 80 01 	cmp  %g2, %g1                                  
40006038:	22 80 00 21 	be,a   400060bc <rtems_termios_read+0x100>     <== ALWAYS TAKEN
4000603c:	c4 07 60 28 	ld  [ %i5 + 0x28 ], %g2                        
      sc = fillBufferQueue (tty);                                     
                                                                      
    if (sc != RTEMS_SUCCESSFUL)                                       
      tty->cindex = tty->ccount = 0;                                  
  }                                                                   
  while (count && (tty->cindex < tty->ccount)) {                      
40006040:	80 a6 e0 00 	cmp  %i3, 0                                    
40006044:	22 80 00 15 	be,a   40006098 <rtems_termios_read+0xdc>      <== NEVER TAKEN
40006048:	b6 10 20 00 	clr  %i3                                       <== NOT EXECUTED
4000604c:	c2 07 60 24 	ld  [ %i5 + 0x24 ], %g1                        
40006050:	c4 07 60 20 	ld  [ %i5 + 0x20 ], %g2                        
40006054:	80 a0 40 02 	cmp  %g1, %g2                                  
40006058:	36 80 00 11 	bge,a   4000609c <rtems_termios_read+0xe0>     
4000605c:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
40006060:	10 80 00 06 	b  40006078 <rtems_termios_read+0xbc>          
40006064:	a4 24 80 01 	sub  %l2, %g1, %l2                             
40006068:	c4 07 60 20 	ld  [ %i5 + 0x20 ], %g2                        
4000606c:	80 a0 80 01 	cmp  %g2, %g1                                  
40006070:	24 80 00 0b 	ble,a   4000609c <rtems_termios_read+0xe0>     
40006074:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
    *buffer++ = tty->cbuf[tty->cindex++];                             
40006078:	c4 07 60 1c 	ld  [ %i5 + 0x1c ], %g2                        
      sc = fillBufferQueue (tty);                                     
                                                                      
    if (sc != RTEMS_SUCCESSFUL)                                       
      tty->cindex = tty->ccount = 0;                                  
  }                                                                   
  while (count && (tty->cindex < tty->ccount)) {                      
4000607c:	b6 86 ff ff 	addcc  %i3, -1, %i3                            
    *buffer++ = tty->cbuf[tty->cindex++];                             
40006080:	c4 08 80 01 	ldub  [ %g2 + %g1 ], %g2                       
40006084:	c4 2c 80 01 	stb  %g2, [ %l2 + %g1 ]                        
40006088:	82 00 60 01 	inc  %g1                                       
      sc = fillBufferQueue (tty);                                     
                                                                      
    if (sc != RTEMS_SUCCESSFUL)                                       
      tty->cindex = tty->ccount = 0;                                  
  }                                                                   
  while (count && (tty->cindex < tty->ccount)) {                      
4000608c:	12 bf ff f7 	bne  40006068 <rtems_termios_read+0xac>        
40006090:	c2 27 60 24 	st  %g1, [ %i5 + 0x24 ]                        
40006094:	b6 10 20 00 	clr  %i3                                       
    *buffer++ = tty->cbuf[tty->cindex++];                             
    count--;                                                          
  }                                                                   
  args->bytes_moved = args->count - count;                            
40006098:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
  tty->tty_rcvwakeup = 0;                                             
  rtems_semaphore_release (tty->isem);                                
4000609c:	d0 07 60 14 	ld  [ %i5 + 0x14 ], %o0                        
  }                                                                   
  while (count && (tty->cindex < tty->ccount)) {                      
    *buffer++ = tty->cbuf[tty->cindex++];                             
    count--;                                                          
  }                                                                   
  args->bytes_moved = args->count - count;                            
400060a0:	b6 20 40 1b 	sub  %g1, %i3, %i3                             
400060a4:	f6 26 20 1c 	st  %i3, [ %i0 + 0x1c ]                        
  tty->tty_rcvwakeup = 0;                                             
400060a8:	c0 27 60 e4 	clr  [ %i5 + 0xe4 ]                            
  rtems_semaphore_release (tty->isem);                                
400060ac:	40 00 05 07 	call  400074c8 <rtems_semaphore_release>       
400060b0:	b0 10 00 10 	mov  %l0, %i0                                  
  return sc;                                                          
}                                                                     
400060b4:	81 c7 e0 08 	ret                                            
400060b8:	81 e8 00 00 	restore                                        
  }                                                                   
                                                                      
  if (tty->cindex == tty->ccount) {                                   
    tty->cindex = tty->ccount = 0;                                    
    tty->read_start_column = tty->column;                             
    if (tty->device.pollRead != NULL &&                               
400060bc:	c2 07 60 a0 	ld  [ %i5 + 0xa0 ], %g1                        
    rtems_semaphore_release (tty->isem);                              
    return sc;                                                        
  }                                                                   
                                                                      
  if (tty->cindex == tty->ccount) {                                   
    tty->cindex = tty->ccount = 0;                                    
400060c0:	c0 27 60 20 	clr  [ %i5 + 0x20 ]                            
400060c4:	c0 27 60 24 	clr  [ %i5 + 0x24 ]                            
    tty->read_start_column = tty->column;                             
    if (tty->device.pollRead != NULL &&                               
400060c8:	80 a0 60 00 	cmp  %g1, 0                                    
400060cc:	02 80 00 06 	be  400060e4 <rtems_termios_read+0x128>        
400060d0:	c4 27 60 2c 	st  %g2, [ %i5 + 0x2c ]                        
400060d4:	c4 07 60 b4 	ld  [ %i5 + 0xb4 ], %g2                        
400060d8:	80 a0 a0 00 	cmp  %g2, 0                                    
400060dc:	22 80 00 6d 	be,a   40006290 <rtems_termios_read+0x2d4>     
400060e0:	c4 07 60 3c 	ld  [ %i5 + 0x3c ], %g2                        
 * Fill the input buffer from the raw input queue                     
 */                                                                   
static rtems_status_code                                              
fillBufferQueue (struct rtems_termios_tty *tty)                       
{                                                                     
  rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;        
400060e4:	f8 07 60 74 	ld  [ %i5 + 0x74 ], %i4                        
  rtems_status_code sc;                                               
  int               wait = 1;                                         
400060e8:	b2 10 20 01 	mov  1, %i1                                    
  while ( wait ) {                                                    
    /*                                                                
     * Process characters read from raw queue                         
     */                                                               
    while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&              
                       (tty->ccount < (CBUFSIZE-1))) {                
400060ec:	23 10 00 78 	sethi  %hi(0x4001e000), %l1                    
             ==                (FL_MDXON | FL_ISNTXOF))               
            && ((tty->rawOutBufState == rob_idle)                     
          || (tty->flow_ctrl & FL_OSTOP))) {                          
          /* XON should be sent now... */                             
          (*tty->device.write)(                                       
            tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);     
400060f0:	a6 07 60 49 	add  %i5, 0x49, %l3                            
                                                                      
  while ( wait ) {                                                    
    /*                                                                
     * Process characters read from raw queue                         
     */                                                               
    while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&              
400060f4:	c4 07 60 5c 	ld  [ %i5 + 0x5c ], %g2                        
400060f8:	c2 07 60 60 	ld  [ %i5 + 0x60 ], %g1                        
400060fc:	80 a0 80 01 	cmp  %g2, %g1                                  
40006100:	02 80 00 42 	be  40006208 <rtems_termios_read+0x24c>        
40006104:	c4 04 63 e4 	ld  [ %l1 + 0x3e4 ], %g2                       
40006108:	c2 07 60 20 	ld  [ %i5 + 0x20 ], %g1                        
                       (tty->ccount < (CBUFSIZE-1))) {                
4000610c:	84 00 bf ff 	add  %g2, -1, %g2                              
                                                                      
  while ( wait ) {                                                    
    /*                                                                
     * Process characters read from raw queue                         
     */                                                               
    while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&              
40006110:	80 a0 80 01 	cmp  %g2, %g1                                  
40006114:	08 80 00 3d 	bleu  40006208 <rtems_termios_read+0x24c>      <== NEVER TAKEN
40006118:	b4 14 63 e4 	or  %l1, 0x3e4, %i2                            
                       (tty->ccount < (CBUFSIZE-1))) {                
      unsigned char c;                                                
      unsigned int newHead;                                           
                                                                      
      newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;        
4000611c:	d0 07 60 5c 	ld  [ %i5 + 0x5c ], %o0                        
40006120:	d2 07 60 64 	ld  [ %i5 + 0x64 ], %o1                        
40006124:	40 00 4a 80 	call  40018b24 <.urem>                         
40006128:	90 02 20 01 	inc  %o0                                       
      c = tty->rawInBuf.theBuf[newHead];                              
4000612c:	c2 07 60 58 	ld  [ %i5 + 0x58 ], %g1                        
40006130:	f8 08 40 08 	ldub  [ %g1 + %o0 ], %i4                       
      tty->rawInBuf.Head = newHead;                                   
40006134:	d0 27 60 5c 	st  %o0, [ %i5 + 0x5c ]                        
      if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)             
40006138:	c2 07 60 60 	ld  [ %i5 + 0x60 ], %g1                        
4000613c:	c4 07 60 64 	ld  [ %i5 + 0x64 ], %g2                        
          % tty->rawInBuf.Size)                                       
40006140:	d2 07 60 64 	ld  [ %i5 + 0x64 ], %o1                        
      unsigned int newHead;                                           
                                                                      
      newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;        
      c = tty->rawInBuf.theBuf[newHead];                              
      tty->rawInBuf.Head = newHead;                                   
      if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)             
40006144:	82 00 80 01 	add  %g2, %g1, %g1                             
          % tty->rawInBuf.Size)                                       
40006148:	40 00 4a 77 	call  40018b24 <.urem>                         
4000614c:	90 20 40 08 	sub  %g1, %o0, %o0                             
      unsigned int newHead;                                           
                                                                      
      newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;        
      c = tty->rawInBuf.theBuf[newHead];                              
      tty->rawInBuf.Head = newHead;                                   
      if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)             
40006150:	c2 07 60 bc 	ld  [ %i5 + 0xbc ], %g1                        
40006154:	80 a2 00 01 	cmp  %o0, %g1                                  
40006158:	3a 80 00 18 	bcc,a   400061b8 <rtems_termios_read+0x1fc>    <== NEVER TAKEN
4000615c:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        <== NOT EXECUTED
          % tty->rawInBuf.Size)                                       
         < tty->lowwater) {                                           
        tty->flow_ctrl &= ~FL_IREQXOF;                                
40006160:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
40006164:	82 08 7f fe 	and  %g1, -2, %g1                              
40006168:	c2 27 60 b8 	st  %g1, [ %i5 + 0xb8 ]                        
        /* if tx stopped and XON should be sent... */                 
        if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))               
4000616c:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
40006170:	82 08 62 02 	and  %g1, 0x202, %g1                           
40006174:	80 a0 62 02 	cmp  %g1, 0x202                                
40006178:	22 80 00 38 	be,a   40006258 <rtems_termios_read+0x29c>     <== NEVER TAKEN
4000617c:	c2 07 60 94 	ld  [ %i5 + 0x94 ], %g1                        <== NOT EXECUTED
            && ((tty->rawOutBufState == rob_idle)                     
          || (tty->flow_ctrl & FL_OSTOP))) {                          
          /* XON should be sent now... */                             
          (*tty->device.write)(                                       
            tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);     
        } else if (tty->flow_ctrl & FL_MDRTS) {                       
40006180:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
40006184:	80 88 61 00 	btst  0x100, %g1                               
40006188:	22 80 00 0c 	be,a   400061b8 <rtems_termios_read+0x1fc>     <== ALWAYS TAKEN
4000618c:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        
          tty->flow_ctrl &= ~FL_IRTSOFF;                              
40006190:	c4 07 60 b8 	ld  [ %i5 + 0xb8 ], %g2                        <== NOT EXECUTED
          /* activate RTS line */                                     
          if (tty->device.startRemoteTx != NULL) {                    
40006194:	c2 07 60 b0 	ld  [ %i5 + 0xb0 ], %g1                        <== NOT EXECUTED
          || (tty->flow_ctrl & FL_OSTOP))) {                          
          /* XON should be sent now... */                             
          (*tty->device.write)(                                       
            tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);     
        } else if (tty->flow_ctrl & FL_MDRTS) {                       
          tty->flow_ctrl &= ~FL_IRTSOFF;                              
40006198:	84 08 bf fb 	and  %g2, -5, %g2                              <== NOT EXECUTED
4000619c:	c4 27 60 b8 	st  %g2, [ %i5 + 0xb8 ]                        <== NOT EXECUTED
          /* activate RTS line */                                     
          if (tty->device.startRemoteTx != NULL) {                    
400061a0:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
400061a4:	22 80 00 05 	be,a   400061b8 <rtems_termios_read+0x1fc>     <== NOT EXECUTED
400061a8:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        <== NOT EXECUTED
            tty->device.startRemoteTx(tty->minor);                    
400061ac:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
400061b0:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        <== NOT EXECUTED
          }                                                           
        }                                                             
      }                                                               
                                                                      
      /* continue processing new character */                         
      if (tty->termios.c_lflag & ICANON) {                            
400061b4:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        <== NOT EXECUTED
        if (siproc (c, tty))                                          
400061b8:	90 0f 20 ff 	and  %i4, 0xff, %o0                            
          }                                                           
        }                                                             
      }                                                               
                                                                      
      /* continue processing new character */                         
      if (tty->termios.c_lflag & ICANON) {                            
400061bc:	80 88 60 02 	btst  2, %g1                                   
400061c0:	02 80 00 1d 	be  40006234 <rtems_termios_read+0x278>        <== NEVER TAKEN
400061c4:	92 10 00 1d 	mov  %i5, %o1                                  
        if (siproc (c, tty))                                          
400061c8:	7f ff ff 36 	call  40005ea0 <siproc>                        
400061cc:	01 00 00 00 	nop                                            
400061d0:	80 a2 20 00 	cmp  %o0, 0                                    
400061d4:	32 80 00 02 	bne,a   400061dc <rtems_termios_read+0x220>    
400061d8:	b2 10 20 00 	clr  %i1                                       
                                                                      
  while ( wait ) {                                                    
    /*                                                                
     * Process characters read from raw queue                         
     */                                                               
    while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&              
400061dc:	c4 07 60 5c 	ld  [ %i5 + 0x5c ], %g2                        
400061e0:	c2 07 60 60 	ld  [ %i5 + 0x60 ], %g1                        
400061e4:	80 a0 80 01 	cmp  %g2, %g1                                  
400061e8:	02 80 00 08 	be  40006208 <rtems_termios_read+0x24c>        
400061ec:	f8 07 60 70 	ld  [ %i5 + 0x70 ], %i4                        
                       (tty->ccount < (CBUFSIZE-1))) {                
400061f0:	c2 06 80 00 	ld  [ %i2 ], %g1                               
                                                                      
  while ( wait ) {                                                    
    /*                                                                
     * Process characters read from raw queue                         
     */                                                               
    while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&              
400061f4:	c4 07 60 20 	ld  [ %i5 + 0x20 ], %g2                        
                       (tty->ccount < (CBUFSIZE-1))) {                
400061f8:	82 00 7f ff 	add  %g1, -1, %g1                              
                                                                      
  while ( wait ) {                                                    
    /*                                                                
     * Process characters read from raw queue                         
     */                                                               
    while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&              
400061fc:	80 a0 80 01 	cmp  %g2, %g1                                  
40006200:	0a bf ff c7 	bcs  4000611c <rtems_termios_read+0x160>       <== ALWAYS TAKEN
40006204:	01 00 00 00 	nop                                            
    }                                                                 
                                                                      
    /*                                                                
     * Wait for characters                                            
     */                                                               
    if ( wait ) {                                                     
40006208:	80 a6 60 00 	cmp  %i1, 0                                    
4000620c:	02 bf ff 8e 	be  40006044 <rtems_termios_read+0x88>         
40006210:	80 a6 e0 00 	cmp  %i3, 0                                    
      sc = rtems_semaphore_obtain(                                    
40006214:	d0 07 60 68 	ld  [ %i5 + 0x68 ], %o0                        
40006218:	d2 07 60 6c 	ld  [ %i5 + 0x6c ], %o1                        
4000621c:	40 00 04 5c 	call  4000738c <rtems_semaphore_obtain>        
40006220:	94 10 00 1c 	mov  %i4, %o2                                  
        tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout);
      if (sc != RTEMS_SUCCESSFUL)                                     
40006224:	80 a2 20 00 	cmp  %o0, 0                                    
40006228:	02 bf ff b3 	be  400060f4 <rtems_termios_read+0x138>        <== ALWAYS TAKEN
4000622c:	80 a6 e0 00 	cmp  %i3, 0                                    
40006230:	30 bf ff 85 	b,a   40006044 <rtems_termios_read+0x88>       <== NOT EXECUTED
      /* continue processing new character */                         
      if (tty->termios.c_lflag & ICANON) {                            
        if (siproc (c, tty))                                          
          wait = 0;                                                   
      } else {                                                        
        siproc (c, tty);                                              
40006234:	7f ff ff 1b 	call  40005ea0 <siproc>                        <== NOT EXECUTED
40006238:	01 00 00 00 	nop                                            <== NOT EXECUTED
        if (tty->ccount >= tty->termios.c_cc[VMIN])                   
4000623c:	c2 0f 60 47 	ldub  [ %i5 + 0x47 ], %g1                      <== NOT EXECUTED
40006240:	c4 07 60 20 	ld  [ %i5 + 0x20 ], %g2                        <== NOT EXECUTED
40006244:	80 a0 80 01 	cmp  %g2, %g1                                  <== NOT EXECUTED
40006248:	06 bf ff e5 	bl  400061dc <rtems_termios_read+0x220>        <== NOT EXECUTED
4000624c:	01 00 00 00 	nop                                            <== NOT EXECUTED
      }                                                               
                                                                      
      /* continue processing new character */                         
      if (tty->termios.c_lflag & ICANON) {                            
        if (siproc (c, tty))                                          
          wait = 0;                                                   
40006250:	10 bf ff e3 	b  400061dc <rtems_termios_read+0x220>         <== NOT EXECUTED
40006254:	b2 10 20 00 	clr  %i1	! 0 <PROM_START>                      <== NOT EXECUTED
         < tty->lowwater) {                                           
        tty->flow_ctrl &= ~FL_IREQXOF;                                
        /* if tx stopped and XON should be sent... */                 
        if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))               
             ==                (FL_MDXON | FL_ISNTXOF))               
            && ((tty->rawOutBufState == rob_idle)                     
40006258:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4000625c:	22 80 00 07 	be,a   40006278 <rtems_termios_read+0x2bc>     <== NOT EXECUTED
40006260:	c2 07 60 a4 	ld  [ %i5 + 0xa4 ], %g1                        <== NOT EXECUTED
          || (tty->flow_ctrl & FL_OSTOP))) {                          
40006264:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        <== NOT EXECUTED
40006268:	80 88 60 20 	btst  0x20, %g1                                <== NOT EXECUTED
4000626c:	02 bf ff c5 	be  40006180 <rtems_termios_read+0x1c4>        <== NOT EXECUTED
40006270:	01 00 00 00 	nop                                            <== NOT EXECUTED
          /* XON should be sent now... */                             
          (*tty->device.write)(                                       
40006274:	c2 07 60 a4 	ld  [ %i5 + 0xa4 ], %g1                        <== NOT EXECUTED
40006278:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        <== NOT EXECUTED
4000627c:	92 10 00 13 	mov  %l3, %o1                                  <== NOT EXECUTED
40006280:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
40006284:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
          }                                                           
        }                                                             
      }                                                               
                                                                      
      /* continue processing new character */                         
      if (tty->termios.c_lflag & ICANON) {                            
40006288:	10 bf ff cc 	b  400061b8 <rtems_termios_read+0x1fc>         <== NOT EXECUTED
4000628c:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        <== NOT EXECUTED
static rtems_status_code                                              
fillBufferPoll (struct rtems_termios_tty *tty)                        
{                                                                     
  int n;                                                              
                                                                      
  if (tty->termios.c_lflag & ICANON) {                                
40006290:	80 88 a0 02 	btst  2, %g2                                   
40006294:	02 80 00 0e 	be  400062cc <rtems_termios_read+0x310>        
40006298:	01 00 00 00 	nop                                            
    for (;;) {                                                        
      n = (*tty->device.pollRead)(tty->minor);                        
4000629c:	9f c0 40 00 	call  %g1                                      
400062a0:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        
      if (n < 0) {                                                    
400062a4:	80 a2 20 00 	cmp  %o0, 0                                    
400062a8:	06 80 00 3a 	bl  40006390 <rtems_termios_read+0x3d4>        
400062ac:	90 0a 20 ff 	and  %o0, 0xff, %o0                            
        rtems_task_wake_after (1);                                    
      } else {                                                        
        if  (siproc (n, tty))                                         
400062b0:	7f ff fe fc 	call  40005ea0 <siproc>                        
400062b4:	92 10 00 1d 	mov  %i5, %o1                                  
400062b8:	80 a2 20 00 	cmp  %o0, 0                                    
400062bc:	12 bf ff 62 	bne  40006044 <rtems_termios_read+0x88>        
400062c0:	80 a6 e0 00 	cmp  %i3, 0                                    
400062c4:	10 bf ff f6 	b  4000629c <rtems_termios_read+0x2e0>         
400062c8:	c2 07 60 a0 	ld  [ %i5 + 0xa0 ], %g1                        
      }                                                               
    }                                                                 
  } else {                                                            
    rtems_interval then, now;                                         
                                                                      
    then = rtems_clock_get_ticks_since_boot();                        
400062cc:	40 00 02 70 	call  40006c8c <rtems_clock_get_ticks_since_boot>
400062d0:	01 00 00 00 	nop                                            
400062d4:	b8 10 00 08 	mov  %o0, %i4                                  
    for (;;) {                                                        
      n = (*tty->device.pollRead)(tty->minor);                        
400062d8:	c2 07 60 a0 	ld  [ %i5 + 0xa0 ], %g1                        
400062dc:	9f c0 40 00 	call  %g1                                      
400062e0:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        
      if (n < 0) {                                                    
400062e4:	80 a2 20 00 	cmp  %o0, 0                                    
400062e8:	06 80 00 10 	bl  40006328 <rtems_termios_read+0x36c>        
400062ec:	90 0a 20 ff 	and  %o0, 0xff, %o0                            
            break;                                                    
          }                                                           
        }                                                             
        rtems_task_wake_after (1);                                    
      } else {                                                        
        siproc (n, tty);                                              
400062f0:	7f ff fe ec 	call  40005ea0 <siproc>                        
400062f4:	92 10 00 1d 	mov  %i5, %o1                                  
        if (tty->ccount >= tty->termios.c_cc[VMIN])                   
400062f8:	c2 0f 60 47 	ldub  [ %i5 + 0x47 ], %g1                      
400062fc:	c4 07 60 20 	ld  [ %i5 + 0x20 ], %g2                        
40006300:	80 a0 80 01 	cmp  %g2, %g1                                  
40006304:	16 bf ff 4f 	bge  40006040 <rtems_termios_read+0x84>        
40006308:	80 a0 60 00 	cmp  %g1, 0                                    
          break;                                                      
        if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])      
4000630c:	22 bf ff f4 	be,a   400062dc <rtems_termios_read+0x320>     <== NEVER TAKEN
40006310:	c2 07 60 a0 	ld  [ %i5 + 0xa0 ], %g1                        <== NOT EXECUTED
40006314:	c2 0f 60 46 	ldub  [ %i5 + 0x46 ], %g1                      
40006318:	80 a0 60 00 	cmp  %g1, 0                                    
4000631c:	22 bf ff f0 	be,a   400062dc <rtems_termios_read+0x320>     <== NEVER TAKEN
40006320:	c2 07 60 a0 	ld  [ %i5 + 0xa0 ], %g1                        <== NOT EXECUTED
40006324:	30 bf ff ea 	b,a   400062cc <rtems_termios_read+0x310>      
                                                                      
    then = rtems_clock_get_ticks_since_boot();                        
    for (;;) {                                                        
      n = (*tty->device.pollRead)(tty->minor);                        
      if (n < 0) {                                                    
        if (tty->termios.c_cc[VMIN]) {                                
40006328:	c2 0f 60 47 	ldub  [ %i5 + 0x47 ], %g1                      
4000632c:	80 a0 60 00 	cmp  %g1, 0                                    
40006330:	02 80 00 0d 	be  40006364 <rtems_termios_read+0x3a8>        
40006334:	c2 0f 60 46 	ldub  [ %i5 + 0x46 ], %g1                      
          if (tty->termios.c_cc[VTIME] && tty->ccount) {              
40006338:	80 a0 60 00 	cmp  %g1, 0                                    
4000633c:	02 80 00 06 	be  40006354 <rtems_termios_read+0x398>        <== NEVER TAKEN
40006340:	01 00 00 00 	nop                                            
40006344:	c2 07 60 20 	ld  [ %i5 + 0x20 ], %g1                        
40006348:	80 a0 60 00 	cmp  %g1, 0                                    
4000634c:	12 80 00 09 	bne  40006370 <rtems_termios_read+0x3b4>       
40006350:	01 00 00 00 	nop                                            
          now = rtems_clock_get_ticks_since_boot();                   
          if ((now - then) > tty->vtimeTicks) {                       
            break;                                                    
          }                                                           
        }                                                             
        rtems_task_wake_after (1);                                    
40006354:	40 00 05 5f 	call  400078d0 <rtems_task_wake_after>         
40006358:	90 10 20 01 	mov  1, %o0	! 1 <PROM_START+0x1>               
  } else {                                                            
    rtems_interval then, now;                                         
                                                                      
    then = rtems_clock_get_ticks_since_boot();                        
    for (;;) {                                                        
      n = (*tty->device.pollRead)(tty->minor);                        
4000635c:	10 bf ff e0 	b  400062dc <rtems_termios_read+0x320>         
40006360:	c2 07 60 a0 	ld  [ %i5 + 0xa0 ], %g1                        
            if ((now - then) > tty->vtimeTicks) {                     
              break;                                                  
            }                                                         
          }                                                           
        } else {                                                      
          if (!tty->termios.c_cc[VTIME])                              
40006364:	80 a0 60 00 	cmp  %g1, 0                                    
40006368:	02 bf ff 37 	be  40006044 <rtems_termios_read+0x88>         <== NEVER TAKEN
4000636c:	80 a6 e0 00 	cmp  %i3, 0                                    
            break;                                                    
          now = rtems_clock_get_ticks_since_boot();                   
40006370:	40 00 02 47 	call  40006c8c <rtems_clock_get_ticks_since_boot>
40006374:	01 00 00 00 	nop                                            
          if ((now - then) > tty->vtimeTicks) {                       
40006378:	c2 07 60 54 	ld  [ %i5 + 0x54 ], %g1                        
4000637c:	90 22 00 1c 	sub  %o0, %i4, %o0                             
40006380:	80 a2 00 01 	cmp  %o0, %g1                                  
40006384:	08 bf ff f4 	bleu  40006354 <rtems_termios_read+0x398>      
40006388:	80 a6 e0 00 	cmp  %i3, 0                                    
4000638c:	30 bf ff 2e 	b,a   40006044 <rtems_termios_read+0x88>       
                                                                      
  if (tty->termios.c_lflag & ICANON) {                                
    for (;;) {                                                        
      n = (*tty->device.pollRead)(tty->minor);                        
      if (n < 0) {                                                    
        rtems_task_wake_after (1);                                    
40006390:	40 00 05 50 	call  400078d0 <rtems_task_wake_after>         
40006394:	90 10 20 01 	mov  1, %o0                                    
40006398:	10 bf ff c1 	b  4000629c <rtems_termios_read+0x2e0>         
4000639c:	c2 07 60 a0 	ld  [ %i5 + 0xa0 ], %g1                        
                                                                      

40004958 <rtems_termios_refill_transmitter>: * in task-driven mode, this function is called in Tx task context * in interrupt-driven mode, this function is called in TxIRQ context */ static int rtems_termios_refill_transmitter (struct rtems_termios_tty *tty) {
40004958:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int nToSend;                                                        
  rtems_interrupt_level level;                                        
  int len;                                                            
                                                                      
  /* check for XOF/XON to send */                                     
  if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))         
4000495c:	c2 06 20 b8 	ld  [ %i0 + 0xb8 ], %g1                        
40004960:	82 08 64 03 	and  %g1, 0x403, %g1                           
40004964:	80 a0 64 01 	cmp  %g1, 0x401                                
40004968:	02 80 00 44 	be  40004a78 <rtems_termios_refill_transmitter+0x120><== NEVER TAKEN
4000496c:	ba 10 00 18 	mov  %i0, %i5                                  
    tty->flow_ctrl |= FL_ISNTXOF;                                     
    rtems_interrupt_enable(level);                                    
                                                                      
    nToSend = 1;                                                      
                                                                      
  } else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) == FL_ISNTXOF) {
40004970:	c2 06 20 b8 	ld  [ %i0 + 0xb8 ], %g1                        
40004974:	82 08 60 03 	and  %g1, 3, %g1                               
40004978:	80 a0 60 02 	cmp  %g1, 2                                    
4000497c:	22 80 00 50 	be,a   40004abc <rtems_termios_refill_transmitter+0x164><== NEVER TAKEN
40004980:	c2 06 20 a4 	ld  [ %i0 + 0xa4 ], %g1                        <== NOT EXECUTED
    tty->flow_ctrl &= ~FL_ISNTXOF;                                    
    rtems_interrupt_enable(level);                                    
                                                                      
    nToSend = 1;                                                      
  } else {                                                            
    if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {               
40004984:	c4 06 20 80 	ld  [ %i0 + 0x80 ], %g2                        
40004988:	c2 06 20 84 	ld  [ %i0 + 0x84 ], %g1                        
4000498c:	80 a0 80 01 	cmp  %g2, %g1                                  
40004990:	22 80 00 30 	be,a   40004a50 <rtems_termios_refill_transmitter+0xf8>
40004994:	c2 06 20 94 	ld  [ %i0 + 0x94 ], %g1                        
        rtems_semaphore_release (tty->rawOutBuf.Semaphore);           
      }                                                               
      return 0;                                                       
    }                                                                 
                                                                      
    rtems_interrupt_disable(level);                                   
40004998:	7f ff f5 c3 	call  400020a4 <sparc_disable_interrupts>      
4000499c:	01 00 00 00 	nop                                            
    len = tty->t_dqlen;                                               
400049a0:	f8 06 20 90 	ld  [ %i0 + 0x90 ], %i4                        
    tty->t_dqlen = 0;                                                 
400049a4:	c0 26 20 90 	clr  [ %i0 + 0x90 ]                            
    rtems_interrupt_enable(level);                                    
400049a8:	7f ff f5 c3 	call  400020b4 <sparc_enable_interrupts>       
400049ac:	01 00 00 00 	nop                                            
                                                                      
    newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;      
400049b0:	d0 06 20 84 	ld  [ %i0 + 0x84 ], %o0                        
400049b4:	d2 06 20 88 	ld  [ %i0 + 0x88 ], %o1                        
400049b8:	40 00 50 5b 	call  40018b24 <.urem>                         
400049bc:	90 07 00 08 	add  %i4, %o0, %o0                             
    tty->rawOutBuf.Tail = newTail;                                    
    if (tty->rawOutBufState == rob_wait) {                            
400049c0:	c2 06 20 94 	ld  [ %i0 + 0x94 ], %g1                        
    len = tty->t_dqlen;                                               
    tty->t_dqlen = 0;                                                 
    rtems_interrupt_enable(level);                                    
                                                                      
    newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;      
    tty->rawOutBuf.Tail = newTail;                                    
400049c4:	d0 27 60 84 	st  %o0, [ %i5 + 0x84 ]                        
    if (tty->rawOutBufState == rob_wait) {                            
400049c8:	80 a0 60 02 	cmp  %g1, 2                                    
400049cc:	02 80 00 55 	be  40004b20 <rtems_termios_refill_transmitter+0x1c8>
400049d0:	b8 10 00 08 	mov  %o0, %i4                                  
       * wake up any pending writer task                              
       */                                                             
      rtems_semaphore_release (tty->rawOutBuf.Semaphore);             
    }                                                                 
                                                                      
    if (newTail == tty->rawOutBuf.Head) {                             
400049d4:	c2 07 60 80 	ld  [ %i5 + 0x80 ], %g1                        
400049d8:	80 a0 40 1c 	cmp  %g1, %i4                                  
400049dc:	22 80 00 48 	be,a   40004afc <rtems_termios_refill_transmitter+0x1a4>
400049e0:	c2 07 60 d4 	ld  [ %i5 + 0xd4 ], %g1                        
      if ( tty->tty_snd.sw_pfn != NULL) {                             
        (*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);   
      }                                                               
    }                                                                 
    /* check, whether output should stop due to received XOFF */      
    else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))               
400049e4:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
400049e8:	82 08 62 10 	and  %g1, 0x210, %g1                           
400049ec:	80 a0 62 10 	cmp  %g1, 0x210                                
400049f0:	02 80 00 4f 	be  40004b2c <rtems_termios_refill_transmitter+0x1d4><== NEVER TAKEN
400049f4:	01 00 00 00 	nop                                            
      nToSend = 0;                                                    
    } else {                                                          
      /*                                                              
       * Buffer not empty, start tranmitter                           
       */                                                             
      if (newTail > tty->rawOutBuf.Head)                              
400049f8:	c2 07 60 80 	ld  [ %i5 + 0x80 ], %g1                        
400049fc:	80 a7 00 01 	cmp  %i4, %g1                                  
40004a00:	18 80 00 1b 	bgu  40004a6c <rtems_termios_refill_transmitter+0x114>
40004a04:	01 00 00 00 	nop                                            
        nToSend = tty->rawOutBuf.Size - newTail;                      
      else                                                            
        nToSend = tty->rawOutBuf.Head - newTail;                      
40004a08:	f0 07 60 80 	ld  [ %i5 + 0x80 ], %i0                        
40004a0c:	b0 26 00 1c 	sub  %i0, %i4, %i0                             
      /* 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)) {                   
40004a10:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
40004a14:	80 88 66 00 	btst  0x600, %g1                               
40004a18:	02 80 00 04 	be  40004a28 <rtems_termios_refill_transmitter+0xd0>
40004a1c:	94 10 00 18 	mov  %i0, %o2                                  
40004a20:	94 10 20 01 	mov  1, %o2                                    
        nToSend = 1;                                                  
40004a24:	b0 10 20 01 	mov  1, %i0                                    
      }                                                               
      tty->rawOutBufState = rob_busy; /*apm*/                         
      (*tty->device.write)(                                           
40004a28:	d2 07 60 7c 	ld  [ %i5 + 0x7c ], %o1                        
40004a2c:	c2 07 60 a4 	ld  [ %i5 + 0xa4 ], %g1                        
40004a30:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        
      /* to allow fast reaction on incoming flow ctrl and low latency*/
      /* for outgoing flow control                                   */
      if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {                   
        nToSend = 1;                                                  
      }                                                               
      tty->rawOutBufState = rob_busy; /*apm*/                         
40004a34:	84 10 20 01 	mov  1, %g2                                    
      (*tty->device.write)(                                           
40004a38:	92 02 40 1c 	add  %o1, %i4, %o1                             
40004a3c:	9f c0 40 00 	call  %g1                                      
40004a40:	c4 27 60 94 	st  %g2, [ %i5 + 0x94 ]                        
        tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);        
    }                                                                 
    tty->rawOutBuf.Tail = newTail; /*apm*/                            
40004a44:	f8 27 60 84 	st  %i4, [ %i5 + 0x84 ]                        
  }                                                                   
  return nToSend;                                                     
}                                                                     
40004a48:	81 c7 e0 08 	ret                                            
40004a4c:	81 e8 00 00 	restore                                        
  } else {                                                            
    if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {               
      /*                                                              
       * buffer was empty                                             
       */                                                             
      if (tty->rawOutBufState == rob_wait) {                          
40004a50:	80 a0 60 02 	cmp  %g1, 2                                    
40004a54:	12 bf ff fd 	bne  40004a48 <rtems_termios_refill_transmitter+0xf0><== ALWAYS TAKEN
40004a58:	b0 10 20 00 	clr  %i0                                       
        /*                                                            
         * this should never happen...                                
         */                                                           
        rtems_semaphore_release (tty->rawOutBuf.Semaphore);           
40004a5c:	40 00 0a 9b 	call  400074c8 <rtems_semaphore_release>       <== NOT EXECUTED
40004a60:	d0 07 60 8c 	ld  [ %i5 + 0x8c ], %o0                        <== NOT EXECUTED
40004a64:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40004a68:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    } else {                                                          
      /*                                                              
       * Buffer not empty, start tranmitter                           
       */                                                             
      if (newTail > tty->rawOutBuf.Head)                              
        nToSend = tty->rawOutBuf.Size - newTail;                      
40004a6c:	f0 07 60 88 	ld  [ %i5 + 0x88 ], %i0                        
40004a70:	10 bf ff e8 	b  40004a10 <rtems_termios_refill_transmitter+0xb8>
40004a74:	b0 26 00 1c 	sub  %i0, %i4, %i0                             
                                                                      
  /* check for XOF/XON to send */                                     
  if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))         
      == (FL_MDXOF | FL_IREQXOF)) {                                   
    /* XOFF should be sent now... */                                  
    (*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
40004a78:	c2 06 20 a4 	ld  [ %i0 + 0xa4 ], %g1                        <== NOT EXECUTED
40004a7c:	d0 06 20 10 	ld  [ %i0 + 0x10 ], %o0                        <== NOT EXECUTED
40004a80:	92 06 20 4a 	add  %i0, 0x4a, %o1                            <== NOT EXECUTED
40004a84:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
40004a88:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
                                                                      
    rtems_interrupt_disable(level);                                   
40004a8c:	7f ff f5 86 	call  400020a4 <sparc_disable_interrupts>      <== NOT EXECUTED
40004a90:	01 00 00 00 	nop                                            <== NOT EXECUTED
    tty->t_dqlen--;                                                   
40004a94:	c4 06 20 90 	ld  [ %i0 + 0x90 ], %g2                        <== NOT EXECUTED
    tty->flow_ctrl |= FL_ISNTXOF;                                     
40004a98:	c2 06 20 b8 	ld  [ %i0 + 0xb8 ], %g1                        <== NOT EXECUTED
      == (FL_MDXOF | FL_IREQXOF)) {                                   
    /* XOFF should be sent now... */                                  
    (*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
                                                                      
    rtems_interrupt_disable(level);                                   
    tty->t_dqlen--;                                                   
40004a9c:	84 00 bf ff 	add  %g2, -1, %g2                              <== NOT EXECUTED
    tty->flow_ctrl |= FL_ISNTXOF;                                     
40004aa0:	82 10 60 02 	or  %g1, 2, %g1                                <== NOT EXECUTED
     * Therefore the dequeue "length" should be reduced by 1          
     */                                                               
    (*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
                                                                      
    rtems_interrupt_disable(level);                                   
    tty->t_dqlen--;                                                   
40004aa4:	c4 27 60 90 	st  %g2, [ %i5 + 0x90 ]                        <== NOT EXECUTED
    tty->flow_ctrl &= ~FL_ISNTXOF;                                    
40004aa8:	c2 27 60 b8 	st  %g1, [ %i5 + 0xb8 ]                        <== NOT EXECUTED
    rtems_interrupt_enable(level);                                    
40004aac:	7f ff f5 82 	call  400020b4 <sparc_enable_interrupts>       <== NOT EXECUTED
40004ab0:	b0 10 20 01 	mov  1, %i0                                    <== NOT EXECUTED
40004ab4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40004ab8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
     * FIXME: this .write call will generate another                  
     * dequeue callback. This will advance the "Tail" in the data     
     * buffer, although the corresponding data is not yet out!        
     * Therefore the dequeue "length" should be reduced by 1          
     */                                                               
    (*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
40004abc:	d0 06 20 10 	ld  [ %i0 + 0x10 ], %o0                        <== NOT EXECUTED
40004ac0:	92 06 20 49 	add  %i0, 0x49, %o1                            <== NOT EXECUTED
40004ac4:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
40004ac8:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
                                                                      
    rtems_interrupt_disable(level);                                   
40004acc:	7f ff f5 76 	call  400020a4 <sparc_disable_interrupts>      <== NOT EXECUTED
40004ad0:	01 00 00 00 	nop                                            <== NOT EXECUTED
    tty->t_dqlen--;                                                   
40004ad4:	c4 06 20 90 	ld  [ %i0 + 0x90 ], %g2                        <== NOT EXECUTED
    tty->flow_ctrl &= ~FL_ISNTXOF;                                    
40004ad8:	c2 06 20 b8 	ld  [ %i0 + 0xb8 ], %g1                        <== NOT EXECUTED
     * Therefore the dequeue "length" should be reduced by 1          
     */                                                               
    (*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
                                                                      
    rtems_interrupt_disable(level);                                   
    tty->t_dqlen--;                                                   
40004adc:	84 00 bf ff 	add  %g2, -1, %g2                              <== NOT EXECUTED
    tty->flow_ctrl &= ~FL_ISNTXOF;                                    
40004ae0:	82 08 7f fd 	and  %g1, -3, %g1                              <== NOT EXECUTED
     * Therefore the dequeue "length" should be reduced by 1          
     */                                                               
    (*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
                                                                      
    rtems_interrupt_disable(level);                                   
    tty->t_dqlen--;                                                   
40004ae4:	c4 27 60 90 	st  %g2, [ %i5 + 0x90 ]                        <== NOT EXECUTED
    tty->flow_ctrl &= ~FL_ISNTXOF;                                    
40004ae8:	c2 27 60 b8 	st  %g1, [ %i5 + 0xb8 ]                        <== NOT EXECUTED
    rtems_interrupt_enable(level);                                    
40004aec:	7f ff f5 72 	call  400020b4 <sparc_enable_interrupts>       <== NOT EXECUTED
40004af0:	b0 10 20 01 	mov  1, %i0                                    <== NOT EXECUTED
40004af4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40004af8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
    if (newTail == tty->rawOutBuf.Head) {                             
      /*                                                              
       * Buffer has become empty                                      
       */                                                             
      tty->rawOutBufState = rob_idle;                                 
40004afc:	c0 27 60 94 	clr  [ %i5 + 0x94 ]                            
      nToSend = 0;                                                    
                                                                      
      /*                                                              
       * check to see if snd wakeup callback was set                  
       */                                                             
      if ( tty->tty_snd.sw_pfn != NULL) {                             
40004b00:	80 a0 60 00 	cmp  %g1, 0                                    
40004b04:	02 bf ff d0 	be  40004a44 <rtems_termios_refill_transmitter+0xec><== ALWAYS TAKEN
40004b08:	b0 10 20 00 	clr  %i0                                       
        (*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);   
40004b0c:	d2 07 60 d8 	ld  [ %i5 + 0xd8 ], %o1                        <== NOT EXECUTED
40004b10:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
40004b14:	90 07 60 30 	add  %i5, 0x30, %o0                            <== NOT EXECUTED
      }                                                               
      tty->rawOutBufState = rob_busy; /*apm*/                         
      (*tty->device.write)(                                           
        tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);        
    }                                                                 
    tty->rawOutBuf.Tail = newTail; /*apm*/                            
40004b18:	f8 27 60 84 	st  %i4, [ %i5 + 0x84 ]                        <== NOT EXECUTED
40004b1c:	30 bf ff f6 	b,a   40004af4 <rtems_termios_refill_transmitter+0x19c><== NOT EXECUTED
    tty->rawOutBuf.Tail = newTail;                                    
    if (tty->rawOutBufState == rob_wait) {                            
      /*                                                              
       * wake up any pending writer task                              
       */                                                             
      rtems_semaphore_release (tty->rawOutBuf.Semaphore);             
40004b20:	40 00 0a 6a 	call  400074c8 <rtems_semaphore_release>       
40004b24:	d0 06 20 8c 	ld  [ %i0 + 0x8c ], %o0                        
40004b28:	30 bf ff ab 	b,a   400049d4 <rtems_termios_refill_transmitter+0x7c>
    /* check, whether output should stop due to received XOFF */      
    else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))               
       ==                (FL_MDXON | FL_ORCVXOF)) {                   
      /* Buffer not empty, but output stops due to XOFF */            
      /* set flag, that output has been stopped */                    
      rtems_interrupt_disable(level);                                 
40004b2c:	7f ff f5 5e 	call  400020a4 <sparc_disable_interrupts>      <== NOT EXECUTED
40004b30:	01 00 00 00 	nop                                            <== NOT EXECUTED
      tty->flow_ctrl |= FL_OSTOP;                                     
40004b34:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        <== NOT EXECUTED
      tty->rawOutBufState = rob_busy; /*apm*/                         
40004b38:	84 10 20 01 	mov  1, %g2                                    <== NOT EXECUTED
    else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))               
       ==                (FL_MDXON | FL_ORCVXOF)) {                   
      /* Buffer not empty, but output stops due to XOFF */            
      /* set flag, that output has been stopped */                    
      rtems_interrupt_disable(level);                                 
      tty->flow_ctrl |= FL_OSTOP;                                     
40004b3c:	82 10 60 20 	or  %g1, 0x20, %g1                             <== NOT EXECUTED
      tty->rawOutBufState = rob_busy; /*apm*/                         
40004b40:	c4 27 60 94 	st  %g2, [ %i5 + 0x94 ]                        <== NOT EXECUTED
    else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))               
       ==                (FL_MDXON | FL_ORCVXOF)) {                   
      /* Buffer not empty, but output stops due to XOFF */            
      /* set flag, that output has been stopped */                    
      rtems_interrupt_disable(level);                                 
      tty->flow_ctrl |= FL_OSTOP;                                     
40004b44:	c2 27 60 b8 	st  %g1, [ %i5 + 0xb8 ]                        <== NOT EXECUTED
      tty->rawOutBufState = rob_busy; /*apm*/                         
      rtems_interrupt_enable(level);                                  
40004b48:	7f ff f5 5b 	call  400020b4 <sparc_enable_interrupts>       <== NOT EXECUTED
40004b4c:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
      }                                                               
      tty->rawOutBufState = rob_busy; /*apm*/                         
      (*tty->device.write)(                                           
        tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);        
    }                                                                 
    tty->rawOutBuf.Tail = newTail; /*apm*/                            
40004b50:	f8 27 60 84 	st  %i4, [ %i5 + 0x84 ]                        <== NOT EXECUTED
40004b54:	30 bf ff e8 	b,a   40004af4 <rtems_termios_refill_transmitter+0x19c><== NOT EXECUTED
                                                                      

400066d8 <rtems_termios_rxdaemon>: /* * this task actually processes any receive events */ static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument) {
400066d8:	9d e3 bf 98 	save  %sp, -104, %sp                           
                                                                      
  while (1) {                                                         
    /*                                                                
     * wait for rtems event                                           
     */                                                               
    rtems_event_receive(                                              
400066dc:	10 80 00 08 	b  400066fc <rtems_termios_rxdaemon+0x24>      
400066e0:	96 07 bf fc 	add  %fp, -4, %o3                              
    }                                                                 
                                                                      
    /*                                                                
     * do something                                                   
     */                                                               
    c = tty->device.pollRead(tty->minor);                             
400066e4:	9f c0 40 00 	call  %g1                                      
400066e8:	d0 06 20 10 	ld  [ %i0 + 0x10 ], %o0                        
    if (c != EOF) {                                                   
400066ec:	80 a2 3f ff 	cmp  %o0, -1                                   
400066f0:	32 80 00 15 	bne,a   40006744 <rtems_termios_rxdaemon+0x6c> 
400066f4:	d0 2f bf fb 	stb  %o0, [ %fp + -5 ]                         
                                                                      
  while (1) {                                                         
    /*                                                                
     * wait for rtems event                                           
     */                                                               
    rtems_event_receive(                                              
400066f8:	96 07 bf fc 	add  %fp, -4, %o3                              
400066fc:	92 10 20 02 	mov  2, %o1                                    
40006700:	94 10 20 00 	clr  %o2                                       
40006704:	40 00 01 85 	call  40006d18 <rtems_event_receive>           
40006708:	90 10 20 03 	mov  3, %o0                                    
      (TERMIOS_RX_PROC_EVENT | TERMIOS_RX_TERMINATE_EVENT),           
      RTEMS_EVENT_ANY | RTEMS_WAIT,                                   
      RTEMS_NO_TIMEOUT,                                               
      &the_event                                                      
    );                                                                
    if ((the_event & TERMIOS_RX_TERMINATE_EVENT) != 0) {              
4000670c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40006710:	80 88 60 01 	btst  1, %g1                                   
40006714:	22 bf ff f4 	be,a   400066e4 <rtems_termios_rxdaemon+0xc>   <== ALWAYS TAKEN
40006718:	c2 06 20 a0 	ld  [ %i0 + 0xa0 ], %g1                        
      tty->rxTaskId = 0;                                              
4000671c:	c0 26 20 c4 	clr  [ %i0 + 0xc4 ]                            <== NOT EXECUTED
      rtems_task_delete(RTEMS_SELF);                                  
40006720:	40 00 03 f3 	call  400076ec <rtems_task_delete>             <== NOT EXECUTED
40006724:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * do something                                                   
     */                                                               
    c = tty->device.pollRead(tty->minor);                             
40006728:	c2 06 20 a0 	ld  [ %i0 + 0xa0 ], %g1                        <== NOT EXECUTED
4000672c:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
40006730:	d0 06 20 10 	ld  [ %i0 + 0x10 ], %o0                        <== NOT EXECUTED
    if (c != EOF) {                                                   
40006734:	80 a2 3f ff 	cmp  %o0, -1                                   <== NOT EXECUTED
40006738:	22 bf ff f1 	be,a   400066fc <rtems_termios_rxdaemon+0x24>  <== NOT EXECUTED
4000673c:	96 07 bf fc 	add  %fp, -4, %o3                              <== NOT EXECUTED
      /*                                                              
       * pollRead did call enqueue on its own                         
       */                                                             
      c_buf = c;                                                      
40006740:	d0 2f bf fb 	stb  %o0, [ %fp + -5 ]                         <== NOT EXECUTED
      rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);           
40006744:	92 07 bf fb 	add  %fp, -5, %o1                              
40006748:	90 10 00 18 	mov  %i0, %o0                                  
4000674c:	7f ff ff 1a 	call  400063b4 <rtems_termios_enqueue_raw_characters>
40006750:	94 10 20 01 	mov  1, %o2                                    
                                                                      
  while (1) {                                                         
    /*                                                                
     * wait for rtems event                                           
     */                                                               
    rtems_event_receive(                                              
40006754:	10 bf ff ea 	b  400066fc <rtems_termios_rxdaemon+0x24>      
40006758:	96 07 bf fc 	add  %fp, -4, %o3                              
                                                                      

40004b58 <rtems_termios_txdaemon>: /* * this task actually processes any transmit events */ static rtems_task rtems_termios_txdaemon(rtems_task_argument argument) {
40004b58:	9d e3 bf 98 	save  %sp, -104, %sp                           
40004b5c:	3b 10 00 7a 	sethi  %hi(0x4001e800), %i5                    
40004b60:	10 80 00 0c 	b  40004b90 <rtems_termios_txdaemon+0x38>      
40004b64:	ba 17 62 ac 	or  %i5, 0x2ac, %i5	! 4001eaac <rtems_termios_linesw>
    }                                                                 
                                                                      
    /*                                                                
     * call any line discipline start function                        
     */                                                               
    if (rtems_termios_linesw[tty->t_line].l_start != NULL) {          
40004b68:	83 28 60 05 	sll  %g1, 5, %g1                               
40004b6c:	82 07 40 01 	add  %i5, %g1, %g1                             
40004b70:	c2 00 60 14 	ld  [ %g1 + 0x14 ], %g1                        
40004b74:	80 a0 60 00 	cmp  %g1, 0                                    
40004b78:	02 80 00 04 	be  40004b88 <rtems_termios_txdaemon+0x30>     <== ALWAYS TAKEN
40004b7c:	90 10 00 18 	mov  %i0, %o0                                  
      rtems_termios_linesw[tty->t_line].l_start(tty);                 
40004b80:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
40004b84:	01 00 00 00 	nop                                            <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * try to push further characters to device                       
     */                                                               
    rtems_termios_refill_transmitter(tty);                            
40004b88:	7f ff ff 74 	call  40004958 <rtems_termios_refill_transmitter>
40004b8c:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
  while (1) {                                                         
    /*                                                                
     * wait for rtems event                                           
     */                                                               
    rtems_event_receive(                                              
40004b90:	92 10 20 02 	mov  2, %o1                                    
40004b94:	94 10 20 00 	clr  %o2                                       
40004b98:	96 07 bf fc 	add  %fp, -4, %o3                              
40004b9c:	40 00 08 5f 	call  40006d18 <rtems_event_receive>           
40004ba0:	90 10 20 03 	mov  3, %o0                                    
       (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) {              
40004ba4:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40004ba8:	80 88 60 01 	btst  1, %g1                                   
40004bac:	22 bf ff ef 	be,a   40004b68 <rtems_termios_txdaemon+0x10>  <== ALWAYS TAKEN
40004bb0:	c2 06 20 cc 	ld  [ %i0 + 0xcc ], %g1                        
      tty->txTaskId = 0;                                              
40004bb4:	c0 26 20 c8 	clr  [ %i0 + 0xc8 ]                            <== NOT EXECUTED
      rtems_task_delete(RTEMS_SELF);                                  
40004bb8:	40 00 0a cd 	call  400076ec <rtems_task_delete>             <== NOT EXECUTED
40004bbc:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * call any line discipline start function                        
     */                                                               
    if (rtems_termios_linesw[tty->t_line].l_start != NULL) {          
40004bc0:	10 bf ff ea 	b  40004b68 <rtems_termios_txdaemon+0x10>      <== NOT EXECUTED
40004bc4:	c2 06 20 cc 	ld  [ %i0 + 0xcc ], %g1                        <== NOT EXECUTED
                                                                      

40005ee8 <rtems_termios_write>: rtems_termios_puts (&c, 1, tty); } rtems_status_code rtems_termios_write (void *arg) {
40005ee8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_libio_rw_args_t *args = arg;                                  
  struct rtems_termios_tty *tty = args->iop->data1;                   
40005eec:	c2 06 00 00 	ld  [ %i0 ], %g1                               
  rtems_status_code sc;                                               
                                                                      
  sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
40005ef0:	92 10 20 00 	clr  %o1                                       
                                                                      
rtems_status_code                                                     
rtems_termios_write (void *arg)                                       
{                                                                     
  rtems_libio_rw_args_t *args = arg;                                  
  struct rtems_termios_tty *tty = args->iop->data1;                   
40005ef4:	fa 00 60 30 	ld  [ %g1 + 0x30 ], %i5                        
  rtems_status_code sc;                                               
                                                                      
  sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
40005ef8:	94 10 20 00 	clr  %o2                                       
40005efc:	40 00 05 24 	call  4000738c <rtems_semaphore_obtain>        
40005f00:	d0 07 60 18 	ld  [ %i5 + 0x18 ], %o0                        
  if (sc != RTEMS_SUCCESSFUL)                                         
40005f04:	b4 92 20 00 	orcc  %o0, 0, %i2                              
40005f08:	12 80 00 0f 	bne  40005f44 <rtems_termios_write+0x5c>       <== NEVER TAKEN
40005f0c:	03 10 00 7a 	sethi  %hi(0x4001e800), %g1                    
    return sc;                                                        
  if (rtems_termios_linesw[tty->t_line].l_write != NULL) {            
40005f10:	c4 07 60 cc 	ld  [ %i5 + 0xcc ], %g2                        
40005f14:	85 28 a0 05 	sll  %g2, 5, %g2                               
40005f18:	82 10 62 ac 	or  %g1, 0x2ac, %g1                            
40005f1c:	82 00 40 02 	add  %g1, %g2, %g1                             
40005f20:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
40005f24:	80 a0 60 00 	cmp  %g1, 0                                    
40005f28:	02 80 00 09 	be  40005f4c <rtems_termios_write+0x64>        
40005f2c:	90 10 00 1d 	mov  %i5, %o0                                  
    sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);         
40005f30:	9f c0 40 00 	call  %g1                                      
40005f34:	92 10 00 18 	mov  %i0, %o1                                  
40005f38:	b4 10 00 08 	mov  %o0, %i2                                  
    rtems_semaphore_release (tty->osem);                              
40005f3c:	40 00 05 63 	call  400074c8 <rtems_semaphore_release>       
40005f40:	d0 07 60 18 	ld  [ %i5 + 0x18 ], %o0                        
    rtems_termios_puts (args->buffer, args->count, tty);              
    args->bytes_moved = args->count;                                  
  }                                                                   
  rtems_semaphore_release (tty->osem);                                
  return sc;                                                          
}                                                                     
40005f44:	81 c7 e0 08 	ret                                            
40005f48:	91 e8 00 1a 	restore  %g0, %i2, %o0                         
  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) {                                 
40005f4c:	c2 07 60 34 	ld  [ %i5 + 0x34 ], %g1                        
40005f50:	80 88 60 01 	btst  1, %g1                                   
40005f54:	22 80 00 14 	be,a   40005fa4 <rtems_termios_write+0xbc>     <== NEVER TAKEN
40005f58:	d0 1e 20 10 	ldd  [ %i0 + 0x10 ], %o0                       <== NOT EXECUTED
    uint32_t   count = args->count;                                   
40005f5c:	f8 06 20 14 	ld  [ %i0 + 0x14 ], %i4                        
    char      *buffer = args->buffer;                                 
    while (count--)                                                   
40005f60:	80 a7 20 00 	cmp  %i4, 0                                    
40005f64:	02 80 00 14 	be  40005fb4 <rtems_termios_write+0xcc>        <== NEVER TAKEN
40005f68:	f6 06 20 10 	ld  [ %i0 + 0x10 ], %i3                        
      oproc (*buffer++, tty);                                         
40005f6c:	d0 0e c0 00 	ldub  [ %i3 ], %o0                             
40005f70:	92 10 00 1d 	mov  %i5, %o1                                  
40005f74:	7f ff fe 3e 	call  4000586c <oproc>                         
40005f78:	90 0a 20 ff 	and  %o0, 0xff, %o0                            
    return sc;                                                        
  }                                                                   
  if (tty->termios.c_oflag & OPOST) {                                 
    uint32_t   count = args->count;                                   
    char      *buffer = args->buffer;                                 
    while (count--)                                                   
40005f7c:	b8 87 3f ff 	addcc  %i4, -1, %i4                            
40005f80:	12 bf ff fb 	bne  40005f6c <rtems_termios_write+0x84>       
40005f84:	b6 06 e0 01 	inc  %i3                                       
      oproc (*buffer++, tty);                                         
    args->bytes_moved = args->count;                                  
  } else {                                                            
    rtems_termios_puts (args->buffer, args->count, tty);              
    args->bytes_moved = args->count;                                  
40005f88:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
  }                                                                   
  rtems_semaphore_release (tty->osem);                                
40005f8c:	d0 07 60 18 	ld  [ %i5 + 0x18 ], %o0                        
    while (count--)                                                   
      oproc (*buffer++, tty);                                         
    args->bytes_moved = args->count;                                  
  } else {                                                            
    rtems_termios_puts (args->buffer, args->count, tty);              
    args->bytes_moved = args->count;                                  
40005f90:	c2 26 20 1c 	st  %g1, [ %i0 + 0x1c ]                        
  }                                                                   
  rtems_semaphore_release (tty->osem);                                
40005f94:	40 00 05 4d 	call  400074c8 <rtems_semaphore_release>       
40005f98:	b0 10 00 1a 	mov  %i2, %i0                                  
  return sc;                                                          
}                                                                     
40005f9c:	81 c7 e0 08 	ret                                            
40005fa0:	81 e8 00 00 	restore                                        
    char      *buffer = args->buffer;                                 
    while (count--)                                                   
      oproc (*buffer++, tty);                                         
    args->bytes_moved = args->count;                                  
  } else {                                                            
    rtems_termios_puts (args->buffer, args->count, tty);              
40005fa4:	7f ff fd e2 	call  4000572c <rtems_termios_puts>            <== NOT EXECUTED
40005fa8:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
    args->bytes_moved = args->count;                                  
40005fac:	10 bf ff f8 	b  40005f8c <rtems_termios_write+0xa4>         <== NOT EXECUTED
40005fb0:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        <== NOT EXECUTED
    return sc;                                                        
  }                                                                   
  if (tty->termios.c_oflag & OPOST) {                                 
    uint32_t   count = args->count;                                   
    char      *buffer = args->buffer;                                 
    while (count--)                                                   
40005fb4:	10 bf ff f6 	b  40005f8c <rtems_termios_write+0xa4>         <== NOT EXECUTED
40005fb8:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
                                                                      

4001707c <rtems_timer_cancel>: */ rtems_status_code rtems_timer_cancel( rtems_id id ) {
4001707c:	9d e3 bf 98 	save  %sp, -104, %sp                           
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get (                      
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (Timer_Control *)                                            
40017080:	11 10 00 f7 	sethi  %hi(0x4003dc00), %o0                    
40017084:	92 10 00 18 	mov  %i0, %o1                                  
40017088:	90 12 21 d8 	or  %o0, 0x1d8, %o0                            
4001708c:	40 00 0c fe 	call  4001a484 <_Objects_Get>                  
40017090:	94 07 bf fc 	add  %fp, -4, %o2                              
  Timer_Control   *the_timer;                                         
  Objects_Locations       location;                                   
                                                                      
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
40017094:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40017098:	80 a0 60 00 	cmp  %g1, 0                                    
4001709c:	12 80 00 0c 	bne  400170cc <rtems_timer_cancel+0x50>        
400170a0:	01 00 00 00 	nop                                            
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( !_Timer_Is_dormant_class( the_timer->the_class ) )         
400170a4:	c2 02 20 38 	ld  [ %o0 + 0x38 ], %g1                        
400170a8:	80 a0 60 04 	cmp  %g1, 4                                    
400170ac:	02 80 00 04 	be  400170bc <rtems_timer_cancel+0x40>         <== NEVER TAKEN
400170b0:	01 00 00 00 	nop                                            
        (void) _Watchdog_Remove( &the_timer->Ticker );                
400170b4:	40 00 14 ec 	call  4001c464 <_Watchdog_Remove>              
400170b8:	90 02 20 10 	add  %o0, 0x10, %o0                            
      _Thread_Enable_dispatch();                                      
400170bc:	40 00 10 d5 	call  4001b410 <_Thread_Enable_dispatch>       
400170c0:	b0 10 20 00 	clr  %i0                                       
400170c4:	81 c7 e0 08 	ret                                            
400170c8:	81 e8 00 00 	restore                                        
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
400170cc:	81 c7 e0 08 	ret                                            
400170d0:	91 e8 20 04 	restore  %g0, 4, %o0                           
                                                                      

400175d4 <rtems_timer_server_fire_when>: rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) {
400175d4:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Timer_Control        *the_timer;                                    
  Objects_Locations     location;                                     
  rtems_interval        seconds;                                      
  Timer_server_Control *timer_server = _Timer_server;                 
400175d8:	03 10 00 f7 	sethi  %hi(0x4003dc00), %g1                    
400175dc:	fa 00 62 18 	ld  [ %g1 + 0x218 ], %i5	! 4003de18 <_Timer_server>
                                                                      
  if ( !timer_server )                                                
400175e0:	80 a7 60 00 	cmp  %i5, 0                                    
400175e4:	02 80 00 08 	be  40017604 <rtems_timer_server_fire_when+0x30>
400175e8:	82 10 20 0e 	mov  0xe, %g1                                  
    return RTEMS_INCORRECT_STATE;                                     
                                                                      
  if ( !_TOD.is_set )                                                 
400175ec:	39 10 00 f4 	sethi  %hi(0x4003d000), %i4                    
400175f0:	82 17 23 b8 	or  %i4, 0x3b8, %g1	! 4003d3b8 <_TOD>          
400175f4:	c4 08 60 14 	ldub  [ %g1 + 0x14 ], %g2                      
400175f8:	80 a0 a0 00 	cmp  %g2, 0                                    
400175fc:	12 80 00 04 	bne  4001760c <rtems_timer_server_fire_when+0x38><== ALWAYS TAKEN
40017600:	82 10 20 0b 	mov  0xb, %g1                                  
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
40017604:	81 c7 e0 08 	ret                                            
40017608:	91 e8 00 01 	restore  %g0, %g1, %o0                         
    return RTEMS_INCORRECT_STATE;                                     
                                                                      
  if ( !_TOD.is_set )                                                 
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( !routine )                                                     
4001760c:	80 a6 a0 00 	cmp  %i2, 0                                    
40017610:	02 bf ff fd 	be  40017604 <rtems_timer_server_fire_when+0x30>
40017614:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !_TOD_Validate( wall_time ) )                                  
40017618:	7f ff f3 1e 	call  40014290 <_TOD_Validate>                 
4001761c:	90 10 00 19 	mov  %i1, %o0                                  
40017620:	80 8a 20 ff 	btst  0xff, %o0                                
40017624:	12 80 00 04 	bne  40017634 <rtems_timer_server_fire_when+0x60>
40017628:	82 10 20 14 	mov  0x14, %g1                                 
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
4001762c:	81 c7 e0 08 	ret                                            
40017630:	91 e8 00 01 	restore  %g0, %g1, %o0                         
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !_TOD_Validate( wall_time ) )                                  
    return RTEMS_INVALID_CLOCK;                                       
                                                                      
  seconds = _TOD_To_seconds( wall_time );                             
40017634:	7f ff f2 dd 	call  400141a8 <_TOD_To_seconds>               
40017638:	90 10 00 19 	mov  %i1, %o0                                  
4001763c:	b2 10 00 08 	mov  %o0, %i1                                  
40017640:	d0 1f 23 b8 	ldd  [ %i4 + 0x3b8 ], %o0                      
40017644:	94 10 20 00 	clr  %o2                                       
40017648:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
4001764c:	40 00 52 36 	call  4002bf24 <__divdi3>                      
40017650:	96 12 e2 00 	or  %o3, 0x200, %o3	! 3b9aca00 <RAM_SIZE+0x3b5aca00>
  if ( seconds <= _TOD_Seconds_since_epoch() )                        
40017654:	80 a6 40 09 	cmp  %i1, %o1                                  
40017658:	08 bf ff f5 	bleu  4001762c <rtems_timer_server_fire_when+0x58>
4001765c:	82 10 20 14 	mov  0x14, %g1                                 
40017660:	92 10 00 18 	mov  %i0, %o1                                  
40017664:	11 10 00 f7 	sethi  %hi(0x4003dc00), %o0                    
40017668:	94 07 bf fc 	add  %fp, -4, %o2                              
4001766c:	40 00 0b 86 	call  4001a484 <_Objects_Get>                  
40017670:	90 12 21 d8 	or  %o0, 0x1d8, %o0                            
    return RTEMS_INVALID_CLOCK;                                       
                                                                      
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
40017674:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40017678:	80 a0 60 00 	cmp  %g1, 0                                    
4001767c:	12 80 00 19 	bne  400176e0 <rtems_timer_server_fire_when+0x10c>
40017680:	a0 10 00 08 	mov  %o0, %l0                                  
                                                                      
    case OBJECTS_LOCAL:                                               
      (void) _Watchdog_Remove( &the_timer->Ticker );                  
40017684:	40 00 13 78 	call  4001c464 <_Watchdog_Remove>              
40017688:	90 02 20 10 	add  %o0, 0x10, %o0                            
4001768c:	d0 1f 23 b8 	ldd  [ %i4 + 0x3b8 ], %o0                      
      the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;               
40017690:	82 10 20 03 	mov  3, %g1                                    
40017694:	94 10 20 00 	clr  %o2                                       
40017698:	c2 24 20 38 	st  %g1, [ %l0 + 0x38 ]                        
4001769c:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
400176a0:	c0 24 20 18 	clr  [ %l0 + 0x18 ]                            
400176a4:	96 12 e2 00 	or  %o3, 0x200, %o3                            
  the_watchdog->routine   = routine;                                  
400176a8:	f4 24 20 2c 	st  %i2, [ %l0 + 0x2c ]                        
  the_watchdog->id        = id;                                       
400176ac:	f0 24 20 30 	st  %i0, [ %l0 + 0x30 ]                        
400176b0:	40 00 52 1d 	call  4002bf24 <__divdi3>                      
400176b4:	f6 24 20 34 	st  %i3, [ %l0 + 0x34 ]                        
      _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
      the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
                                                                      
      (*timer_server->schedule_operation)( timer_server, the_timer ); 
400176b8:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
                                                                      
    case OBJECTS_LOCAL:                                               
      (void) _Watchdog_Remove( &the_timer->Ticker );                  
      the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;               
      _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
      the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
400176bc:	b2 26 40 09 	sub  %i1, %o1, %i1                             
                                                                      
      (*timer_server->schedule_operation)( timer_server, the_timer ); 
400176c0:	90 10 00 1d 	mov  %i5, %o0                                  
400176c4:	92 10 00 10 	mov  %l0, %o1                                  
400176c8:	9f c0 40 00 	call  %g1                                      
400176cc:	f2 24 20 1c 	st  %i1, [ %l0 + 0x1c ]                        
                                                                      
      _Thread_Enable_dispatch();                                      
400176d0:	40 00 0f 50 	call  4001b410 <_Thread_Enable_dispatch>       
400176d4:	01 00 00 00 	nop                                            
      return RTEMS_SUCCESSFUL;                                        
400176d8:	10 bf ff cb 	b  40017604 <rtems_timer_server_fire_when+0x30>
400176dc:	82 10 20 00 	clr  %g1	! 0 <PROM_START>                      
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
400176e0:	10 bf ff c9 	b  40017604 <rtems_timer_server_fire_when+0x30>
400176e4:	82 10 20 04 	mov  4, %g1                                    
                                                                      

40002dd8 <rtems_verror>: static int rtems_verror( rtems_error_code_t error_flag, const char *printf_format, va_list arglist ) {
40002dd8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int               local_errno = 0;                                  
  int               chars_written = 0;                                
  rtems_status_code status;                                           
                                                                      
  if (error_flag & RTEMS_ERROR_PANIC) {                               
40002ddc:	03 08 00 00 	sethi  %hi(0x20000000), %g1                    
40002de0:	80 8e 00 01 	btst  %i0, %g1                                 
40002de4:	02 80 00 10 	be  40002e24 <rtems_verror+0x4c>               
40002de8:	b8 10 00 18 	mov  %i0, %i4                                  
    if (rtems_panic_in_progress++)                                    
40002dec:	05 10 00 7b 	sethi  %hi(0x4001ec00), %g2                    
40002df0:	c6 00 a1 2c 	ld  [ %g2 + 0x12c ], %g3	! 4001ed2c <rtems_panic_in_progress>
40002df4:	82 00 e0 01 	add  %g3, 1, %g1                               
40002df8:	80 a0 e0 00 	cmp  %g3, 0                                    
40002dfc:	02 80 00 07 	be  40002e18 <rtems_verror+0x40>               <== ALWAYS TAKEN
40002e00:	c2 20 a1 2c 	st  %g1, [ %g2 + 0x12c ]                       
   *                                                                  
   * This rountine increments the thread dispatch level               
   */                                                                 
  RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
  {                                                                   
    uint32_t level = _Thread_Dispatch_disable_level;                  
40002e04:	03 10 00 7b 	sethi  %hi(0x4001ec00), %g1                    <== NOT EXECUTED
40002e08:	c6 00 62 c0 	ld  [ %g1 + 0x2c0 ], %g3	! 4001eec0 <_Thread_Dispatch_disable_level><== NOT EXECUTED
                                                                      
    ++level;                                                          
40002e0c:	86 00 e0 01 	inc  %g3                                       <== NOT EXECUTED
    _Thread_Dispatch_disable_level = level;                           
40002e10:	c6 20 62 c0 	st  %g3, [ %g1 + 0x2c0 ]                       <== NOT EXECUTED
void _Thread_Disable_dispatch( void );                                
#else                                                                 
RTEMS_INLINE_ROUTINE void _Thread_Disable_dispatch( void )            
{                                                                     
  _Thread_Dispatch_increment_disable_level();                         
  RTEMS_COMPILER_MEMORY_BARRIER();                                    
40002e14:	c2 00 a1 2c 	ld  [ %g2 + 0x12c ], %g1                       <== NOT EXECUTED
      _Thread_Disable_dispatch();       /* disable task switches */   
                                                                      
    /* don't aggravate things */                                      
    if (rtems_panic_in_progress > 2)                                  
40002e18:	80 a0 60 02 	cmp  %g1, 2                                    
40002e1c:	14 80 00 30 	bg  40002edc <rtems_verror+0x104>              <== NEVER TAKEN
40002e20:	b0 10 20 00 	clr  %i0                                       
      return 0;                                                       
  }                                                                   
                                                                      
  (void) fflush(stdout);            /* in case stdout/stderr same */  
40002e24:	3b 10 00 79 	sethi  %hi(0x4001e400), %i5                    
40002e28:	c2 07 61 68 	ld  [ %i5 + 0x168 ], %g1	! 4001e568 <_impure_ptr>
                                                                      
  status = error_flag & ~RTEMS_ERROR_MASK;                            
40002e2c:	37 1c 00 00 	sethi  %hi(0x70000000), %i3                    
    /* don't aggravate things */                                      
    if (rtems_panic_in_progress > 2)                                  
      return 0;                                                       
  }                                                                   
                                                                      
  (void) fflush(stdout);            /* in case stdout/stderr same */  
40002e30:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           
40002e34:	40 00 33 46 	call  4000fb4c <fflush>                        
40002e38:	b6 2f 00 1b 	andn  %i4, %i3, %i3                            
                                                                      
  status = error_flag & ~RTEMS_ERROR_MASK;                            
  if (error_flag & RTEMS_ERROR_ERRNO)     /* include errno? */        
40002e3c:	03 10 00 00 	sethi  %hi(0x40000000), %g1                    
40002e40:	80 8f 00 01 	btst  %i4, %g1                                 
40002e44:	12 80 00 34 	bne  40002f14 <rtems_verror+0x13c>             
40002e48:	01 00 00 00 	nop                                            
  rtems_error_code_t  error_flag,                                     
  const char         *printf_format,                                  
  va_list             arglist                                         
)                                                                     
{                                                                     
  int               local_errno = 0;                                  
40002e4c:	b8 10 20 00 	clr  %i4	! 0 <PROM_START>                      
  #if defined(RTEMS_MULTIPROCESSING)                                  
    if (_System_state_Is_multiprocessing)                             
      fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node);
  #endif                                                              
                                                                      
  chars_written += vfprintf(stderr, printf_format, arglist);          
40002e50:	c2 07 61 68 	ld  [ %i5 + 0x168 ], %g1                       
40002e54:	92 10 00 19 	mov  %i1, %o1                                  
40002e58:	d0 00 60 0c 	ld  [ %g1 + 0xc ], %o0                         
40002e5c:	40 00 47 b2 	call  40014d24 <vfprintf>                      
40002e60:	94 10 00 1a 	mov  %i2, %o2                                  
                                                                      
  if (status)                                                         
40002e64:	80 a6 e0 00 	cmp  %i3, 0                                    
40002e68:	12 80 00 1f 	bne  40002ee4 <rtems_verror+0x10c>             
40002e6c:	b0 10 00 08 	mov  %o0, %i0                                  
    chars_written +=                                                  
      fprintf(stderr, " (status: %s)", rtems_status_text(status));    
                                                                      
  if (local_errno) {                                                  
40002e70:	80 a7 20 00 	cmp  %i4, 0                                    
40002e74:	02 80 00 12 	be  40002ebc <rtems_verror+0xe4>               
40002e78:	c2 07 61 68 	ld  [ %i5 + 0x168 ], %g1                       
    if ((local_errno > 0) && *strerror(local_errno))                  
40002e7c:	80 a7 20 00 	cmp  %i4, 0                                    
40002e80:	04 80 00 09 	ble  40002ea4 <rtems_verror+0xcc>              
40002e84:	13 10 00 72 	sethi  %hi(0x4001c800), %o1                    
40002e88:	40 00 37 8b 	call  40010cb4 <strerror>                      
40002e8c:	90 10 00 1c 	mov  %i4, %o0                                  
40002e90:	c2 4a 00 00 	ldsb  [ %o0 ], %g1                             
40002e94:	80 a0 60 00 	cmp  %g1, 0                                    
40002e98:	12 80 00 23 	bne  40002f24 <rtems_verror+0x14c>             <== ALWAYS TAKEN
40002e9c:	c2 07 61 68 	ld  [ %i5 + 0x168 ], %g1                       
      chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
    else                                                              
      chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
40002ea0:	13 10 00 72 	sethi  %hi(0x4001c800), %o1                    <== NOT EXECUTED
40002ea4:	d0 00 60 0c 	ld  [ %g1 + 0xc ], %o0                         
40002ea8:	92 12 61 f0 	or  %o1, 0x1f0, %o1                            
40002eac:	40 00 34 24 	call  4000ff3c <fprintf>                       
40002eb0:	94 10 00 1c 	mov  %i4, %o2                                  
40002eb4:	b0 06 00 08 	add  %i0, %o0, %i0                             
  }                                                                   
                                                                      
  chars_written += fprintf(stderr, "\n");                             
40002eb8:	c2 07 61 68 	ld  [ %i5 + 0x168 ], %g1                       
40002ebc:	13 10 00 72 	sethi  %hi(0x4001c800), %o1                    
40002ec0:	d0 00 60 0c 	ld  [ %g1 + 0xc ], %o0                         
40002ec4:	40 00 34 1e 	call  4000ff3c <fprintf>                       
40002ec8:	92 12 62 08 	or  %o1, 0x208, %o1                            
                                                                      
  (void) fflush(stderr);                                              
40002ecc:	c2 07 61 68 	ld  [ %i5 + 0x168 ], %g1                       
      chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
    else                                                              
      chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
  }                                                                   
                                                                      
  chars_written += fprintf(stderr, "\n");                             
40002ed0:	b0 02 00 18 	add  %o0, %i0, %i0                             
                                                                      
  (void) fflush(stderr);                                              
40002ed4:	40 00 33 1e 	call  4000fb4c <fflush>                        
40002ed8:	d0 00 60 0c 	ld  [ %g1 + 0xc ], %o0                         
                                                                      
  return chars_written;                                               
}                                                                     
40002edc:	81 c7 e0 08 	ret                                            
40002ee0:	81 e8 00 00 	restore                                        
                                                                      
  chars_written += vfprintf(stderr, printf_format, arglist);          
                                                                      
  if (status)                                                         
    chars_written +=                                                  
      fprintf(stderr, " (status: %s)", rtems_status_text(status));    
40002ee4:	03 10 00 79 	sethi  %hi(0x4001e400), %g1                    
40002ee8:	c2 00 61 68 	ld  [ %g1 + 0x168 ], %g1	! 4001e568 <_impure_ptr>
40002eec:	90 10 00 1b 	mov  %i3, %o0                                  
40002ef0:	7f ff ff b4 	call  40002dc0 <rtems_status_text>             
40002ef4:	f6 00 60 0c 	ld  [ %g1 + 0xc ], %i3                         
40002ef8:	13 10 00 72 	sethi  %hi(0x4001c800), %o1                    
40002efc:	94 10 00 08 	mov  %o0, %o2                                  
40002f00:	92 12 61 d0 	or  %o1, 0x1d0, %o1                            
40002f04:	40 00 34 0e 	call  4000ff3c <fprintf>                       
40002f08:	90 10 00 1b 	mov  %i3, %o0                                  
  #endif                                                              
                                                                      
  chars_written += vfprintf(stderr, printf_format, arglist);          
                                                                      
  if (status)                                                         
    chars_written +=                                                  
40002f0c:	10 bf ff d9 	b  40002e70 <rtems_verror+0x98>                
40002f10:	b0 06 00 08 	add  %i0, %o0, %i0                             
                                                                      
  (void) fflush(stdout);            /* in case stdout/stderr same */  
                                                                      
  status = error_flag & ~RTEMS_ERROR_MASK;                            
  if (error_flag & RTEMS_ERROR_ERRNO)     /* include errno? */        
    local_errno = errno;                                              
40002f14:	40 00 32 0b 	call  4000f740 <__errno>                       
40002f18:	01 00 00 00 	nop                                            
40002f1c:	10 bf ff cd 	b  40002e50 <rtems_verror+0x78>                
40002f20:	f8 02 00 00 	ld  [ %o0 ], %i4                               
    chars_written +=                                                  
      fprintf(stderr, " (status: %s)", rtems_status_text(status));    
                                                                      
  if (local_errno) {                                                  
    if ((local_errno > 0) && *strerror(local_errno))                  
      chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
40002f24:	90 10 00 1c 	mov  %i4, %o0                                  
40002f28:	40 00 37 63 	call  40010cb4 <strerror>                      
40002f2c:	f8 00 60 0c 	ld  [ %g1 + 0xc ], %i4                         
40002f30:	13 10 00 72 	sethi  %hi(0x4001c800), %o1                    
40002f34:	94 10 00 08 	mov  %o0, %o2                                  
40002f38:	92 12 61 e0 	or  %o1, 0x1e0, %o1                            
40002f3c:	40 00 34 00 	call  4000ff3c <fprintf>                       
40002f40:	90 10 00 1c 	mov  %i4, %o0                                  
40002f44:	10 bf ff dd 	b  40002eb8 <rtems_verror+0xe0>                
40002f48:	b0 06 00 08 	add  %i0, %o0, %i0                             
                                                                      

40026cfc <scanInt>: /** * Extract an integer value from the database */ static int scanInt(FILE *fp, int *val) {
40026cfc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int c;                                                              
  unsigned int i = 0;                                                 
  unsigned int limit = INT_MAX;                                       
40026d00:	35 1f ff ff 	sethi  %hi(0x7ffffc00), %i2                    
  int sign = 0;                                                       
40026d04:	b6 10 20 00 	clr  %i3                                       
static int                                                            
scanInt(FILE *fp, int *val)                                           
{                                                                     
  int c;                                                              
  unsigned int i = 0;                                                 
  unsigned int limit = INT_MAX;                                       
40026d08:	b4 16 a3 ff 	or  %i2, 0x3ff, %i2                            
 */                                                                   
static int                                                            
scanInt(FILE *fp, int *val)                                           
{                                                                     
  int c;                                                              
  unsigned int i = 0;                                                 
40026d0c:	ba 10 20 00 	clr  %i5                                       
  unsigned int limit = INT_MAX;                                       
  int sign = 0;                                                       
  int d;                                                              
                                                                      
  for (;;) {                                                          
    c = getc(fp);                                                     
40026d10:	23 10 01 92 	sethi  %hi(0x40064800), %l1                    
        limit++;                                                      
        continue;                                                     
      }                                                               
      sign = 1;                                                       
    }                                                                 
    if (!isdigit(c))                                                  
40026d14:	21 10 01 92 	sethi  %hi(0x40064800), %l0                    
  unsigned int limit = INT_MAX;                                       
  int sign = 0;                                                       
  int d;                                                              
                                                                      
  for (;;) {                                                          
    c = getc(fp);                                                     
40026d18:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
40026d1c:	82 00 7f ff 	add  %g1, -1, %g1                              
40026d20:	80 a0 60 00 	cmp  %g1, 0                                    
40026d24:	06 80 00 26 	bl  40026dbc <scanInt+0xc0>                    <== NEVER TAKEN
40026d28:	c2 26 20 04 	st  %g1, [ %i0 + 4 ]                           
40026d2c:	c4 06 00 00 	ld  [ %i0 ], %g2                               
40026d30:	d0 08 80 00 	ldub  [ %g2 ], %o0                             
40026d34:	84 00 a0 01 	inc  %g2                                       
    if (c == ':')                                                     
40026d38:	80 a2 20 3a 	cmp  %o0, 0x3a                                 
40026d3c:	02 80 00 26 	be  40026dd4 <scanInt+0xd8>                    
40026d40:	c4 26 00 00 	st  %g2, [ %i0 ]                               
      break;                                                          
    if (sign == 0) {                                                  
40026d44:	80 a6 e0 00 	cmp  %i3, 0                                    
40026d48:	32 80 00 06 	bne,a   40026d60 <scanInt+0x64>                
40026d4c:	c4 04 23 b0 	ld  [ %l0 + 0x3b0 ], %g2                       
      if (c == '-') {                                                 
40026d50:	80 a2 20 2d 	cmp  %o0, 0x2d                                 
40026d54:	02 80 00 32 	be  40026e1c <scanInt+0x120>                   
40026d58:	b6 10 20 01 	mov  1, %i3                                    
        limit++;                                                      
        continue;                                                     
      }                                                               
      sign = 1;                                                       
    }                                                                 
    if (!isdigit(c))                                                  
40026d5c:	c4 04 23 b0 	ld  [ %l0 + 0x3b0 ], %g2                       
40026d60:	84 00 80 08 	add  %g2, %o0, %g2                             
40026d64:	c4 08 a0 01 	ldub  [ %g2 + 1 ], %g2                         
40026d68:	80 88 a0 04 	btst  4, %g2                                   
40026d6c:	22 80 00 22 	be,a   40026df4 <scanInt+0xf8>                 
40026d70:	b0 10 20 00 	clr  %i0                                       
      return 0;                                                       
    d = c - '0';                                                      
40026d74:	b8 02 3f d0 	add  %o0, -48, %i4                             
    if ((i > (limit / 10))                                            
40026d78:	92 10 20 0a 	mov  0xa, %o1                                  
40026d7c:	40 00 b8 b0 	call  4005503c <.udiv>                         
40026d80:	90 10 00 1a 	mov  %i2, %o0                                  
40026d84:	80 a7 40 08 	cmp  %i5, %o0                                  
40026d88:	38 80 00 1b 	bgu,a   40026df4 <scanInt+0xf8>                
40026d8c:	b0 10 20 00 	clr  %i0                                       
     || ((i == (limit / 10)) && (d > (limit % 10))))                  
40026d90:	02 80 00 1b 	be  40026dfc <scanInt+0x100>                   
40026d94:	90 10 00 1a 	mov  %i2, %o0                                  
      return 0;                                                       
    i = i * 10 + d;                                                   
40026d98:	83 2f 60 01 	sll  %i5, 1, %g1                               
40026d9c:	bb 2f 60 03 	sll  %i5, 3, %i5                               
40026da0:	ba 00 40 1d 	add  %g1, %i5, %i5                             
  unsigned int limit = INT_MAX;                                       
  int sign = 0;                                                       
  int d;                                                              
                                                                      
  for (;;) {                                                          
    c = getc(fp);                                                     
40026da4:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
      return 0;                                                       
    d = c - '0';                                                      
    if ((i > (limit / 10))                                            
     || ((i == (limit / 10)) && (d > (limit % 10))))                  
      return 0;                                                       
    i = i * 10 + d;                                                   
40026da8:	ba 07 00 1d 	add  %i4, %i5, %i5                             
  unsigned int limit = INT_MAX;                                       
  int sign = 0;                                                       
  int d;                                                              
                                                                      
  for (;;) {                                                          
    c = getc(fp);                                                     
40026dac:	82 00 7f ff 	add  %g1, -1, %g1                              
40026db0:	80 a0 60 00 	cmp  %g1, 0                                    
40026db4:	16 bf ff de 	bge  40026d2c <scanInt+0x30>                   <== ALWAYS TAKEN
40026db8:	c2 26 20 04 	st  %g1, [ %i0 + 4 ]                           
40026dbc:	d0 04 63 c0 	ld  [ %l1 + 0x3c0 ], %o0                       <== NOT EXECUTED
40026dc0:	40 00 68 60 	call  40040f40 <__srget_r>                     <== NOT EXECUTED
40026dc4:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
    if (c == ':')                                                     
40026dc8:	80 a2 20 3a 	cmp  %o0, 0x3a                                 <== NOT EXECUTED
40026dcc:	12 bf ff df 	bne  40026d48 <scanInt+0x4c>                   <== NOT EXECUTED
40026dd0:	80 a6 e0 00 	cmp  %i3, 0                                    <== NOT EXECUTED
    if ((i > (limit / 10))                                            
     || ((i == (limit / 10)) && (d > (limit % 10))))                  
      return 0;                                                       
    i = i * 10 + d;                                                   
  }                                                                   
  if (sign == 0)                                                      
40026dd4:	80 a6 e0 00 	cmp  %i3, 0                                    
40026dd8:	02 80 00 07 	be  40026df4 <scanInt+0xf8>                    <== NEVER TAKEN
40026ddc:	b0 10 20 00 	clr  %i0                                       
    return 0;                                                         
  *val = i * sign;                                                    
40026de0:	90 10 00 1b 	mov  %i3, %o0                                  
40026de4:	92 10 00 1d 	mov  %i5, %o1                                  
40026de8:	40 00 b8 5b 	call  40054f54 <.umul>                         
40026dec:	b0 10 20 01 	mov  1, %i0                                    
40026df0:	d0 26 40 00 	st  %o0, [ %i1 ]                               
  return 1;                                                           
40026df4:	81 c7 e0 08 	ret                                            
40026df8:	81 e8 00 00 	restore                                        
    }                                                                 
    if (!isdigit(c))                                                  
      return 0;                                                       
    d = c - '0';                                                      
    if ((i > (limit / 10))                                            
     || ((i == (limit / 10)) && (d > (limit % 10))))                  
40026dfc:	40 00 b9 3c 	call  400552ec <.urem>                         
40026e00:	92 10 20 0a 	mov  0xa, %o1                                  
40026e04:	80 a7 00 08 	cmp  %i4, %o0                                  
40026e08:	08 bf ff e5 	bleu  40026d9c <scanInt+0xa0>                  <== NEVER TAKEN
40026e0c:	83 2f 60 01 	sll  %i5, 1, %g1                               
        continue;                                                     
      }                                                               
      sign = 1;                                                       
    }                                                                 
    if (!isdigit(c))                                                  
      return 0;                                                       
40026e10:	b0 10 20 00 	clr  %i0                                       
  }                                                                   
  if (sign == 0)                                                      
    return 0;                                                         
  *val = i * sign;                                                    
  return 1;                                                           
}                                                                     
40026e14:	81 c7 e0 08 	ret                                            
40026e18:	81 e8 00 00 	restore                                        
    if (c == ':')                                                     
      break;                                                          
    if (sign == 0) {                                                  
      if (c == '-') {                                                 
        sign = -1;                                                    
        limit++;                                                      
40026e1c:	b4 06 a0 01 	inc  %i2                                       
        continue;                                                     
40026e20:	10 bf ff be 	b  40026d18 <scanInt+0x1c>                     
40026e24:	b6 10 3f ff 	mov  -1, %i3                                   
                                                                      

40026e28 <scanString>: /** * Extract a string value from the database */ static int scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag) {
40026e28:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int c;                                                              
                                                                      
  *name = *bufp;                                                      
40026e2c:	c2 06 80 00 	ld  [ %i2 ], %g1                               
  for (;;) {                                                          
    c = getc(fp);                                                     
40026e30:	3b 10 01 92 	sethi  %hi(0x40064800), %i5                    
static int                                                            
scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag)
{                                                                     
  int c;                                                              
                                                                      
  *name = *bufp;                                                      
40026e34:	10 80 00 19 	b  40026e98 <scanString+0x70>                  
40026e38:	c2 26 40 00 	st  %g1, [ %i1 ]                               
  for (;;) {                                                          
    c = getc(fp);                                                     
40026e3c:	c2 06 00 00 	ld  [ %i0 ], %g1                               
40026e40:	d0 08 40 00 	ldub  [ %g1 ], %o0                             
40026e44:	82 00 60 01 	inc  %g1                                       
    if (c == ':') {                                                   
40026e48:	80 a2 20 3a 	cmp  %o0, 0x3a                                 
40026e4c:	02 80 00 1e 	be  40026ec4 <scanString+0x9c>                 
40026e50:	c2 26 00 00 	st  %g1, [ %i0 ]                               
        if (nlFlag)                                                   
            return 0;                                                 
        break;                                                        
    }                                                                 
    if (c == '\n') {                                                  
40026e54:	80 a2 20 0a 	cmp  %o0, 0xa                                  
40026e58:	02 80 00 2a 	be  40026f00 <scanString+0xd8>                 
40026e5c:	80 a2 3f ff 	cmp  %o0, -1                                   
        if (!nlFlag)                                                  
            return 0;                                                 
        break;                                                        
    }                                                                 
    if (c == EOF)                                                     
40026e60:	02 80 00 26 	be  40026ef8 <scanString+0xd0>                 
40026e64:	01 00 00 00 	nop                                            
      return 0;                                                       
    if (*nleft < 2)                                                   
40026e68:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
40026e6c:	80 a0 60 01 	cmp  %g1, 1                                    
40026e70:	08 80 00 22 	bleu  40026ef8 <scanString+0xd0>               
40026e74:	01 00 00 00 	nop                                            
      return 0;                                                       
    **bufp = c;                                                       
40026e78:	c2 06 80 00 	ld  [ %i2 ], %g1                               
40026e7c:	d0 28 40 00 	stb  %o0, [ %g1 ]                              
    ++(*bufp);                                                        
40026e80:	c4 06 80 00 	ld  [ %i2 ], %g2                               
    --(*nleft);                                                       
40026e84:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
    if (c == EOF)                                                     
      return 0;                                                       
    if (*nleft < 2)                                                   
      return 0;                                                       
    **bufp = c;                                                       
    ++(*bufp);                                                        
40026e88:	84 00 a0 01 	inc  %g2                                       
40026e8c:	c4 26 80 00 	st  %g2, [ %i2 ]                               
    --(*nleft);                                                       
40026e90:	82 00 7f ff 	add  %g1, -1, %g1                              
40026e94:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
{                                                                     
  int c;                                                              
                                                                      
  *name = *bufp;                                                      
  for (;;) {                                                          
    c = getc(fp);                                                     
40026e98:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
40026e9c:	82 00 7f ff 	add  %g1, -1, %g1                              
40026ea0:	80 a0 60 00 	cmp  %g1, 0                                    
40026ea4:	16 bf ff e6 	bge  40026e3c <scanString+0x14>                
40026ea8:	c2 26 20 04 	st  %g1, [ %i0 + 4 ]                           
40026eac:	d0 07 63 c0 	ld  [ %i5 + 0x3c0 ], %o0                       
40026eb0:	40 00 68 24 	call  40040f40 <__srget_r>                     
40026eb4:	92 10 00 18 	mov  %i0, %o1                                  
    if (c == ':') {                                                   
40026eb8:	80 a2 20 3a 	cmp  %o0, 0x3a                                 
40026ebc:	12 bf ff e7 	bne  40026e58 <scanString+0x30>                <== ALWAYS TAKEN
40026ec0:	80 a2 20 0a 	cmp  %o0, 0xa                                  
        if (nlFlag)                                                   
40026ec4:	80 a7 20 00 	cmp  %i4, 0                                    
40026ec8:	12 80 00 11 	bne  40026f0c <scanString+0xe4>                
40026ecc:	b0 10 20 00 	clr  %i0                                       
      return 0;                                                       
    **bufp = c;                                                       
    ++(*bufp);                                                        
    --(*nleft);                                                       
  }                                                                   
  **bufp = '\0';                                                      
40026ed0:	c2 06 80 00 	ld  [ %i2 ], %g1                               
40026ed4:	c0 28 40 00 	clrb  [ %g1 ]                                  
  ++(*bufp);                                                          
40026ed8:	c4 06 80 00 	ld  [ %i2 ], %g2                               
  --(*nleft);                                                         
40026edc:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
    **bufp = c;                                                       
    ++(*bufp);                                                        
    --(*nleft);                                                       
  }                                                                   
  **bufp = '\0';                                                      
  ++(*bufp);                                                          
40026ee0:	84 00 a0 01 	inc  %g2                                       
40026ee4:	c4 26 80 00 	st  %g2, [ %i2 ]                               
  --(*nleft);                                                         
40026ee8:	82 00 7f ff 	add  %g1, -1, %g1                              
40026eec:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
  return 1;                                                           
40026ef0:	81 c7 e0 08 	ret                                            
40026ef4:	91 e8 20 01 	restore  %g0, 1, %o0                           
}                                                                     
40026ef8:	81 c7 e0 08 	ret                                            
40026efc:	91 e8 20 00 	restore  %g0, 0, %o0                           
        if (nlFlag)                                                   
            return 0;                                                 
        break;                                                        
    }                                                                 
    if (c == '\n') {                                                  
        if (!nlFlag)                                                  
40026f00:	80 a7 20 00 	cmp  %i4, 0                                    
40026f04:	12 bf ff f3 	bne  40026ed0 <scanString+0xa8>                
40026f08:	b0 10 20 00 	clr  %i0                                       
40026f0c:	81 c7 e0 08 	ret                                            
40026f10:	81 e8 00 00 	restore                                        
                                                                      

40026f14 <scangr>: FILE *fp, struct group *grp, char *buffer, size_t bufsize ) {
40026f14:	9d e3 bf 98 	save  %sp, -104, %sp                           
  int grgid;                                                          
  char *grmem, *cp;                                                   
  int memcount;                                                       
                                                                      
  if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)            
40026f18:	98 10 20 00 	clr  %o4                                       
  FILE *fp,                                                           
  struct group *grp,                                                  
  char *buffer,                                                       
  size_t bufsize                                                      
)                                                                     
{                                                                     
40026f1c:	f4 27 a0 4c 	st  %i2, [ %fp + 0x4c ]                        
40026f20:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]                        
  int grgid;                                                          
  char *grmem, *cp;                                                   
  int memcount;                                                       
                                                                      
  if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)            
40026f24:	90 10 00 18 	mov  %i0, %o0                                  
40026f28:	92 10 00 19 	mov  %i1, %o1                                  
40026f2c:	94 07 a0 4c 	add  %fp, 0x4c, %o2                            
40026f30:	7f ff ff be 	call  40026e28 <scanString>                    
40026f34:	96 07 a0 50 	add  %fp, 0x50, %o3                            
40026f38:	80 a2 20 00 	cmp  %o0, 0                                    
40026f3c:	12 80 00 04 	bne  40026f4c <scangr+0x38>                    
40026f40:	90 10 00 18 	mov  %i0, %o0                                  
   || !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)          
   || !scanInt(fp, &grgid)                                            
   || !scanString(fp, &grmem, &buffer, &bufsize, 1))                  
    return 0;                                                         
40026f44:	81 c7 e0 08 	ret                                            
40026f48:	91 e8 20 00 	restore  %g0, 0, %o0                           
  int grgid;                                                          
  char *grmem, *cp;                                                   
  int memcount;                                                       
                                                                      
  if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)            
   || !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)          
40026f4c:	92 06 60 04 	add  %i1, 4, %o1                               
40026f50:	94 07 a0 4c 	add  %fp, 0x4c, %o2                            
40026f54:	96 07 a0 50 	add  %fp, 0x50, %o3                            
40026f58:	7f ff ff b4 	call  40026e28 <scanString>                    
40026f5c:	98 10 20 00 	clr  %o4                                       
40026f60:	80 a2 20 00 	cmp  %o0, 0                                    
40026f64:	02 bf ff f8 	be  40026f44 <scangr+0x30>                     <== NEVER TAKEN
40026f68:	90 10 00 18 	mov  %i0, %o0                                  
   || !scanInt(fp, &grgid)                                            
40026f6c:	7f ff ff 64 	call  40026cfc <scanInt>                       
40026f70:	92 07 bf f8 	add  %fp, -8, %o1                              
40026f74:	80 a2 20 00 	cmp  %o0, 0                                    
40026f78:	02 bf ff f3 	be  40026f44 <scangr+0x30>                     <== NEVER TAKEN
40026f7c:	90 10 00 18 	mov  %i0, %o0                                  
   || !scanString(fp, &grmem, &buffer, &bufsize, 1))                  
40026f80:	92 07 bf fc 	add  %fp, -4, %o1                              
40026f84:	94 07 a0 4c 	add  %fp, 0x4c, %o2                            
40026f88:	96 07 a0 50 	add  %fp, 0x50, %o3                            
40026f8c:	7f ff ff a7 	call  40026e28 <scanString>                    
40026f90:	98 10 20 01 	mov  1, %o4                                    
40026f94:	80 a2 20 00 	cmp  %o0, 0                                    
40026f98:	02 bf ff eb 	be  40026f44 <scangr+0x30>                     <== NEVER TAKEN
40026f9c:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
  grp->gr_gid = grgid;                                                
                                                                      
  /*                                                                  
   * Determine number of members                                      
   */                                                                 
  for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {                  
40026fa0:	fa 07 bf fc 	ld  [ %fp + -4 ], %i5                          
  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;                                                
40026fa4:	c2 36 60 08 	sth  %g1, [ %i1 + 8 ]                          
                                                                      
  /*                                                                  
   * Determine number of members                                      
   */                                                                 
  for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {                  
40026fa8:	c6 0f 40 00 	ldub  [ %i5 ], %g3                             
40026fac:	83 28 e0 18 	sll  %g3, 0x18, %g1                            
40026fb0:	80 a0 60 00 	cmp  %g1, 0                                    
40026fb4:	02 80 00 10 	be  40026ff4 <scangr+0xe0>                     <== NEVER TAKEN
40026fb8:	88 10 20 17 	mov  0x17, %g4                                 
40026fbc:	84 10 00 1d 	mov  %i5, %g2                                  
40026fc0:	88 10 20 01 	mov  1, %g4                                    
40026fc4:	84 00 a0 01 	inc  %g2                                       
40026fc8:	c6 08 80 00 	ldub  [ %g2 ], %g3                             
    if(*cp == ',')                                                    
40026fcc:	83 38 60 18 	sra  %g1, 0x18, %g1                            
      memcount++;                                                     
40026fd0:	82 18 60 2c 	xor  %g1, 0x2c, %g1                            
40026fd4:	80 a0 00 01 	cmp  %g0, %g1                                  
  grp->gr_gid = grgid;                                                
                                                                      
  /*                                                                  
   * Determine number of members                                      
   */                                                                 
  for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {                  
40026fd8:	83 28 e0 18 	sll  %g3, 0x18, %g1                            
    if(*cp == ',')                                                    
      memcount++;                                                     
40026fdc:	88 61 3f ff 	subx  %g4, -1, %g4                             
  grp->gr_gid = grgid;                                                
                                                                      
  /*                                                                  
   * Determine number of members                                      
   */                                                                 
  for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {                  
40026fe0:	80 a0 60 00 	cmp  %g1, 0                                    
40026fe4:	32 bf ff f9 	bne,a   40026fc8 <scangr+0xb4>                 
40026fe8:	84 00 a0 01 	inc  %g2                                       
40026fec:	89 29 20 02 	sll  %g4, 2, %g4                               
40026ff0:	88 01 20 13 	add  %g4, 0x13, %g4                            
  }                                                                   
                                                                      
  /*                                                                  
   * Hack to produce (hopefully) a suitably-aligned array of pointers 
   */                                                                 
  if (bufsize < (((memcount+1)*sizeof(char *)) + 15))                 
40026ff4:	c2 07 a0 50 	ld  [ %fp + 0x50 ], %g1                        
40026ff8:	80 a0 40 04 	cmp  %g1, %g4                                  
40026ffc:	0a bf ff d2 	bcs  40026f44 <scangr+0x30>                    <== NEVER TAKEN
40027000:	c2 07 a0 4c 	ld  [ %fp + 0x4c ], %g1                        
    return 0;                                                         
  grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);            
40027004:	82 00 60 0f 	add  %g1, 0xf, %g1                             
40027008:	82 08 7f f0 	and  %g1, -16, %g1                             
4002700c:	c2 26 60 0c 	st  %g1, [ %i1 + 0xc ]                         
                                                                      
  /*                                                                  
   * Fill in pointer array                                            
   */                                                                 
  grp->gr_mem[0] = grmem;                                             
40027010:	fa 20 40 00 	st  %i5, [ %g1 ]                               
  for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {                  
40027014:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40027018:	c4 08 40 00 	ldub  [ %g1 ], %g2                             
4002701c:	85 28 a0 18 	sll  %g2, 0x18, %g2                            
40027020:	80 a0 a0 00 	cmp  %g2, 0                                    
40027024:	02 80 00 18 	be  40027084 <scangr+0x170>                    <== NEVER TAKEN
40027028:	82 00 60 01 	inc  %g1                                       
4002702c:	10 80 00 07 	b  40027048 <scangr+0x134>                     
40027030:	86 10 20 01 	mov  1, %g3                                    
40027034:	c4 08 40 00 	ldub  [ %g1 ], %g2                             
40027038:	85 28 a0 18 	sll  %g2, 0x18, %g2                            
4002703c:	80 a0 a0 00 	cmp  %g2, 0                                    
40027040:	02 80 00 0c 	be  40027070 <scangr+0x15c>                    
40027044:	82 00 60 01 	inc  %g1                                       
    if(*cp == ',') {                                                  
40027048:	85 38 a0 18 	sra  %g2, 0x18, %g2                            
4002704c:	80 a0 a0 2c 	cmp  %g2, 0x2c                                 
40027050:	32 bf ff fa 	bne,a   40027038 <scangr+0x124>                
40027054:	c4 08 40 00 	ldub  [ %g1 ], %g2                             
      *cp = '\0';                                                     
40027058:	c0 28 7f ff 	clrb  [ %g1 + -1 ]                             
      grp->gr_mem[memcount++] = cp + 1;                               
4002705c:	c8 06 60 0c 	ld  [ %i1 + 0xc ], %g4                         
40027060:	85 28 e0 02 	sll  %g3, 2, %g2                               
40027064:	86 00 e0 01 	inc  %g3                                       
40027068:	10 bf ff f3 	b  40027034 <scangr+0x120>                     
4002706c:	c2 21 00 02 	st  %g1, [ %g4 + %g2 ]                         
40027070:	87 28 e0 02 	sll  %g3, 2, %g3                               
    }                                                                 
  }                                                                   
  grp->gr_mem[memcount] = NULL;                                       
40027074:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
40027078:	c0 20 40 03 	clr  [ %g1 + %g3 ]                             
  return 1;                                                           
}                                                                     
4002707c:	81 c7 e0 08 	ret                                            
40027080:	91 e8 20 01 	restore  %g0, 1, %o0                           
                                                                      
  /*                                                                  
   * Fill in pointer array                                            
   */                                                                 
  grp->gr_mem[0] = grmem;                                             
  for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {                  
40027084:	10 bf ff fc 	b  40027074 <scangr+0x160>                     <== NOT EXECUTED
40027088:	86 10 20 04 	mov  4, %g3                                    <== NOT EXECUTED
                                                                      

4002708c <scanpw>: FILE *fp, struct passwd *pwd, char *buffer, size_t bufsize ) {
4002708c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  int pwuid, pwgid;                                                   
                                                                      
  if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)            
40027090:	98 10 20 00 	clr  %o4                                       
  FILE *fp,                                                           
  struct passwd *pwd,                                                 
  char *buffer,                                                       
  size_t bufsize                                                      
)                                                                     
{                                                                     
40027094:	f4 27 a0 4c 	st  %i2, [ %fp + 0x4c ]                        
40027098:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]                        
  int pwuid, pwgid;                                                   
                                                                      
  if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)            
4002709c:	90 10 00 18 	mov  %i0, %o0                                  
400270a0:	92 10 00 19 	mov  %i1, %o1                                  
400270a4:	94 07 a0 4c 	add  %fp, 0x4c, %o2                            
400270a8:	7f ff ff 60 	call  40026e28 <scanString>                    
400270ac:	96 07 a0 50 	add  %fp, 0x50, %o3                            
400270b0:	80 a2 20 00 	cmp  %o0, 0                                    
400270b4:	12 80 00 04 	bne  400270c4 <scanpw+0x38>                    
400270b8:	90 10 00 18 	mov  %i0, %o0                                  
   || !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))          
    return 0;                                                         
400270bc:	81 c7 e0 08 	ret                                            
400270c0:	91 e8 20 00 	restore  %g0, 0, %o0                           
)                                                                     
{                                                                     
  int pwuid, pwgid;                                                   
                                                                      
  if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)            
   || !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0)          
400270c4:	92 06 60 04 	add  %i1, 4, %o1                               
400270c8:	94 07 a0 4c 	add  %fp, 0x4c, %o2                            
400270cc:	96 07 a0 50 	add  %fp, 0x50, %o3                            
400270d0:	7f ff ff 56 	call  40026e28 <scanString>                    
400270d4:	98 10 20 00 	clr  %o4                                       
400270d8:	80 a2 20 00 	cmp  %o0, 0                                    
400270dc:	02 bf ff f8 	be  400270bc <scanpw+0x30>                     <== NEVER TAKEN
400270e0:	90 10 00 18 	mov  %i0, %o0                                  
   || !scanInt(fp, &pwuid)                                            
400270e4:	7f ff ff 06 	call  40026cfc <scanInt>                       
400270e8:	92 07 bf f8 	add  %fp, -8, %o1                              
400270ec:	80 a2 20 00 	cmp  %o0, 0                                    
400270f0:	02 bf ff f3 	be  400270bc <scanpw+0x30>                     
400270f4:	90 10 00 18 	mov  %i0, %o0                                  
   || !scanInt(fp, &pwgid)                                            
400270f8:	7f ff ff 01 	call  40026cfc <scanInt>                       
400270fc:	92 07 bf fc 	add  %fp, -4, %o1                              
40027100:	80 a2 20 00 	cmp  %o0, 0                                    
40027104:	02 bf ff ee 	be  400270bc <scanpw+0x30>                     
40027108:	90 10 00 18 	mov  %i0, %o0                                  
   || !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)         
4002710c:	92 06 60 0c 	add  %i1, 0xc, %o1                             
40027110:	94 07 a0 4c 	add  %fp, 0x4c, %o2                            
40027114:	96 07 a0 50 	add  %fp, 0x50, %o3                            
40027118:	7f ff ff 44 	call  40026e28 <scanString>                    
4002711c:	98 10 20 00 	clr  %o4                                       
40027120:	80 a2 20 00 	cmp  %o0, 0                                    
40027124:	02 bf ff e6 	be  400270bc <scanpw+0x30>                     <== NEVER TAKEN
40027128:	90 10 00 18 	mov  %i0, %o0                                  
   || !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)           
4002712c:	92 06 60 10 	add  %i1, 0x10, %o1                            
40027130:	94 07 a0 4c 	add  %fp, 0x4c, %o2                            
40027134:	96 07 a0 50 	add  %fp, 0x50, %o3                            
40027138:	7f ff ff 3c 	call  40026e28 <scanString>                    
4002713c:	98 10 20 00 	clr  %o4                                       
40027140:	80 a2 20 00 	cmp  %o0, 0                                    
40027144:	02 bf ff de 	be  400270bc <scanpw+0x30>                     <== NEVER TAKEN
40027148:	90 10 00 18 	mov  %i0, %o0                                  
   || !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)             
4002714c:	92 06 60 14 	add  %i1, 0x14, %o1                            
40027150:	94 07 a0 4c 	add  %fp, 0x4c, %o2                            
40027154:	96 07 a0 50 	add  %fp, 0x50, %o3                            
40027158:	7f ff ff 34 	call  40026e28 <scanString>                    
4002715c:	98 10 20 00 	clr  %o4                                       
40027160:	80 a2 20 00 	cmp  %o0, 0                                    
40027164:	02 bf ff d6 	be  400270bc <scanpw+0x30>                     <== NEVER TAKEN
40027168:	90 10 00 18 	mov  %i0, %o0                                  
   || !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))          
4002716c:	92 06 60 18 	add  %i1, 0x18, %o1                            
40027170:	94 07 a0 4c 	add  %fp, 0x4c, %o2                            
40027174:	96 07 a0 50 	add  %fp, 0x50, %o3                            
40027178:	7f ff ff 2c 	call  40026e28 <scanString>                    
4002717c:	98 10 20 01 	mov  1, %o4                                    
40027180:	80 a2 20 00 	cmp  %o0, 0                                    
40027184:	02 bf ff ce 	be  400270bc <scanpw+0x30>                     
40027188:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
    return 0;                                                         
  pwd->pw_uid = pwuid;                                                
4002718c:	c2 36 60 08 	sth  %g1, [ %i1 + 8 ]                          
  pwd->pw_gid = pwgid;                                                
40027190:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40027194:	c2 36 60 0a 	sth  %g1, [ %i1 + 0xa ]                        
  return 1;                                                           
}                                                                     
40027198:	81 c7 e0 08 	ret                                            
4002719c:	91 e8 20 01 	restore  %g0, 1, %o0                           
                                                                      

400077dc <sched_get_priority_max>: #include <rtems/posix/priority.h> int sched_get_priority_max( int policy ) {
400077dc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  switch ( policy ) {                                                 
400077e0:	80 a6 20 04 	cmp  %i0, 4                                    
400077e4:	08 80 00 08 	bleu  40007804 <sched_get_priority_max+0x28>   
400077e8:	82 10 20 01 	mov  1, %g1                                    
    case SCHED_RR:                                                    
    case SCHED_SPORADIC:                                              
      break;                                                          
                                                                      
    default:                                                          
      rtems_set_errno_and_return_minus_one( EINVAL );                 
400077ec:	40 00 22 40 	call  400100ec <__errno>                       
400077f0:	b0 10 3f ff 	mov  -1, %i0                                   
400077f4:	82 10 20 16 	mov  0x16, %g1                                 
400077f8:	c2 22 00 00 	st  %g1, [ %o0 ]                               
400077fc:	81 c7 e0 08 	ret                                            
40007800:	81 e8 00 00 	restore                                        
                                                                      
int sched_get_priority_max(                                           
  int  policy                                                         
)                                                                     
{                                                                     
  switch ( policy ) {                                                 
40007804:	b1 28 40 18 	sll  %g1, %i0, %i0                             
40007808:	80 8e 20 17 	btst  0x17, %i0                                
4000780c:	02 bf ff f8 	be  400077ec <sched_get_priority_max+0x10>     <== NEVER TAKEN
40007810:	03 10 00 7b 	sethi  %hi(0x4001ec00), %g1                    
                                                                      
    default:                                                          
      rtems_set_errno_and_return_minus_one( EINVAL );                 
  }                                                                   
                                                                      
  return POSIX_SCHEDULER_MAXIMUM_PRIORITY;                            
40007814:	f0 08 61 fc 	ldub  [ %g1 + 0x1fc ], %i0	! 4001edfc <rtems_maximum_priority>
}                                                                     
40007818:	81 c7 e0 08 	ret                                            
4000781c:	91 ee 3f ff 	restore  %i0, -1, %o0                          
                                                                      

40007820 <sched_get_priority_min>: * 13.3.6 Get Scheduling Parameter Limits, P1003.1b-1993, p. 258 */ int sched_get_priority_min( int policy ) {
40007820:	9d e3 bf a0 	save  %sp, -96, %sp                            
  switch ( policy ) {                                                 
40007824:	80 a6 20 04 	cmp  %i0, 4                                    
40007828:	08 80 00 08 	bleu  40007848 <sched_get_priority_min+0x28>   
4000782c:	82 10 00 18 	mov  %i0, %g1                                  
    case SCHED_RR:                                                    
    case SCHED_SPORADIC:                                              
      break;                                                          
                                                                      
    default:                                                          
      rtems_set_errno_and_return_minus_one( EINVAL );                 
40007830:	40 00 22 2f 	call  400100ec <__errno>                       
40007834:	b0 10 3f ff 	mov  -1, %i0                                   
40007838:	82 10 20 16 	mov  0x16, %g1                                 
4000783c:	c2 22 00 00 	st  %g1, [ %o0 ]                               
  }                                                                   
                                                                      
  return POSIX_SCHEDULER_MINIMUM_PRIORITY;                            
}                                                                     
40007840:	81 c7 e0 08 	ret                                            
40007844:	81 e8 00 00 	restore                                        
 */                                                                   
int sched_get_priority_min(                                           
  int  policy                                                         
)                                                                     
{                                                                     
  switch ( policy ) {                                                 
40007848:	84 10 20 01 	mov  1, %g2                                    
4000784c:	83 28 80 01 	sll  %g2, %g1, %g1                             
40007850:	80 88 60 17 	btst  0x17, %g1                                
40007854:	02 bf ff f7 	be  40007830 <sched_get_priority_min+0x10>     <== NEVER TAKEN
40007858:	b0 10 20 01 	mov  1, %i0                                    
    default:                                                          
      rtems_set_errno_and_return_minus_one( EINVAL );                 
  }                                                                   
                                                                      
  return POSIX_SCHEDULER_MINIMUM_PRIORITY;                            
}                                                                     
4000785c:	81 c7 e0 08 	ret                                            
40007860:	81 e8 00 00 	restore                                        
                                                                      

40007864 <sched_rr_get_interval>: int sched_rr_get_interval( pid_t pid, struct timespec *interval ) {
40007864:	9d e3 bf a0 	save  %sp, -96, %sp                            
  /*                                                                  
   *  Only supported for the "calling process" (i.e. this node).      
   */                                                                 
                                                                      
  if ( pid && pid != getpid() )                                       
40007868:	80 a6 20 00 	cmp  %i0, 0                                    
4000786c:	12 80 00 0a 	bne  40007894 <sched_rr_get_interval+0x30>     <== ALWAYS TAKEN
40007870:	80 a6 60 00 	cmp  %i1, 0                                    
    rtems_set_errno_and_return_minus_one( ESRCH );                    
                                                                      
  if ( !interval )                                                    
40007874:	02 80 00 13 	be  400078c0 <sched_rr_get_interval+0x5c>      
40007878:	03 10 00 7e 	sethi  %hi(0x4001f800), %g1                    
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  _Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval );      
4000787c:	d0 00 61 10 	ld  [ %g1 + 0x110 ], %o0	! 4001f910 <_Thread_Ticks_per_timeslice>
40007880:	92 10 00 19 	mov  %i1, %o1                                  
40007884:	40 00 0f 59 	call  4000b5e8 <_Timespec_From_ticks>          
40007888:	b0 10 20 00 	clr  %i0                                       
  return 0;                                                           
}                                                                     
4000788c:	81 c7 e0 08 	ret                                            
40007890:	81 e8 00 00 	restore                                        
{                                                                     
  /*                                                                  
   *  Only supported for the "calling process" (i.e. this node).      
   */                                                                 
                                                                      
  if ( pid && pid != getpid() )                                       
40007894:	7f ff ee ed 	call  40003448 <getpid>                        
40007898:	01 00 00 00 	nop                                            
4000789c:	80 a2 00 18 	cmp  %o0, %i0                                  
400078a0:	02 bf ff f5 	be  40007874 <sched_rr_get_interval+0x10>      
400078a4:	80 a6 60 00 	cmp  %i1, 0                                    
    rtems_set_errno_and_return_minus_one( ESRCH );                    
400078a8:	40 00 22 11 	call  400100ec <__errno>                       
400078ac:	b0 10 3f ff 	mov  -1, %i0                                   
400078b0:	82 10 20 03 	mov  3, %g1                                    
400078b4:	c2 22 00 00 	st  %g1, [ %o0 ]                               
400078b8:	81 c7 e0 08 	ret                                            
400078bc:	81 e8 00 00 	restore                                        
                                                                      
  if ( !interval )                                                    
    rtems_set_errno_and_return_minus_one( EINVAL );                   
400078c0:	40 00 22 0b 	call  400100ec <__errno>                       
400078c4:	b0 10 3f ff 	mov  -1, %i0                                   
400078c8:	82 10 20 16 	mov  0x16, %g1                                 
400078cc:	c2 22 00 00 	st  %g1, [ %o0 ]                               
400078d0:	81 c7 e0 08 	ret                                            
400078d4:	81 e8 00 00 	restore                                        
                                                                      

4000812c <sem_open>: int oflag, ... /* mode_t mode, */ /* unsigned int value */ ) {
4000812c:	9d e3 bf 88 	save  %sp, -120, %sp                           
   *                                                                  
   * This rountine increments the thread dispatch level               
   */                                                                 
  RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
  {                                                                   
    uint32_t level = _Thread_Dispatch_disable_level;                  
40008130:	03 10 00 8e 	sethi  %hi(0x40023800), %g1                    
40008134:	c4 00 60 c0 	ld  [ %g1 + 0xc0 ], %g2	! 400238c0 <_Thread_Dispatch_disable_level>
  size_t                     name_len;                                
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  if ( oflag & O_CREAT ) {                                            
    va_start(arg, oflag);                                             
40008138:	f4 27 a0 4c 	st  %i2, [ %fp + 0x4c ]                        
                                                                      
    ++level;                                                          
4000813c:	84 00 a0 01 	inc  %g2                                       
40008140:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]                        
40008144:	f8 27 a0 54 	st  %i4, [ %fp + 0x54 ]                        
40008148:	fa 27 a0 58 	st  %i5, [ %fp + 0x58 ]                        
    _Thread_Dispatch_disable_level = level;                           
4000814c:	c4 20 60 c0 	st  %g2, [ %g1 + 0xc0 ]                        
  Objects_Locations          location;                                
  size_t                     name_len;                                
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  if ( oflag & O_CREAT ) {                                            
40008150:	b4 8e 62 00 	andcc  %i1, 0x200, %i2                         
40008154:	12 80 00 27 	bne  400081f0 <sem_open+0xc4>                  
40008158:	b6 10 20 00 	clr  %i3                                       
  const char *name,                                                   
  Objects_Id *id,                                                     
  size_t     *len                                                     
)                                                                     
{                                                                     
  return _POSIX_Name_to_id( &_POSIX_Semaphore_Information, name, id, len );
4000815c:	39 10 00 8e 	sethi  %hi(0x40023800), %i4                    
40008160:	92 10 00 18 	mov  %i0, %o1                                  
40008164:	90 17 23 84 	or  %i4, 0x384, %o0                            
40008168:	94 07 bf f0 	add  %fp, -16, %o2                             
4000816c:	7f ff fe 5c 	call  40007adc <_POSIX_Name_to_id>             
40008170:	96 07 bf fc 	add  %fp, -4, %o3                              
   *  and we can just return a pointer to the id.  Otherwise we may   
   *  need to check to see if this is a "semaphore does not exist"    
   *  or some other miscellaneous error on the name.                  
   */                                                                 
                                                                      
  if ( status ) {                                                     
40008174:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40008178:	22 80 00 0e 	be,a   400081b0 <sem_open+0x84>                
4000817c:	b2 0e 6a 00 	and  %i1, 0xa00, %i1                           
    /*                                                                
     * Unless provided a valid name that did not already exist        
     * and we are willing to create then it is an error.              
     */                                                               
                                                                      
    if ( !( status == ENOENT && (oflag & O_CREAT) ) ) {               
40008180:	80 a7 60 02 	cmp  %i5, 2                                    
40008184:	12 80 00 04 	bne  40008194 <sem_open+0x68>                  
40008188:	80 a6 a0 00 	cmp  %i2, 0                                    
4000818c:	12 80 00 1d 	bne  40008200 <sem_open+0xd4>                  
40008190:	d2 07 bf fc 	ld  [ %fp + -4 ], %o1                          
      _Thread_Enable_dispatch();                                      
40008194:	40 00 0e 73 	call  4000bb60 <_Thread_Enable_dispatch>       
40008198:	b0 10 3f ff 	mov  -1, %i0                                   
      rtems_set_errno_and_return_minus_one_cast( status, sem_t * );   
4000819c:	40 00 25 30 	call  4001165c <__errno>                       
400081a0:	01 00 00 00 	nop                                            
400081a4:	fa 22 00 00 	st  %i5, [ %o0 ]                               
400081a8:	81 c7 e0 08 	ret                                            
400081ac:	81 e8 00 00 	restore                                        
                                                                      
    /*                                                                
     * Check for existence with creation.                             
     */                                                               
                                                                      
    if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {       
400081b0:	80 a6 6a 00 	cmp  %i1, 0xa00                                
400081b4:	02 80 00 1f 	be  40008230 <sem_open+0x104>                  
400081b8:	d2 07 bf f0 	ld  [ %fp + -16 ], %o1                         
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Get (  
  sem_t             *id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (POSIX_Semaphore_Control *)                                  
400081bc:	94 07 bf f8 	add  %fp, -8, %o2                              
400081c0:	40 00 0a 7a 	call  4000aba8 <_Objects_Get>                  
400081c4:	90 17 23 84 	or  %i4, 0x384, %o0                            
      _Thread_Enable_dispatch();                                      
      rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );   
    }                                                                 
                                                                      
    the_semaphore = _POSIX_Semaphore_Get( (sem_t *) &the_semaphore_id, &location );
    the_semaphore->open_count += 1;                                   
400081c8:	c2 02 20 18 	ld  [ %o0 + 0x18 ], %g1                        
    if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {       
      _Thread_Enable_dispatch();                                      
      rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );   
    }                                                                 
                                                                      
    the_semaphore = _POSIX_Semaphore_Get( (sem_t *) &the_semaphore_id, &location );
400081cc:	d0 27 bf f4 	st  %o0, [ %fp + -12 ]                         
    the_semaphore->open_count += 1;                                   
400081d0:	82 00 60 01 	inc  %g1                                       
    _Thread_Enable_dispatch();                                        
400081d4:	40 00 0e 63 	call  4000bb60 <_Thread_Enable_dispatch>       
400081d8:	c2 22 20 18 	st  %g1, [ %o0 + 0x18 ]                        
    _Thread_Enable_dispatch();                                        
400081dc:	40 00 0e 61 	call  4000bb60 <_Thread_Enable_dispatch>       
400081e0:	01 00 00 00 	nop                                            
return_id:                                                            
  #if defined(RTEMS_USE_16_BIT_OBJECT)                                
    the_semaphore->Semaphore_id = the_semaphore->Object.id;           
    return &the_semaphore->Semaphore_id;                              
  #else                                                               
    return (sem_t *)&the_semaphore->Object.id;                        
400081e4:	f0 07 bf f4 	ld  [ %fp + -12 ], %i0                         
400081e8:	81 c7 e0 08 	ret                                            
400081ec:	91 ee 20 08 	restore  %i0, 8, %o0                           
  size_t                     name_len;                                
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  if ( oflag & O_CREAT ) {                                            
    va_start(arg, oflag);                                             
400081f0:	82 07 a0 4c 	add  %fp, 0x4c, %g1                            
    mode = va_arg( arg, mode_t );                                     
    value = va_arg( arg, unsigned int );                              
400081f4:	f6 07 a0 50 	ld  [ %fp + 0x50 ], %i3                        
  size_t                     name_len;                                
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  if ( oflag & O_CREAT ) {                                            
    va_start(arg, oflag);                                             
400081f8:	10 bf ff d9 	b  4000815c <sem_open+0x30>                    
400081fc:	c2 27 bf ec 	st  %g1, [ %fp + -20 ]                         
  /*                                                                  
   *  At this point, the semaphore does not exist and everything has been
   *  checked. We should go ahead and create a semaphore.             
   */                                                                 
                                                                      
  status =_POSIX_Semaphore_Create_support(                            
40008200:	94 10 20 00 	clr  %o2                                       
40008204:	96 10 00 1b 	mov  %i3, %o3                                  
40008208:	98 07 bf f4 	add  %fp, -12, %o4                             
4000820c:	40 00 1a b9 	call  4000ecf0 <_POSIX_Semaphore_Create_support>
40008210:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
  /*                                                                  
   * errno was set by Create_support, so don't set it again.          
   */                                                                 
                                                                      
  _Thread_Enable_dispatch();                                          
40008214:	40 00 0e 53 	call  4000bb60 <_Thread_Enable_dispatch>       
40008218:	ba 10 00 08 	mov  %o0, %i5                                  
                                                                      
  if ( status == -1 )                                                 
4000821c:	80 a7 7f ff 	cmp  %i5, -1                                   
40008220:	32 bf ff f2 	bne,a   400081e8 <sem_open+0xbc>               <== ALWAYS TAKEN
40008224:	f0 07 bf f4 	ld  [ %fp + -12 ], %i0                         
    the_semaphore->Semaphore_id = the_semaphore->Object.id;           
    return &the_semaphore->Semaphore_id;                              
  #else                                                               
    return (sem_t *)&the_semaphore->Object.id;                        
  #endif                                                              
}                                                                     
40008228:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000822c:	91 e8 3f ff 	restore  %g0, -1, %o0                          <== NOT EXECUTED
    /*                                                                
     * Check for existence with creation.                             
     */                                                               
                                                                      
    if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {       
      _Thread_Enable_dispatch();                                      
40008230:	40 00 0e 4c 	call  4000bb60 <_Thread_Enable_dispatch>       
40008234:	b0 10 3f ff 	mov  -1, %i0                                   
      rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );   
40008238:	40 00 25 09 	call  4001165c <__errno>                       
4000823c:	01 00 00 00 	nop                                            
40008240:	82 10 20 11 	mov  0x11, %g1	! 11 <PROM_START+0x11>          
40008244:	c2 22 00 00 	st  %g1, [ %o0 ]                               
40008248:	81 c7 e0 08 	ret                                            
4000824c:	81 e8 00 00 	restore                                        
                                                                      

4000a284 <sem_timedwait>: int sem_timedwait( sem_t *sem, const struct timespec *abstime ) {
4000a284:	9d e3 bf 98 	save  %sp, -104, %sp                           
   *                                                                  
   *  If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,                
   *  POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
   *  then we should not wait.                                        
   */                                                                 
  status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );       
4000a288:	90 10 00 19 	mov  %i1, %o0                                  
4000a28c:	40 00 16 6f 	call  4000fc48 <_POSIX_Absolute_timeout_to_ticks>
4000a290:	92 07 bf fc 	add  %fp, -4, %o1                              
  if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )                
    do_wait = false;                                                  
                                                                      
  lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks ); 
4000a294:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          
   *  If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,                
   *  POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
   *  then we should not wait.                                        
   */                                                                 
  status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );       
  if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )                
4000a298:	80 a2 20 03 	cmp  %o0, 3                                    
4000a29c:	02 80 00 06 	be  4000a2b4 <sem_timedwait+0x30>              <== ALWAYS TAKEN
4000a2a0:	90 10 00 18 	mov  %i0, %o0                                  
    do_wait = false;                                                  
                                                                      
  lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks ); 
4000a2a4:	40 00 19 69 	call  40010848 <_POSIX_Semaphore_Wait_support> <== NOT EXECUTED
4000a2a8:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4000a2ac:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000a2b0:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
4000a2b4:	40 00 19 65 	call  40010848 <_POSIX_Semaphore_Wait_support> 
4000a2b8:	92 10 20 01 	mov  1, %o1                                    
         lock_status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )               
      rtems_set_errno_and_return_minus_one( ETIMEDOUT );              
  }                                                                   
                                                                      
  return lock_status;                                                 
}                                                                     
4000a2bc:	81 c7 e0 08 	ret                                            
4000a2c0:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

40007790 <sigaction>: int sigaction( int sig, const struct sigaction *act, struct sigaction *oact ) {
40007790:	9d e3 bf a0 	save  %sp, -96, %sp                            
  ISR_Level     level;                                                
                                                                      
  if ( oact )                                                         
40007794:	80 a6 a0 00 	cmp  %i2, 0                                    
40007798:	02 80 00 0d 	be  400077cc <sigaction+0x3c>                  
4000779c:	87 2e 20 02 	sll  %i0, 2, %g3                               
    *oact = _POSIX_signals_Vectors[ sig ];                            
400077a0:	05 10 00 6a 	sethi  %hi(0x4001a800), %g2                    
400077a4:	83 2e 20 04 	sll  %i0, 4, %g1                               
400077a8:	84 10 a1 70 	or  %g2, 0x170, %g2                            
400077ac:	82 20 40 03 	sub  %g1, %g3, %g1                             
400077b0:	c6 00 80 01 	ld  [ %g2 + %g1 ], %g3                         
400077b4:	82 00 80 01 	add  %g2, %g1, %g1                             
400077b8:	c6 26 80 00 	st  %g3, [ %i2 ]                               
400077bc:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
400077c0:	c4 26 a0 04 	st  %g2, [ %i2 + 4 ]                           
400077c4:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
400077c8:	c2 26 a0 08 	st  %g1, [ %i2 + 8 ]                           
                                                                      
  if ( !sig )                                                         
400077cc:	80 a6 20 00 	cmp  %i0, 0                                    
400077d0:	02 80 00 33 	be  4000789c <sigaction+0x10c>                 
400077d4:	01 00 00 00 	nop                                            
                                                                      
static inline bool is_valid_signo(                                    
  int signo                                                           
)                                                                     
{                                                                     
  return ((signo) >= 1 && (signo) <= 32 );                            
400077d8:	82 06 3f ff 	add  %i0, -1, %g1                              
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( !is_valid_signo(sig) )                                         
400077dc:	80 a0 60 1f 	cmp  %g1, 0x1f                                 
400077e0:	18 80 00 2f 	bgu  4000789c <sigaction+0x10c>                
400077e4:	80 a6 20 09 	cmp  %i0, 9                                    
   *                                                                  
   *  NOTE: Solaris documentation claims to "silently enforce" this which
   *        contradicts the POSIX specification.                      
   */                                                                 
                                                                      
  if ( sig == SIGKILL )                                               
400077e8:	02 80 00 2d 	be  4000789c <sigaction+0x10c>                 
400077ec:	80 a6 60 00 	cmp  %i1, 0                                    
  /*                                                                  
   *  Evaluate the new action structure and set the global signal vector
   *  appropriately.                                                  
   */                                                                 
                                                                      
  if ( act ) {                                                        
400077f0:	02 80 00 1a 	be  40007858 <sigaction+0xc8>                  <== NEVER TAKEN
400077f4:	82 10 20 00 	clr  %g1                                       
    /*                                                                
     *  Unless the user is installing the default signal actions, then
     *  we can just copy the provided sigaction structure into the vectors.
     */                                                               
                                                                      
    _ISR_Disable( level );                                            
400077f8:	7f ff eb 17 	call  40002454 <sparc_disable_interrupts>      
400077fc:	01 00 00 00 	nop                                            
40007800:	ba 10 00 08 	mov  %o0, %i5                                  
      if ( act->sa_handler == SIG_DFL ) {                             
40007804:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
40007808:	80 a0 60 00 	cmp  %g1, 0                                    
4000780c:	02 80 00 15 	be  40007860 <sigaction+0xd0>                  
40007810:	83 2e 20 02 	sll  %i0, 2, %g1                               
        _POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
      } else {                                                        
         _POSIX_signals_Clear_process_signals( sig );                 
40007814:	40 00 17 c0 	call  4000d714 <_POSIX_signals_Clear_process_signals>
40007818:	90 10 00 18 	mov  %i0, %o0                                  
         _POSIX_signals_Vectors[ sig ] = *act;                        
4000781c:	c4 06 40 00 	ld  [ %i1 ], %g2                               
40007820:	87 2e 20 02 	sll  %i0, 2, %g3                               
40007824:	03 10 00 6a 	sethi  %hi(0x4001a800), %g1                    
40007828:	b1 2e 20 04 	sll  %i0, 4, %i0                               
4000782c:	82 10 61 70 	or  %g1, 0x170, %g1                            
40007830:	b0 26 00 03 	sub  %i0, %g3, %i0                             
40007834:	c4 20 40 18 	st  %g2, [ %g1 + %i0 ]                         
40007838:	c4 06 60 04 	ld  [ %i1 + 4 ], %g2                           
4000783c:	b0 00 40 18 	add  %g1, %i0, %i0                             
40007840:	c4 26 20 04 	st  %g2, [ %i0 + 4 ]                           
40007844:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
40007848:	c2 26 20 08 	st  %g1, [ %i0 + 8 ]                           
      }                                                               
    _ISR_Enable( level );                                             
4000784c:	7f ff eb 06 	call  40002464 <sparc_enable_interrupts>       
40007850:	90 10 00 1d 	mov  %i5, %o0                                  
   *      now (signals not posted when SIG_IGN).                      
   *    + If we are now ignoring a signal that was previously pending,
   *      we clear the pending signal indicator.                      
   */                                                                 
                                                                      
  return 0;                                                           
40007854:	82 10 20 00 	clr  %g1                                       
}                                                                     
40007858:	81 c7 e0 08 	ret                                            
4000785c:	91 e8 00 01 	restore  %g0, %g1, %o0                         
     *  we can just copy the provided sigaction structure into the vectors.
     */                                                               
                                                                      
    _ISR_Disable( level );                                            
      if ( act->sa_handler == SIG_DFL ) {                             
        _POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
40007860:	b1 2e 20 04 	sll  %i0, 4, %i0                               
40007864:	b0 26 00 01 	sub  %i0, %g1, %i0                             
40007868:	03 10 00 64 	sethi  %hi(0x40019000), %g1                    
4000786c:	82 10 60 54 	or  %g1, 0x54, %g1	! 40019054 <_POSIX_signals_Default_vectors>
40007870:	c8 00 40 18 	ld  [ %g1 + %i0 ], %g4                         
40007874:	82 00 40 18 	add  %g1, %i0, %g1                             
40007878:	c6 00 60 04 	ld  [ %g1 + 4 ], %g3                           
4000787c:	c4 00 60 08 	ld  [ %g1 + 8 ], %g2                           
40007880:	03 10 00 6a 	sethi  %hi(0x4001a800), %g1                    
40007884:	82 10 61 70 	or  %g1, 0x170, %g1	! 4001a970 <_POSIX_signals_Vectors>
40007888:	c8 20 40 18 	st  %g4, [ %g1 + %i0 ]                         
4000788c:	b0 00 40 18 	add  %g1, %i0, %i0                             
40007890:	c6 26 20 04 	st  %g3, [ %i0 + 4 ]                           
40007894:	10 bf ff ee 	b  4000784c <sigaction+0xbc>                   
40007898:	c4 26 20 08 	st  %g2, [ %i0 + 8 ]                           
   *  NOTE: Solaris documentation claims to "silently enforce" this which
   *        contradicts the POSIX specification.                      
   */                                                                 
                                                                      
  if ( sig == SIGKILL )                                               
    rtems_set_errno_and_return_minus_one( EINVAL );                   
4000789c:	40 00 23 2a 	call  40010544 <__errno>                       
400078a0:	01 00 00 00 	nop                                            
400078a4:	84 10 20 16 	mov  0x16, %g2	! 16 <PROM_START+0x16>          
400078a8:	82 10 3f ff 	mov  -1, %g1                                   
400078ac:	10 bf ff eb 	b  40007858 <sigaction+0xc8>                   
400078b0:	c4 22 00 00 	st  %g2, [ %o0 ]                               
                                                                      

40007d20 <sigtimedwait>: int sigtimedwait( const sigset_t *set, siginfo_t *info, const struct timespec *timeout ) {
40007d20:	9d e3 bf 90 	save  %sp, -112, %sp                           
  ISR_Level          level;                                           
                                                                      
  /*                                                                  
   *  Error check parameters before disabling interrupts.             
   */                                                                 
  if ( !set )                                                         
40007d24:	ba 96 20 00 	orcc  %i0, 0, %i5                              
40007d28:	02 80 00 83 	be  40007f34 <sigtimedwait+0x214>              
40007d2c:	80 a6 a0 00 	cmp  %i2, 0                                    
  /*  NOTE: This is very specifically a RELATIVE not ABSOLUTE time    
   *        in the Open Group specification.                          
   */                                                                 
                                                                      
  interval = 0;                                                       
  if ( timeout ) {                                                    
40007d30:	02 80 00 5b 	be  40007e9c <sigtimedwait+0x17c>              
40007d34:	80 a6 60 00 	cmp  %i1, 0                                    
                                                                      
    if ( !_Timespec_Is_valid( timeout ) )                             
40007d38:	40 00 0f 9d 	call  4000bbac <_Timespec_Is_valid>            
40007d3c:	90 10 00 1a 	mov  %i2, %o0                                  
40007d40:	80 8a 20 ff 	btst  0xff, %o0                                
40007d44:	02 80 00 7c 	be  40007f34 <sigtimedwait+0x214>              
40007d48:	01 00 00 00 	nop                                            
      rtems_set_errno_and_return_minus_one( EINVAL );                 
                                                                      
    interval = _Timespec_To_ticks( timeout );                         
40007d4c:	40 00 0f ab 	call  4000bbf8 <_Timespec_To_ticks>            
40007d50:	90 10 00 1a 	mov  %i2, %o0                                  
                                                                      
    if ( !interval )                                                  
40007d54:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40007d58:	02 80 00 77 	be  40007f34 <sigtimedwait+0x214>              <== NEVER TAKEN
40007d5c:	80 a6 60 00 	cmp  %i1, 0                                    
                                                                      
  /*                                                                  
   *  Initialize local variables.                                     
   */                                                                 
                                                                      
  the_info = ( info ) ? info : &signal_information;                   
40007d60:	02 80 00 52 	be  40007ea8 <sigtimedwait+0x188>              <== NEVER TAKEN
40007d64:	35 10 00 6c 	sethi  %hi(0x4001b000), %i2                    
                                                                      
  the_thread = _Thread_Executing;                                     
40007d68:	35 10 00 6c 	sethi  %hi(0x4001b000), %i2                    
40007d6c:	b4 16 a1 70 	or  %i2, 0x170, %i2	! 4001b170 <_Per_CPU_Information>
40007d70:	f8 06 a0 10 	ld  [ %i2 + 0x10 ], %i4                        
   *  What if they are already pending?                               
   */                                                                 
                                                                      
  /* API signals pending? */                                          
                                                                      
  _ISR_Disable( level );                                              
40007d74:	7f ff ea 93 	call  400027c0 <sparc_disable_interrupts>      
40007d78:	f6 07 21 50 	ld  [ %i4 + 0x150 ], %i3                       
40007d7c:	a0 10 00 08 	mov  %o0, %l0                                  
  if ( *set & api->signals_pending ) {                                
40007d80:	c2 07 40 00 	ld  [ %i5 ], %g1                               
40007d84:	c4 06 e0 d4 	ld  [ %i3 + 0xd4 ], %g2                        
40007d88:	80 88 40 02 	btst  %g1, %g2                                 
40007d8c:	12 80 00 52 	bne  40007ed4 <sigtimedwait+0x1b4>             
40007d90:	01 00 00 00 	nop                                            
    return the_info->si_signo;                                        
  }                                                                   
                                                                      
  /* Process pending signals? */                                      
                                                                      
  if ( *set & _POSIX_signals_Pending ) {                              
40007d94:	05 10 00 6c 	sethi  %hi(0x4001b000), %g2                    
40007d98:	c4 00 a3 c4 	ld  [ %g2 + 0x3c4 ], %g2	! 4001b3c4 <_POSIX_signals_Pending>
40007d9c:	80 88 40 02 	btst  %g1, %g2                                 
40007da0:	12 80 00 2e 	bne  40007e58 <sigtimedwait+0x138>             
40007da4:	03 10 00 6b 	sethi  %hi(0x4001ac00), %g1                    
   *                                                                  
   * This rountine increments the thread dispatch level               
   */                                                                 
  RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
  {                                                                   
    uint32_t level = _Thread_Dispatch_disable_level;                  
40007da8:	c4 00 60 60 	ld  [ %g1 + 0x60 ], %g2	! 4001ac60 <_Thread_Dispatch_disable_level>
    the_info->si_code = SI_USER;                                      
    the_info->si_value.sival_int = 0;                                 
    return signo;                                                     
  }                                                                   
                                                                      
  the_info->si_signo = -1;                                            
40007dac:	86 10 3f ff 	mov  -1, %g3                                   
40007db0:	c6 26 40 00 	st  %g3, [ %i1 ]                               
                                                                      
    ++level;                                                          
40007db4:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
40007db8:	c4 20 60 60 	st  %g2, [ %g1 + 0x60 ]                        
                                                                      
  _Thread_Disable_dispatch();                                         
    the_thread->Wait.queue           = &_POSIX_signals_Wait_queue;    
    the_thread->Wait.return_code     = EINTR;                         
40007dbc:	82 10 20 04 	mov  4, %g1                                    
40007dc0:	c2 27 20 34 	st  %g1, [ %i4 + 0x34 ]                        
    the_thread->Wait.option          = *set;                          
40007dc4:	c2 07 40 00 	ld  [ %i5 ], %g1                               
    the_thread->Wait.return_argument = the_info;                      
40007dc8:	f2 27 20 28 	st  %i1, [ %i4 + 0x28 ]                        
  the_info->si_signo = -1;                                            
                                                                      
  _Thread_Disable_dispatch();                                         
    the_thread->Wait.queue           = &_POSIX_signals_Wait_queue;    
    the_thread->Wait.return_code     = EINTR;                         
    the_thread->Wait.option          = *set;                          
40007dcc:	c2 27 20 30 	st  %g1, [ %i4 + 0x30 ]                        
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (      
  Thread_queue_Control *the_thread_queue                              
)                                                                     
{                                                                     
  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
40007dd0:	a2 10 20 01 	mov  1, %l1                                    
  }                                                                   
                                                                      
  the_info->si_signo = -1;                                            
                                                                      
  _Thread_Disable_dispatch();                                         
    the_thread->Wait.queue           = &_POSIX_signals_Wait_queue;    
40007dd4:	21 10 00 6c 	sethi  %hi(0x4001b000), %l0                    
40007dd8:	a0 14 23 5c 	or  %l0, 0x35c, %l0	! 4001b35c <_POSIX_signals_Wait_queue>
40007ddc:	e0 27 20 44 	st  %l0, [ %i4 + 0x44 ]                        
40007de0:	e2 24 20 30 	st  %l1, [ %l0 + 0x30 ]                        
    the_thread->Wait.return_code     = EINTR;                         
    the_thread->Wait.option          = *set;                          
    the_thread->Wait.return_argument = the_info;                      
    _Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue );
    _ISR_Enable( level );                                             
40007de4:	7f ff ea 7b 	call  400027d0 <sparc_enable_interrupts>       
40007de8:	01 00 00 00 	nop                                            
    _Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval );    
40007dec:	90 10 00 10 	mov  %l0, %o0                                  
40007df0:	92 10 00 18 	mov  %i0, %o1                                  
40007df4:	15 10 00 2e 	sethi  %hi(0x4000b800), %o2                    
40007df8:	40 00 0d ff 	call  4000b5f4 <_Thread_queue_Enqueue_with_handler>
40007dfc:	94 12 a1 d4 	or  %o2, 0x1d4, %o2	! 4000b9d4 <_Thread_queue_Timeout>
  _Thread_Enable_dispatch();                                          
40007e00:	40 00 0c bd 	call  4000b0f4 <_Thread_Enable_dispatch>       
40007e04:	01 00 00 00 	nop                                            
  /*                                                                  
   * When the thread is set free by a signal, it is need to eliminate 
   * the signal.                                                      
   */                                                                 
                                                                      
  _POSIX_signals_Clear_signals( api, the_info->si_signo, the_info, false, false );
40007e08:	d2 06 40 00 	ld  [ %i1 ], %o1                               
40007e0c:	90 10 00 1b 	mov  %i3, %o0                                  
40007e10:	94 10 00 19 	mov  %i1, %o2                                  
40007e14:	96 10 20 00 	clr  %o3                                       
40007e18:	40 00 18 7c 	call  4000e008 <_POSIX_signals_Clear_signals>  
40007e1c:	98 10 20 00 	clr  %o4                                       
  /* Set errno only if return code is not EINTR or                    
   * if EINTR was caused by a signal being caught, which              
   * was not in our set.                                              
   */                                                                 
                                                                      
  if ( (_Thread_Executing->Wait.return_code != EINTR)                 
40007e20:	c2 06 a0 10 	ld  [ %i2 + 0x10 ], %g1                        
40007e24:	c2 00 60 34 	ld  [ %g1 + 0x34 ], %g1                        
40007e28:	80 a0 60 04 	cmp  %g1, 4                                    
40007e2c:	12 80 00 3b 	bne  40007f18 <sigtimedwait+0x1f8>             
40007e30:	01 00 00 00 	nop                                            
       || !(*set & signo_to_mask( the_info->si_signo )) ) {           
40007e34:	f0 06 40 00 	ld  [ %i1 ], %i0                               
40007e38:	c2 07 40 00 	ld  [ %i5 ], %g1                               
40007e3c:	84 06 3f ff 	add  %i0, -1, %g2                              
40007e40:	a3 2c 40 02 	sll  %l1, %g2, %l1                             
40007e44:	80 8c 40 01 	btst  %l1, %g1                                 
40007e48:	02 80 00 34 	be  40007f18 <sigtimedwait+0x1f8>              
40007e4c:	01 00 00 00 	nop                                            
    errno = _Thread_Executing->Wait.return_code;                      
    return -1;                                                        
  }                                                                   
                                                                      
  return the_info->si_signo;                                          
}                                                                     
40007e50:	81 c7 e0 08 	ret                                            
40007e54:	81 e8 00 00 	restore                                        
  }                                                                   
                                                                      
  /* Process pending signals? */                                      
                                                                      
  if ( *set & _POSIX_signals_Pending ) {                              
    signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );      
40007e58:	7f ff ff 9a 	call  40007cc0 <_POSIX_signals_Get_lowest>     
40007e5c:	90 10 00 02 	mov  %g2, %o0                                  
    _POSIX_signals_Clear_signals( api, signo, the_info, true, false );
40007e60:	94 10 00 19 	mov  %i1, %o2                                  
  }                                                                   
                                                                      
  /* Process pending signals? */                                      
                                                                      
  if ( *set & _POSIX_signals_Pending ) {                              
    signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );      
40007e64:	b0 10 00 08 	mov  %o0, %i0                                  
    _POSIX_signals_Clear_signals( api, signo, the_info, true, false );
40007e68:	96 10 20 01 	mov  1, %o3                                    
40007e6c:	90 10 00 1b 	mov  %i3, %o0                                  
40007e70:	92 10 00 18 	mov  %i0, %o1                                  
40007e74:	40 00 18 65 	call  4000e008 <_POSIX_signals_Clear_signals>  
40007e78:	98 10 20 00 	clr  %o4                                       
    _ISR_Enable( level );                                             
40007e7c:	7f ff ea 55 	call  400027d0 <sparc_enable_interrupts>       
40007e80:	90 10 00 10 	mov  %l0, %o0                                  
                                                                      
    the_info->si_signo = signo;                                       
    the_info->si_code = SI_USER;                                      
40007e84:	82 10 20 01 	mov  1, %g1                                    
  if ( *set & _POSIX_signals_Pending ) {                              
    signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );      
    _POSIX_signals_Clear_signals( api, signo, the_info, true, false );
    _ISR_Enable( level );                                             
                                                                      
    the_info->si_signo = signo;                                       
40007e88:	f0 26 40 00 	st  %i0, [ %i1 ]                               
    the_info->si_code = SI_USER;                                      
40007e8c:	c2 26 60 04 	st  %g1, [ %i1 + 4 ]                           
    the_info->si_value.sival_int = 0;                                 
40007e90:	c0 26 60 08 	clr  [ %i1 + 8 ]                               
40007e94:	81 c7 e0 08 	ret                                            
40007e98:	81 e8 00 00 	restore                                        
                                                                      
  /*                                                                  
   *  Initialize local variables.                                     
   */                                                                 
                                                                      
  the_info = ( info ) ? info : &signal_information;                   
40007e9c:	12 bf ff b3 	bne  40007d68 <sigtimedwait+0x48>              
40007ea0:	b0 10 20 00 	clr  %i0                                       
                                                                      
  the_thread = _Thread_Executing;                                     
40007ea4:	35 10 00 6c 	sethi  %hi(0x4001b000), %i2                    
40007ea8:	b4 16 a1 70 	or  %i2, 0x170, %i2	! 4001b170 <_Per_CPU_Information>
40007eac:	f8 06 a0 10 	ld  [ %i2 + 0x10 ], %i4                        
                                                                      
  /*                                                                  
   *  Initialize local variables.                                     
   */                                                                 
                                                                      
  the_info = ( info ) ? info : &signal_information;                   
40007eb0:	b2 07 bf f4 	add  %fp, -12, %i1                             
   *  What if they are already pending?                               
   */                                                                 
                                                                      
  /* API signals pending? */                                          
                                                                      
  _ISR_Disable( level );                                              
40007eb4:	7f ff ea 43 	call  400027c0 <sparc_disable_interrupts>      
40007eb8:	f6 07 21 50 	ld  [ %i4 + 0x150 ], %i3                       
40007ebc:	a0 10 00 08 	mov  %o0, %l0                                  
  if ( *set & api->signals_pending ) {                                
40007ec0:	c2 07 40 00 	ld  [ %i5 ], %g1                               
40007ec4:	c4 06 e0 d4 	ld  [ %i3 + 0xd4 ], %g2                        
40007ec8:	80 88 40 02 	btst  %g1, %g2                                 
40007ecc:	22 bf ff b3 	be,a   40007d98 <sigtimedwait+0x78>            
40007ed0:	05 10 00 6c 	sethi  %hi(0x4001b000), %g2                    
    /* XXX real info later */                                         
    the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending );
40007ed4:	7f ff ff 7b 	call  40007cc0 <_POSIX_signals_Get_lowest>     
40007ed8:	90 10 00 02 	mov  %g2, %o0                                  
    _POSIX_signals_Clear_signals(                                     
40007edc:	94 10 00 19 	mov  %i1, %o2                                  
  /* API signals pending? */                                          
                                                                      
  _ISR_Disable( level );                                              
  if ( *set & api->signals_pending ) {                                
    /* XXX real info later */                                         
    the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending );
40007ee0:	92 10 00 08 	mov  %o0, %o1                                  
40007ee4:	d0 26 40 00 	st  %o0, [ %i1 ]                               
    _POSIX_signals_Clear_signals(                                     
40007ee8:	96 10 20 00 	clr  %o3                                       
40007eec:	90 10 00 1b 	mov  %i3, %o0                                  
40007ef0:	40 00 18 46 	call  4000e008 <_POSIX_signals_Clear_signals>  
40007ef4:	98 10 20 00 	clr  %o4                                       
      the_info->si_signo,                                             
      the_info,                                                       
      false,                                                          
      false                                                           
    );                                                                
    _ISR_Enable( level );                                             
40007ef8:	7f ff ea 36 	call  400027d0 <sparc_enable_interrupts>       
40007efc:	90 10 00 10 	mov  %l0, %o0                                  
                                                                      
    the_info->si_code = SI_USER;                                      
40007f00:	82 10 20 01 	mov  1, %g1                                    
    the_info->si_value.sival_int = 0;                                 
40007f04:	c0 26 60 08 	clr  [ %i1 + 8 ]                               
      false,                                                          
      false                                                           
    );                                                                
    _ISR_Enable( level );                                             
                                                                      
    the_info->si_code = SI_USER;                                      
40007f08:	c2 26 60 04 	st  %g1, [ %i1 + 4 ]                           
    the_info->si_value.sival_int = 0;                                 
    return the_info->si_signo;                                        
40007f0c:	f0 06 40 00 	ld  [ %i1 ], %i0                               
40007f10:	81 c7 e0 08 	ret                                            
40007f14:	81 e8 00 00 	restore                                        
   * was not in our set.                                              
   */                                                                 
                                                                      
  if ( (_Thread_Executing->Wait.return_code != EINTR)                 
       || !(*set & signo_to_mask( the_info->si_signo )) ) {           
    errno = _Thread_Executing->Wait.return_code;                      
40007f18:	40 00 23 6d 	call  40010ccc <__errno>                       
40007f1c:	b0 10 3f ff 	mov  -1, %i0                                   
40007f20:	c2 06 a0 10 	ld  [ %i2 + 0x10 ], %g1                        
40007f24:	c2 00 60 34 	ld  [ %g1 + 0x34 ], %g1                        
40007f28:	c2 22 00 00 	st  %g1, [ %o0 ]                               
    return -1;                                                        
  }                                                                   
                                                                      
  return the_info->si_signo;                                          
}                                                                     
40007f2c:	81 c7 e0 08 	ret                                            
40007f30:	81 e8 00 00 	restore                                        
      rtems_set_errno_and_return_minus_one( EINVAL );                 
                                                                      
    interval = _Timespec_To_ticks( timeout );                         
                                                                      
    if ( !interval )                                                  
      rtems_set_errno_and_return_minus_one( EINVAL );                 
40007f34:	40 00 23 66 	call  40010ccc <__errno>                       
40007f38:	b0 10 3f ff 	mov  -1, %i0                                   
40007f3c:	82 10 20 16 	mov  0x16, %g1                                 
40007f40:	c2 22 00 00 	st  %g1, [ %o0 ]                               
40007f44:	81 c7 e0 08 	ret                                            
40007f48:	81 e8 00 00 	restore                                        
                                                                      

40009b4c <sigwait>: int sigwait( const sigset_t *set, int *sig ) {
40009b4c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int status;                                                         
                                                                      
  status = sigtimedwait( set, NULL, NULL );                           
40009b50:	92 10 20 00 	clr  %o1                                       
40009b54:	90 10 00 18 	mov  %i0, %o0                                  
40009b58:	7f ff ff 6e 	call  40009910 <sigtimedwait>                  
40009b5c:	94 10 20 00 	clr  %o2                                       
                                                                      
  if ( status != -1 ) {                                               
40009b60:	80 a2 3f ff 	cmp  %o0, -1                                   
40009b64:	02 80 00 07 	be  40009b80 <sigwait+0x34>                    
40009b68:	80 a6 60 00 	cmp  %i1, 0                                    
    if ( sig )                                                        
40009b6c:	02 80 00 0a 	be  40009b94 <sigwait+0x48>                    <== NEVER TAKEN
40009b70:	01 00 00 00 	nop                                            
      *sig = status;                                                  
40009b74:	d0 26 40 00 	st  %o0, [ %i1 ]                               
    return 0;                                                         
40009b78:	81 c7 e0 08 	ret                                            
40009b7c:	91 e8 20 00 	restore  %g0, 0, %o0                           
  }                                                                   
                                                                      
  return errno;                                                       
40009b80:	40 00 22 86 	call  40012598 <__errno>                       
40009b84:	01 00 00 00 	nop                                            
40009b88:	f0 02 00 00 	ld  [ %o0 ], %i0                               
40009b8c:	81 c7 e0 08 	ret                                            
40009b90:	81 e8 00 00 	restore                                        
}                                                                     
40009b94:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40009b98:	91 e8 20 00 	restore  %g0, 0, %o0                           <== NOT EXECUTED
                                                                      

40005ea0 <siproc>: /* * Process input character, with semaphore. */ static int siproc (unsigned char c, struct rtems_termios_tty *tty) {
40005ea0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int i;                                                              
                                                                      
  /*                                                                  
   * Obtain output semaphore if character will be echoed              
   */                                                                 
  if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
40005ea4:	c2 06 60 3c 	ld  [ %i1 + 0x3c ], %g1                        
40005ea8:	80 88 6e 78 	btst  0xe78, %g1                               
40005eac:	32 80 00 04 	bne,a   40005ebc <siproc+0x1c>                 <== ALWAYS TAKEN
40005eb0:	d0 06 60 18 	ld  [ %i1 + 0x18 ], %o0                        
    rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 
    i = iproc (c, tty);                                               
    rtems_semaphore_release (tty->osem);                              
  }                                                                   
  else {                                                              
    i = iproc (c, tty);                                               
40005eb4:	7f ff ff 64 	call  40005c44 <iproc>                         <== NOT EXECUTED
40005eb8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Obtain output semaphore if character will be echoed              
   */                                                                 
  if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
    rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 
40005ebc:	94 10 20 00 	clr  %o2                                       
40005ec0:	40 00 05 33 	call  4000738c <rtems_semaphore_obtain>        
40005ec4:	92 10 20 00 	clr  %o1                                       
    i = iproc (c, tty);                                               
40005ec8:	90 10 00 18 	mov  %i0, %o0                                  
40005ecc:	7f ff ff 5e 	call  40005c44 <iproc>                         
40005ed0:	92 10 00 19 	mov  %i1, %o1                                  
40005ed4:	b0 10 00 08 	mov  %o0, %i0                                  
    rtems_semaphore_release (tty->osem);                              
40005ed8:	40 00 05 7c 	call  400074c8 <rtems_semaphore_release>       
40005edc:	d0 06 60 18 	ld  [ %i1 + 0x18 ], %o0                        
40005ee0:	81 c7 e0 08 	ret                                            
40005ee4:	81 e8 00 00 	restore                                        
                                                                      

4000eb40 <sparse_disk_ioctl>: /* * ioctl handler to be passed to the block device handler */ static int sparse_disk_ioctl( rtems_disk_device *dd, uint32_t req, void *argp ) {
4000eb40:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_status_code  sc;                                              
  rtems_sparse_disk *sd = rtems_disk_get_driver_data( dd );           
                                                                      
  if ( RTEMS_BLKIO_REQUEST == req ) {                                 
4000eb44:	03 30 06 10 	sethi  %hi(0xc0184000), %g1                    
4000eb48:	82 10 62 01 	or  %g1, 0x201, %g1	! c0184201 <LEON_REG+0x40184201>
4000eb4c:	80 a6 40 01 	cmp  %i1, %g1                                  
4000eb50:	02 80 00 23 	be  4000ebdc <sparse_disk_ioctl+0x9c>          
4000eb54:	f6 06 20 3c 	ld  [ %i0 + 0x3c ], %i3                        
      case RTEMS_BLKDEV_REQ_WRITE:                                    
        return sparse_disk_read_write( sd, r, r->req == RTEMS_BLKDEV_REQ_READ );
      default:                                                        
        break;                                                        
    }                                                                 
  } else if ( RTEMS_BLKIO_DELETED == req ) {                          
4000eb58:	03 08 00 10 	sethi  %hi(0x20004000), %g1                    
4000eb5c:	82 10 62 07 	or  %g1, 0x207, %g1	! 20004207 <RAM_SIZE+0x1fc04207>
4000eb60:	80 a6 40 01 	cmp  %i1, %g1                                  
4000eb64:	02 80 00 07 	be  4000eb80 <sparse_disk_ioctl+0x40>          
4000eb68:	90 10 00 18 	mov  %i0, %o0                                  
    if ( NULL != sd->delete_handler )                                 
      ( *sd->delete_handler )( sd );                                  
                                                                      
    return 0;                                                         
  } else {                                                            
    return rtems_blkdev_ioctl( dd, req, argp );                       
4000eb6c:	92 10 00 19 	mov  %i1, %o1                                  
4000eb70:	40 00 0c ab 	call  40011e1c <rtems_blkdev_ioctl>            
4000eb74:	94 10 00 1a 	mov  %i2, %o2                                  
4000eb78:	81 c7 e0 08 	ret                                            
4000eb7c:	91 e8 00 08 	restore  %g0, %o0, %o0                         
        return sparse_disk_read_write( sd, r, r->req == RTEMS_BLKDEV_REQ_READ );
      default:                                                        
        break;                                                        
    }                                                                 
  } else if ( RTEMS_BLKIO_DELETED == req ) {                          
    sc = rtems_semaphore_delete( sd->mutex );                         
4000eb80:	7f ff e9 e7 	call  4000931c <rtems_semaphore_delete>        
4000eb84:	d0 06 c0 00 	ld  [ %i3 ], %o0                               
                                                                      
    if ( RTEMS_SUCCESSFUL != sc )                                     
4000eb88:	80 a2 20 00 	cmp  %o0, 0                                    
4000eb8c:	12 80 00 a0 	bne  4000ee0c <sparse_disk_ioctl+0x2cc>        <== NEVER TAKEN
4000eb90:	11 37 ab 6f 	sethi  %hi(0xdeadbc00), %o0                    
      rtems_fatal_error_occurred( 0xdeadbeef );                       
                                                                      
    sd->mutex = RTEMS_ID_NONE;                                        
                                                                      
    if ( NULL != sd->delete_handler )                                 
4000eb94:	c2 06 e0 10 	ld  [ %i3 + 0x10 ], %g1                        
    sc = rtems_semaphore_delete( sd->mutex );                         
                                                                      
    if ( RTEMS_SUCCESSFUL != sc )                                     
      rtems_fatal_error_occurred( 0xdeadbeef );                       
                                                                      
    sd->mutex = RTEMS_ID_NONE;                                        
4000eb98:	c0 26 c0 00 	clr  [ %i3 ]                                   
                                                                      
    if ( NULL != sd->delete_handler )                                 
4000eb9c:	80 a0 60 00 	cmp  %g1, 0                                    
4000eba0:	02 80 00 04 	be  4000ebb0 <sparse_disk_ioctl+0x70>          <== NEVER TAKEN
4000eba4:	b0 10 20 00 	clr  %i0                                       
      ( *sd->delete_handler )( sd );                                  
4000eba8:	9f c0 40 00 	call  %g1                                      
4000ebac:	90 10 00 1b 	mov  %i3, %o0                                  
4000ebb0:	81 c7 e0 08 	ret                                            
4000ebb4:	81 e8 00 00 	restore                                        
      bytes_handled += rv;                                            
      buff_size     -= rv;                                            
    }                                                                 
  }                                                                   
                                                                      
  rtems_semaphore_release( sparse_disk->mutex );                      
4000ebb8:	d0 06 c0 00 	ld  [ %i3 ], %o0                               
4000ebbc:	7f ff ea 5e 	call  40009534 <rtems_semaphore_release>       
4000ebc0:	b0 10 20 00 	clr  %i0                                       
static inline void rtems_blkdev_request_done(                         
  rtems_blkdev_request *req,                                          
  rtems_status_code status                                            
)                                                                     
{                                                                     
  (*req->done)(req, status);                                          
4000ebc4:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1                           
4000ebc8:	90 10 00 1a 	mov  %i2, %o0                                  
4000ebcc:	9f c0 40 00 	call  %g1                                      
4000ebd0:	92 10 20 00 	clr  %o1                                       
    return rtems_blkdev_ioctl( dd, req, argp );                       
  }                                                                   
                                                                      
  errno = EINVAL;                                                     
  return -1;                                                          
}                                                                     
4000ebd4:	81 c7 e0 08 	ret                                            
4000ebd8:	81 e8 00 00 	restore                                        
  rtems_sparse_disk *sd = rtems_disk_get_driver_data( dd );           
                                                                      
  if ( RTEMS_BLKIO_REQUEST == req ) {                                 
    rtems_blkdev_request *r = argp;                                   
                                                                      
    switch ( r->req ) {                                               
4000ebdc:	e6 06 80 00 	ld  [ %i2 ], %l3                               
4000ebe0:	80 a4 e0 01 	cmp  %l3, 1                                    
4000ebe4:	18 80 00 84 	bgu  4000edf4 <sparse_disk_ioctl+0x2b4>        <== NEVER TAKEN
4000ebe8:	92 10 20 00 	clr  %o1                                       
  rtems_blkdev_bnum       block;                                      
  uint8_t                *buff;                                       
  size_t                  buff_size;                                  
  unsigned int            bytes_handled;                              
                                                                      
  rtems_semaphore_obtain( sparse_disk->mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
4000ebec:	d0 06 c0 00 	ld  [ %i3 ], %o0                               
4000ebf0:	7f ff ea 02 	call  400093f8 <rtems_semaphore_obtain>        
4000ebf4:	94 10 20 00 	clr  %o2                                       
                                                                      
  /* we only need to write the block if it is different from the fill pattern.
   * If the read method does not find a block it will deliver the fill pattern anyway.
   */                                                                 
                                                                      
  key = bsearch(                                                      
4000ebf8:	25 10 00 3a 	sethi  %hi(0x4000e800), %l2                    
  size_t                  buff_size;                                  
  unsigned int            bytes_handled;                              
                                                                      
  rtems_semaphore_obtain( sparse_disk->mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
                                                                      
  for ( req_buffer = 0;                                               
4000ebfc:	a8 10 20 00 	clr  %l4                                       
static int sparse_disk_read_write(                                    
  rtems_sparse_disk    *sparse_disk,                                  
  rtems_blkdev_request *req,                                          
  const bool            read )                                        
{                                                                     
  int                     rv = 0;                                     
4000ec00:	84 10 20 00 	clr  %g2                                       
                                                                      
  /* we only need to write the block if it is different from the fill pattern.
   * If the read method does not find a block it will deliver the fill pattern anyway.
   */                                                                 
                                                                      
  key = bsearch(                                                      
4000ec04:	a4 14 a3 18 	or  %l2, 0x318, %l2                            
  unsigned int            bytes_handled;                              
                                                                      
  rtems_semaphore_obtain( sparse_disk->mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
                                                                      
  for ( req_buffer = 0;                                               
        ( 0 <= rv ) && ( req_buffer < req->bufnum );                  
4000ec08:	c2 06 a0 10 	ld  [ %i2 + 0x10 ], %g1                        
4000ec0c:	80 a0 40 14 	cmp  %g1, %l4                                  
4000ec10:	08 bf ff ea 	bleu  4000ebb8 <sparse_disk_ioctl+0x78>        
4000ec14:	87 2d 20 04 	sll  %l4, 4, %g3                               
    bytes_handled  = 0;                                               
    buff           = (uint8_t *) scatter_gather->buffer;              
    block          = scatter_gather->block;                           
    buff_size      = scatter_gather->length;                          
                                                                      
    while ( ( 0 <= rv ) && ( 0 < buff_size ) ) {                      
4000ec18:	80 a0 a0 00 	cmp  %g2, 0                                    
  rtems_semaphore_obtain( sparse_disk->mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
                                                                      
  for ( req_buffer = 0;                                               
        ( 0 <= rv ) && ( req_buffer < req->bufnum );                  
        ++req_buffer ) {                                              
    scatter_gather = &req->bufs[req_buffer];                          
4000ec1c:	86 00 e0 18 	add  %g3, 0x18, %g3                            
4000ec20:	82 06 80 03 	add  %i2, %g3, %g1                             
                                                                      
    bytes_handled  = 0;                                               
    buff           = (uint8_t *) scatter_gather->buffer;              
    block          = scatter_gather->block;                           
4000ec24:	f2 06 80 03 	ld  [ %i2 + %g3 ], %i1                         
        ( 0 <= rv ) && ( req_buffer < req->bufnum );                  
        ++req_buffer ) {                                              
    scatter_gather = &req->bufs[req_buffer];                          
                                                                      
    bytes_handled  = 0;                                               
    buff           = (uint8_t *) scatter_gather->buffer;              
4000ec28:	e2 00 60 08 	ld  [ %g1 + 8 ], %l1                           
    block          = scatter_gather->block;                           
    buff_size      = scatter_gather->length;                          
                                                                      
    while ( ( 0 <= rv ) && ( 0 < buff_size ) ) {                      
4000ec2c:	06 80 00 40 	bl  4000ed2c <sparse_disk_ioctl+0x1ec>         <== NEVER TAKEN
4000ec30:	f8 00 60 04 	ld  [ %g1 + 4 ], %i4                           
4000ec34:	80 a7 20 00 	cmp  %i4, 0                                    
4000ec38:	02 80 00 3d 	be  4000ed2c <sparse_disk_ioctl+0x1ec>         <== NEVER TAKEN
4000ec3c:	b0 10 20 00 	clr  %i0                                       
  const rtems_blkdev_bnum  block,                                     
  uint8_t                 *buffer,                                    
  const size_t             buffer_size )                              
{                                                                     
  rtems_sparse_disk_key *key;                                         
  rtems_sparse_disk_key  block_key = {                                
4000ec40:	10 80 00 1d 	b  4000ecb4 <sparse_disk_ioctl+0x174>          
4000ec44:	f2 27 bf f8 	st  %i1, [ %fp + -8 ]                          
4000ec48:	80 a7 00 01 	cmp  %i4, %g1                                  
4000ec4c:	38 80 00 02 	bgu,a   4000ec54 <sparse_disk_ioctl+0x114>     
4000ec50:	ba 10 00 01 	mov  %g1, %i5                                  
  size_t                 bytes_to_copy = sparse_disk->media_block_size;
                                                                      
  if ( buffer_size < bytes_to_copy )                                  
    bytes_to_copy = buffer_size;                                      
                                                                      
  key = bsearch(                                                      
4000ec54:	d2 06 e0 18 	ld  [ %i3 + 0x18 ], %o1                        
4000ec58:	d4 06 e0 08 	ld  [ %i3 + 8 ], %o2                           
4000ec5c:	90 07 bf f8 	add  %fp, -8, %o0                              
4000ec60:	96 10 20 08 	mov  8, %o3                                    
4000ec64:	40 00 35 a9 	call  4001c308 <bsearch>                       
4000ec68:	98 10 00 12 	mov  %l2, %o4                                  
    sparse_disk->used_count,                                          
    sizeof( rtems_sparse_disk_key ),                                  
    sparse_disk_compare                                               
    );                                                                
                                                                      
  if ( NULL != key )                                                  
4000ec6c:	80 a2 20 00 	cmp  %o0, 0                                    
4000ec70:	02 80 00 29 	be  4000ed14 <sparse_disk_ioctl+0x1d4>         
4000ec74:	94 10 00 1d 	mov  %i5, %o2                                  
    memcpy( buffer, key->data, bytes_to_copy );                       
4000ec78:	d2 02 20 04 	ld  [ %o0 + 4 ], %o1                           
4000ec7c:	40 00 38 6a 	call  4001ce24 <memcpy>                        
4000ec80:	90 10 00 10 	mov  %l0, %o0                                  
4000ec84:	b8 27 00 1d 	sub  %i4, %i5, %i4                             
4000ec88:	82 38 00 1d 	xnor  %g0, %i5, %g1                            
4000ec8c:	80 a0 00 1c 	cmp  %g0, %i4                                  
4000ec90:	83 30 60 1f 	srl  %g1, 0x1f, %g1                            
4000ec94:	86 40 20 00 	addx  %g0, 0, %g3                              
  if ( NULL != key )                                                  
    memcpy( key->data, buffer, bytes_to_copy );                       
  else if ( block_needs_writing )                                     
    return -1;                                                        
                                                                      
  return bytes_to_copy;                                               
4000ec98:	84 10 00 1d 	mov  %i5, %g2                                  
4000ec9c:	82 08 c0 01 	and  %g3, %g1, %g1                             
        rv = sparse_disk_write_block( sparse_disk,                    
                                      block,                          
                                      &buff[bytes_handled],           
                                      buff_size );                    
                                                                      
      ++block;                                                        
4000eca0:	b2 06 60 01 	inc  %i1                                       
    bytes_handled  = 0;                                               
    buff           = (uint8_t *) scatter_gather->buffer;              
    block          = scatter_gather->block;                           
    buff_size      = scatter_gather->length;                          
                                                                      
    while ( ( 0 <= rv ) && ( 0 < buff_size ) ) {                      
4000eca4:	80 88 60 ff 	btst  0xff, %g1                                
4000eca8:	02 80 00 21 	be  4000ed2c <sparse_disk_ioctl+0x1ec>         
4000ecac:	b0 06 00 1d 	add  %i0, %i5, %i0                             
  const rtems_blkdev_bnum  block,                                     
  uint8_t                 *buffer,                                    
  const size_t             buffer_size )                              
{                                                                     
  rtems_sparse_disk_key *key;                                         
  rtems_sparse_disk_key  block_key = {                                
4000ecb0:	f2 27 bf f8 	st  %i1, [ %fp + -8 ]                          
    .block = block,                                                   
    .data  = NULL                                                     
  };                                                                  
  size_t                 bytes_to_copy = sparse_disk->media_block_size;
4000ecb4:	c2 06 e0 0c 	ld  [ %i3 + 0xc ], %g1                         
  const rtems_blkdev_bnum  block,                                     
  uint8_t                 *buffer,                                    
  const size_t             buffer_size )                              
{                                                                     
  rtems_sparse_disk_key *key;                                         
  rtems_sparse_disk_key  block_key = {                                
4000ecb8:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
    block          = scatter_gather->block;                           
    buff_size      = scatter_gather->length;                          
                                                                      
    while ( ( 0 <= rv ) && ( 0 < buff_size ) ) {                      
      if ( read )                                                     
        rv = sparse_disk_read_block( sparse_disk,                     
4000ecbc:	a0 04 40 18 	add  %l1, %i0, %l0                             
    buff           = (uint8_t *) scatter_gather->buffer;              
    block          = scatter_gather->block;                           
    buff_size      = scatter_gather->length;                          
                                                                      
    while ( ( 0 <= rv ) && ( 0 < buff_size ) ) {                      
      if ( read )                                                     
4000ecc0:	80 a4 e0 00 	cmp  %l3, 0                                    
4000ecc4:	02 bf ff e1 	be  4000ec48 <sparse_disk_ioctl+0x108>         
4000ecc8:	ba 10 00 1c 	mov  %i4, %i5                                  
4000eccc:	80 a7 00 01 	cmp  %i4, %g1                                  
4000ecd0:	38 80 00 02 	bgu,a   4000ecd8 <sparse_disk_ioctl+0x198>     
4000ecd4:	ba 10 00 01 	mov  %g1, %i5                                  
                                                                      
  /* we only need to write the block if it is different from the fill pattern.
   * If the read method does not find a block it will deliver the fill pattern anyway.
   */                                                                 
                                                                      
  key = bsearch(                                                      
4000ecd8:	d2 06 e0 18 	ld  [ %i3 + 0x18 ], %o1                        
4000ecdc:	d4 06 e0 08 	ld  [ %i3 + 8 ], %o2                           
4000ece0:	90 07 bf f8 	add  %fp, -8, %o0                              
4000ece4:	96 10 20 08 	mov  8, %o3                                    
4000ece8:	40 00 35 88 	call  4001c308 <bsearch>                       
4000ecec:	98 10 00 12 	mov  %l2, %o4                                  
    sparse_disk->used_count,                                          
    sizeof( rtems_sparse_disk_key ),                                  
    sparse_disk_compare                                               
    );                                                                
                                                                      
  if ( NULL == key ) {                                                
4000ecf0:	aa 92 20 00 	orcc  %o0, 0, %l5                              
4000ecf4:	02 80 00 1a 	be  4000ed5c <sparse_disk_ioctl+0x21c>         
4000ecf8:	80 a7 60 00 	cmp  %i5, 0                                    
      key = sparse_disk_get_new_block( sparse_disk, block );          
    }                                                                 
  }                                                                   
                                                                      
  if ( NULL != key )                                                  
    memcpy( key->data, buffer, bytes_to_copy );                       
4000ecfc:	d0 05 60 04 	ld  [ %l5 + 4 ], %o0                           
4000ed00:	92 10 00 10 	mov  %l0, %o1                                  
4000ed04:	40 00 38 48 	call  4001ce24 <memcpy>                        
4000ed08:	94 10 00 1d 	mov  %i5, %o2                                  
4000ed0c:	10 bf ff df 	b  4000ec88 <sparse_disk_ioctl+0x148>          
4000ed10:	b8 27 00 1d 	sub  %i4, %i5, %i4                             
    );                                                                
                                                                      
  if ( NULL != key )                                                  
    memcpy( buffer, key->data, bytes_to_copy );                       
  else                                                                
    memset( buffer, sparse_disk->fill_pattern, buffer_size );         
4000ed14:	d2 0e e0 14 	ldub  [ %i3 + 0x14 ], %o1                      
4000ed18:	90 10 00 10 	mov  %l0, %o0                                  
4000ed1c:	40 00 38 7f 	call  4001cf18 <memset>                        
4000ed20:	94 10 00 1c 	mov  %i4, %o2                                  
4000ed24:	10 bf ff d9 	b  4000ec88 <sparse_disk_ioctl+0x148>          
4000ed28:	b8 27 00 1d 	sub  %i4, %i5, %i4                             
  size_t                  buff_size;                                  
  unsigned int            bytes_handled;                              
                                                                      
  rtems_semaphore_obtain( sparse_disk->mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
                                                                      
  for ( req_buffer = 0;                                               
4000ed2c:	80 a0 a0 00 	cmp  %g2, 0                                    
4000ed30:	16 bf ff b6 	bge  4000ec08 <sparse_disk_ioctl+0xc8>         <== ALWAYS TAKEN
4000ed34:	a8 05 20 01 	inc  %l4                                       
      bytes_handled += rv;                                            
      buff_size     -= rv;                                            
    }                                                                 
  }                                                                   
                                                                      
  rtems_semaphore_release( sparse_disk->mutex );                      
4000ed38:	d0 06 c0 00 	ld  [ %i3 ], %o0                               <== NOT EXECUTED
4000ed3c:	7f ff e9 fe 	call  40009534 <rtems_semaphore_release>       <== NOT EXECUTED
4000ed40:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
4000ed44:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1                           <== NOT EXECUTED
4000ed48:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
4000ed4c:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
4000ed50:	92 10 20 1b 	mov  0x1b, %o1                                 <== NOT EXECUTED
4000ed54:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000ed58:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    sizeof( rtems_sparse_disk_key ),                                  
    sparse_disk_compare                                               
    );                                                                
                                                                      
  if ( NULL == key ) {                                                
    for ( i = 0; ( !block_needs_writing ) && ( i < bytes_to_copy ); ++i ) {
4000ed5c:	02 bf ff ca 	be  4000ec84 <sparse_disk_ioctl+0x144>         <== NEVER TAKEN
4000ed60:	82 10 20 00 	clr  %g1                                       
4000ed64:	10 80 00 05 	b  4000ed78 <sparse_disk_ioctl+0x238>          
4000ed68:	c8 0e e0 14 	ldub  [ %i3 + 0x14 ], %g4                      
4000ed6c:	80 a0 40 1d 	cmp  %g1, %i5                                  
4000ed70:	1a 80 00 0b 	bcc  4000ed9c <sparse_disk_ioctl+0x25c>        
4000ed74:	80 88 e0 ff 	btst  0xff, %g3                                
      if ( buffer[i] != sparse_disk->fill_pattern )                   
4000ed78:	c4 0c 00 01 	ldub  [ %l0 + %g1 ], %g2                       
    sizeof( rtems_sparse_disk_key ),                                  
    sparse_disk_compare                                               
    );                                                                
                                                                      
  if ( NULL == key ) {                                                
    for ( i = 0; ( !block_needs_writing ) && ( i < bytes_to_copy ); ++i ) {
4000ed7c:	82 00 60 01 	inc  %g1                                       
      if ( buffer[i] != sparse_disk->fill_pattern )                   
4000ed80:	84 18 80 04 	xor  %g2, %g4, %g2                             
4000ed84:	80 a0 00 02 	cmp  %g0, %g2                                  
4000ed88:	84 40 20 00 	addx  %g0, 0, %g2                              
    sizeof( rtems_sparse_disk_key ),                                  
    sparse_disk_compare                                               
    );                                                                
                                                                      
  if ( NULL == key ) {                                                
    for ( i = 0; ( !block_needs_writing ) && ( i < bytes_to_copy ); ++i ) {
4000ed8c:	80 a0 a0 00 	cmp  %g2, 0                                    
4000ed90:	02 bf ff f7 	be  4000ed6c <sparse_disk_ioctl+0x22c>         
4000ed94:	86 10 00 02 	mov  %g2, %g3                                  
      if ( buffer[i] != sparse_disk->fill_pattern )                   
        block_needs_writing = true;                                   
    }                                                                 
                                                                      
    if ( block_needs_writing ) {                                      
4000ed98:	80 88 e0 ff 	btst  0xff, %g3                                
4000ed9c:	22 bf ff bb 	be,a   4000ec88 <sparse_disk_ioctl+0x148>      
4000eda0:	b8 27 00 1d 	sub  %i4, %i5, %i4                             
  rtems_sparse_disk      *sparse_disk,                                
  const rtems_blkdev_bnum block )                                     
{                                                                     
  rtems_sparse_disk_key *key;                                         
                                                                      
  if ( sparse_disk->used_count < sparse_disk->blocks_with_buffer ) {  
4000eda4:	c2 06 e0 08 	ld  [ %i3 + 8 ], %g1                           
4000eda8:	c4 06 e0 04 	ld  [ %i3 + 4 ], %g2                           
4000edac:	80 a0 40 02 	cmp  %g1, %g2                                  
4000edb0:	1a 80 00 0c 	bcc  4000ede0 <sparse_disk_ioctl+0x2a0>        <== NEVER TAKEN
4000edb4:	ab 28 60 03 	sll  %g1, 3, %l5                               
    key        = &sparse_disk->key_table[sparse_disk->used_count];    
4000edb8:	d0 06 e0 18 	ld  [ %i3 + 0x18 ], %o0                        
    key->block = block;                                               
4000edbc:	f2 22 00 15 	st  %i1, [ %o0 + %l5 ]                         
    ++sparse_disk->used_count;                                        
4000edc0:	92 00 60 01 	add  %g1, 1, %o1                               
  const rtems_blkdev_bnum block )                                     
{                                                                     
  rtems_sparse_disk_key *key;                                         
                                                                      
  if ( sparse_disk->used_count < sparse_disk->blocks_with_buffer ) {  
    key        = &sparse_disk->key_table[sparse_disk->used_count];    
4000edc4:	aa 02 00 15 	add  %o0, %l5, %l5                             
    key->block = block;                                               
    ++sparse_disk->used_count;                                        
4000edc8:	d2 26 e0 08 	st  %o1, [ %i3 + 8 ]                           
    qsort( sparse_disk->key_table, sparse_disk->used_count,           
4000edcc:	94 10 20 08 	mov  8, %o2                                    
4000edd0:	40 00 38 98 	call  4001d030 <qsort>                         
4000edd4:	96 10 00 12 	mov  %l2, %o3                                  
      key = sparse_disk_get_new_block( sparse_disk, block );          
    }                                                                 
  }                                                                   
                                                                      
  if ( NULL != key )                                                  
    memcpy( key->data, buffer, bytes_to_copy );                       
4000edd8:	10 bf ff ca 	b  4000ed00 <sparse_disk_ioctl+0x1c0>          
4000eddc:	d0 05 60 04 	ld  [ %l5 + 4 ], %o0                           
4000ede0:	b8 07 20 01 	inc  %i4                                       <== NOT EXECUTED
  rtems_sparse_disk      *sparse_disk,                                
  const rtems_blkdev_bnum block )                                     
{                                                                     
  rtems_sparse_disk_key *key;                                         
                                                                      
  if ( sparse_disk->used_count < sparse_disk->blocks_with_buffer ) {  
4000ede4:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
4000ede8:	ba 10 3f ff 	mov  -1, %i5                                   <== NOT EXECUTED
  }                                                                   
                                                                      
  if ( NULL != key )                                                  
    memcpy( key->data, buffer, bytes_to_copy );                       
  else if ( block_needs_writing )                                     
    return -1;                                                        
4000edec:	10 bf ff ad 	b  4000eca0 <sparse_disk_ioctl+0x160>          <== NOT EXECUTED
4000edf0:	84 10 3f ff 	mov  -1, %g2                                   <== NOT EXECUTED
    return 0;                                                         
  } else {                                                            
    return rtems_blkdev_ioctl( dd, req, argp );                       
  }                                                                   
                                                                      
  errno = EINVAL;                                                     
4000edf4:	40 00 35 67 	call  4001c390 <__errno>                       <== NOT EXECUTED
4000edf8:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4000edfc:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
4000ee00:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
  return -1;                                                          
4000ee04:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000ee08:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    }                                                                 
  } else if ( RTEMS_BLKIO_DELETED == req ) {                          
    sc = rtems_semaphore_delete( sd->mutex );                         
                                                                      
    if ( RTEMS_SUCCESSFUL != sc )                                     
      rtems_fatal_error_occurred( 0xdeadbeef );                       
4000ee0c:	7f ff eb 5c 	call  40009b7c <rtems_fatal_error_occurred>    <== NOT EXECUTED
4000ee10:	90 12 22 ef 	or  %o0, 0x2ef, %o0                            <== NOT EXECUTED
                                                                      

40005574 <sync_per_thread>: fdatasync(fn); } /* iterate over all FILE *'s for this thread */ static void sync_per_thread(Thread_Control *t) {
40005574:	9d e3 bf a0 	save  %sp, -96, %sp                            
                                                                      
   /*                                                                 
    *  The sync_wrapper() function will operate on the current thread's
    *  reent structure so we will temporarily use that.               
    */                                                                
   this_reent = t->libc_reent;                                        
40005578:	c2 06 21 48 	ld  [ %i0 + 0x148 ], %g1                       
   if ( this_reent ) {                                                
4000557c:	80 a0 60 00 	cmp  %g1, 0                                    
40005580:	02 80 00 0c 	be  400055b0 <sync_per_thread+0x3c>            <== NEVER TAKEN
40005584:	3b 10 00 62 	sethi  %hi(0x40018800), %i5                    
     current_reent = _Thread_Executing->libc_reent;                   
40005588:	ba 17 61 e0 	or  %i5, 0x1e0, %i5	! 400189e0 <_Per_CPU_Information>
4000558c:	c4 07 60 10 	ld  [ %i5 + 0x10 ], %g2                        
     _Thread_Executing->libc_reent = this_reent;                      
     _fwalk (t->libc_reent, sync_wrapper);                            
40005590:	13 10 00 15 	sethi  %hi(0x40005400), %o1                    
    *  The sync_wrapper() function will operate on the current thread's
    *  reent structure so we will temporarily use that.               
    */                                                                
   this_reent = t->libc_reent;                                        
   if ( this_reent ) {                                                
     current_reent = _Thread_Executing->libc_reent;                   
40005594:	f8 00 a1 48 	ld  [ %g2 + 0x148 ], %i4                       
     _Thread_Executing->libc_reent = this_reent;                      
40005598:	c2 20 a1 48 	st  %g1, [ %g2 + 0x148 ]                       
     _fwalk (t->libc_reent, sync_wrapper);                            
4000559c:	d0 06 21 48 	ld  [ %i0 + 0x148 ], %o0                       
400055a0:	40 00 2e eb 	call  4001114c <_fwalk>                        
400055a4:	92 12 61 b8 	or  %o1, 0x1b8, %o1                            
     _Thread_Executing->libc_reent = current_reent;                   
400055a8:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
400055ac:	f8 20 61 48 	st  %i4, [ %g1 + 0x148 ]                       
400055b0:	81 c7 e0 08 	ret                                            
400055b4:	81 e8 00 00 	restore                                        
                                                                      

400069c8 <sysconf>: */ long sysconf( int name ) {
400069c8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if ( name == _SC_CLK_TCK )                                          
400069cc:	80 a6 20 02 	cmp  %i0, 2                                    
400069d0:	02 80 00 12 	be  40006a18 <sysconf+0x50>                    
400069d4:	82 10 00 18 	mov  %i0, %g1                                  
    return (TOD_MICROSECONDS_PER_SECOND /                             
      rtems_configuration_get_microseconds_per_tick());               
                                                                      
  if ( name == _SC_OPEN_MAX )                                         
400069d8:	80 a6 20 04 	cmp  %i0, 4                                    
400069dc:	02 80 00 16 	be  40006a34 <sysconf+0x6c>                    
400069e0:	80 a0 60 33 	cmp  %g1, 0x33                                 
    return rtems_libio_number_iops;                                   
                                                                      
  if ( name == _SC_GETPW_R_SIZE_MAX )                                 
400069e4:	02 80 00 0b 	be  40006a10 <sysconf+0x48>                    
400069e8:	b0 10 24 00 	mov  0x400, %i0                                
    return 1024;                                                      
                                                                      
  if ( name == _SC_PAGESIZE )                                         
400069ec:	80 a0 60 08 	cmp  %g1, 8                                    
400069f0:	02 80 00 08 	be  40006a10 <sysconf+0x48>                    
400069f4:	31 00 00 04 	sethi  %hi(0x1000), %i0                        
    return PAGE_SIZE;                                                 
                                                                      
  if ( name == _SC_SYMLOOP_MAX )                                      
400069f8:	80 a0 60 4f 	cmp  %g1, 0x4f                                 
400069fc:	02 80 00 05 	be  40006a10 <sysconf+0x48>                    <== NEVER TAKEN
40006a00:	b0 10 20 20 	mov  0x20, %i0                                 
    return RTEMS_FILESYSTEM_SYMLOOP_MAX;                              
                                                                      
#if defined(__sparc__)                                                
  if ( name == 515 ) /* Solaris _SC_STACK_PROT */                     
40006a04:	80 a0 62 03 	cmp  %g1, 0x203                                
40006a08:	12 80 00 0f 	bne  40006a44 <sysconf+0x7c>                   <== ALWAYS TAKEN
40006a0c:	b0 10 20 00 	clr  %i0                                       
   return 0;                                                          
#endif                                                                
                                                                      
  rtems_set_errno_and_return_minus_one( EINVAL );                     
}                                                                     
40006a10:	81 c7 e0 08 	ret                                            
40006a14:	81 e8 00 00 	restore                                        
  int name                                                            
)                                                                     
{                                                                     
  if ( name == _SC_CLK_TCK )                                          
    return (TOD_MICROSECONDS_PER_SECOND /                             
      rtems_configuration_get_microseconds_per_tick());               
40006a18:	03 10 00 56 	sethi  %hi(0x40015800), %g1                    
long sysconf(                                                         
  int name                                                            
)                                                                     
{                                                                     
  if ( name == _SC_CLK_TCK )                                          
    return (TOD_MICROSECONDS_PER_SECOND /                             
40006a1c:	d2 00 60 b4 	ld  [ %g1 + 0xb4 ], %o1	! 400158b4 <Configuration+0xc>
40006a20:	11 00 03 d0 	sethi  %hi(0xf4000), %o0                       
40006a24:	40 00 32 7c 	call  40013414 <.udiv>                         
40006a28:	90 12 22 40 	or  %o0, 0x240, %o0	! f4240 <PROM_START+0xf4240>
40006a2c:	81 c7 e0 08 	ret                                            
40006a30:	91 e8 00 08 	restore  %g0, %o0, %o0                         
      rtems_configuration_get_microseconds_per_tick());               
                                                                      
  if ( name == _SC_OPEN_MAX )                                         
    return rtems_libio_number_iops;                                   
40006a34:	03 10 00 5c 	sethi  %hi(0x40017000), %g1                    
40006a38:	f0 00 60 e8 	ld  [ %g1 + 0xe8 ], %i0	! 400170e8 <rtems_libio_number_iops>
40006a3c:	81 c7 e0 08 	ret                                            
40006a40:	81 e8 00 00 	restore                                        
#if defined(__sparc__)                                                
  if ( name == 515 ) /* Solaris _SC_STACK_PROT */                     
   return 0;                                                          
#endif                                                                
                                                                      
  rtems_set_errno_and_return_minus_one( EINVAL );                     
40006a44:	40 00 23 23 	call  4000f6d0 <__errno>                       
40006a48:	b0 10 3f ff 	mov  -1, %i0                                   
40006a4c:	82 10 20 16 	mov  0x16, %g1                                 
40006a50:	c2 22 00 00 	st  %g1, [ %o0 ]                               
}                                                                     
40006a54:	81 c7 e0 08 	ret                                            
40006a58:	81 e8 00 00 	restore                                        
                                                                      

40015c50 <tcsetattr>: int tcsetattr( int fd, int opt, struct termios *tp ) {
40015c50:	9d e3 bf a0 	save  %sp, -96, %sp                            
  switch (opt) {                                                      
40015c54:	80 a6 60 00 	cmp  %i1, 0                                    
40015c58:	02 80 00 10 	be  40015c98 <tcsetattr+0x48>                  
40015c5c:	80 a6 60 01 	cmp  %i1, 1                                    
40015c60:	02 80 00 08 	be  40015c80 <tcsetattr+0x30>                  
40015c64:	90 10 00 18 	mov  %i0, %o0                                  
  default:                                                            
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
40015c68:	40 00 12 20 	call  4001a4e8 <__errno>                       
40015c6c:	01 00 00 00 	nop                                            
40015c70:	82 10 20 86 	mov  0x86, %g1	! 86 <PROM_START+0x86>          
40015c74:	c2 22 00 00 	st  %g1, [ %o0 ]                               
     * Fall through to....                                            
     */                                                               
  case TCSANOW:                                                       
    return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );                  
  }                                                                   
}                                                                     
40015c78:	81 c7 e0 08 	ret                                            
40015c7c:	91 e8 3f ff 	restore  %g0, -1, %o0                          
  switch (opt) {                                                      
  default:                                                            
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
                                                                      
  case TCSADRAIN:                                                     
    if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0)                      
40015c80:	92 10 20 03 	mov  3, %o1                                    
40015c84:	40 00 0e 82 	call  4001968c <ioctl>                         
40015c88:	94 10 20 00 	clr  %o2                                       
40015c8c:	80 a2 20 00 	cmp  %o0, 0                                    
40015c90:	06 bf ff fa 	bl  40015c78 <tcsetattr+0x28>                  <== NEVER TAKEN
40015c94:	01 00 00 00 	nop                                            
    	return -1;                                                       
    /*                                                                
     * Fall through to....                                            
     */                                                               
  case TCSANOW:                                                       
    return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );                  
40015c98:	40 00 0e 7d 	call  4001968c <ioctl>                         
40015c9c:	93 e8 20 02 	restore  %g0, 2, %o1                           
                                                                      

40008250 <timer_create>: int timer_create( clockid_t clock_id, struct sigevent *evp, timer_t *timerid ) {
40008250:	9d e3 bf a0 	save  %sp, -96, %sp                            
  POSIX_Timer_Control *ptimer;                                        
                                                                      
  if ( clock_id != CLOCK_REALTIME )                                   
40008254:	80 a6 20 01 	cmp  %i0, 1                                    
40008258:	12 80 00 3d 	bne  4000834c <timer_create+0xfc>              
4000825c:	80 a6 a0 00 	cmp  %i2, 0                                    
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( !timerid )                                                     
40008260:	02 80 00 3b 	be  4000834c <timer_create+0xfc>               
40008264:	80 a6 60 00 	cmp  %i1, 0                                    
 /*                                                                   
  *  The data of the structure evp are checked in order to verify if they
  *  are coherent.                                                    
  */                                                                  
                                                                      
  if (evp != NULL) {                                                  
40008268:	02 80 00 0e 	be  400082a0 <timer_create+0x50>               
4000826c:	03 10 00 8e 	sethi  %hi(0x40023800), %g1                    
    /* The structure has data */                                      
    if ( ( evp->sigev_notify != SIGEV_NONE ) &&                       
40008270:	c2 06 40 00 	ld  [ %i1 ], %g1                               
40008274:	82 00 7f ff 	add  %g1, -1, %g1                              
40008278:	80 a0 60 01 	cmp  %g1, 1                                    
4000827c:	18 80 00 34 	bgu  4000834c <timer_create+0xfc>              <== NEVER TAKEN
40008280:	01 00 00 00 	nop                                            
         ( evp->sigev_notify != SIGEV_SIGNAL ) ) {                    
       /* The value of the field sigev_notify is not valid */         
       rtems_set_errno_and_return_minus_one( EINVAL );                
     }                                                                
                                                                      
     if ( !evp->sigev_signo )                                         
40008284:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
40008288:	80 a0 60 00 	cmp  %g1, 0                                    
4000828c:	02 80 00 30 	be  4000834c <timer_create+0xfc>               <== NEVER TAKEN
40008290:	82 00 7f ff 	add  %g1, -1, %g1                              
       rtems_set_errno_and_return_minus_one( EINVAL );                
                                                                      
     if ( !is_valid_signo(evp->sigev_signo) )                         
40008294:	80 a0 60 1f 	cmp  %g1, 0x1f                                 
40008298:	18 80 00 2d 	bgu  4000834c <timer_create+0xfc>              <== NEVER TAKEN
4000829c:	03 10 00 8e 	sethi  %hi(0x40023800), %g1                    
   *                                                                  
   * This rountine increments the thread dispatch level               
   */                                                                 
  RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
  {                                                                   
    uint32_t level = _Thread_Dispatch_disable_level;                  
400082a0:	c4 00 60 c0 	ld  [ %g1 + 0xc0 ], %g2	! 400238c0 <_Thread_Dispatch_disable_level>
                                                                      
    ++level;                                                          
400082a4:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
400082a8:	c4 20 60 c0 	st  %g2, [ %g1 + 0xc0 ]                        
 *  the inactive chain of free timer control blocks.                  
 */                                                                   
                                                                      
RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Allocate( void )
{                                                                     
  return (POSIX_Timer_Control *) _Objects_Allocate( &_POSIX_Timer_Information );
400082ac:	3b 10 00 8e 	sethi  %hi(0x40023800), %i5                    
400082b0:	40 00 08 e0 	call  4000a630 <_Objects_Allocate>             
400082b4:	90 17 63 c4 	or  %i5, 0x3c4, %o0	! 40023bc4 <_POSIX_Timer_Information>
                                                                      
  /*                                                                  
   *  Allocate a timer                                                
   */                                                                 
  ptimer = _POSIX_Timer_Allocate();                                   
  if ( !ptimer ) {                                                    
400082b8:	80 a2 20 00 	cmp  %o0, 0                                    
400082bc:	02 80 00 2a 	be  40008364 <timer_create+0x114>              
400082c0:	82 10 20 02 	mov  2, %g1                                    
    rtems_set_errno_and_return_minus_one( EAGAIN );                   
  }                                                                   
                                                                      
  /* The data of the created timer are stored to use them later */    
                                                                      
  ptimer->state     = POSIX_TIMER_STATE_CREATE_NEW;                   
400082c4:	c2 2a 20 3c 	stb  %g1, [ %o0 + 0x3c ]                       
  ptimer->thread_id = _Thread_Executing->Object.id;                   
400082c8:	03 10 00 8f 	sethi  %hi(0x40023c00), %g1                    
400082cc:	c2 00 62 20 	ld  [ %g1 + 0x220 ], %g1	! 40023e20 <_Per_CPU_Information+0x10>
                                                                      
  if ( evp != NULL ) {                                                
400082d0:	80 a6 60 00 	cmp  %i1, 0                                    
  }                                                                   
                                                                      
  /* The data of the created timer are stored to use them later */    
                                                                      
  ptimer->state     = POSIX_TIMER_STATE_CREATE_NEW;                   
  ptimer->thread_id = _Thread_Executing->Object.id;                   
400082d4:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
                                                                      
  if ( evp != NULL ) {                                                
400082d8:	02 80 00 08 	be  400082f8 <timer_create+0xa8>               
400082dc:	c2 22 20 38 	st  %g1, [ %o0 + 0x38 ]                        
    ptimer->inf.sigev_notify = evp->sigev_notify;                     
400082e0:	c6 06 40 00 	ld  [ %i1 ], %g3                               
    ptimer->inf.sigev_signo  = evp->sigev_signo;                      
400082e4:	c4 06 60 04 	ld  [ %i1 + 4 ], %g2                           
    ptimer->inf.sigev_value  = evp->sigev_value;                      
400082e8:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
                                                                      
  ptimer->state     = POSIX_TIMER_STATE_CREATE_NEW;                   
  ptimer->thread_id = _Thread_Executing->Object.id;                   
                                                                      
  if ( evp != NULL ) {                                                
    ptimer->inf.sigev_notify = evp->sigev_notify;                     
400082ec:	c6 22 20 40 	st  %g3, [ %o0 + 0x40 ]                        
    ptimer->inf.sigev_signo  = evp->sigev_signo;                      
400082f0:	c4 22 20 44 	st  %g2, [ %o0 + 0x44 ]                        
    ptimer->inf.sigev_value  = evp->sigev_value;                      
400082f4:	c2 22 20 48 	st  %g1, [ %o0 + 0x48 ]                        
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  uint32_t             name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
400082f8:	c4 12 20 0a 	lduh  [ %o0 + 0xa ], %g2                       
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
400082fc:	ba 17 63 c4 	or  %i5, 0x3c4, %i5                            
40008300:	c6 07 60 1c 	ld  [ %i5 + 0x1c ], %g3                        
  }                                                                   
                                                                      
  ptimer->overrun  = 0;                                               
40008304:	c0 22 20 68 	clr  [ %o0 + 0x68 ]                            
  ptimer->timer_data.it_value.tv_sec     = 0;                         
40008308:	c0 22 20 5c 	clr  [ %o0 + 0x5c ]                            
  ptimer->timer_data.it_value.tv_nsec    = 0;                         
4000830c:	c0 22 20 60 	clr  [ %o0 + 0x60 ]                            
  ptimer->timer_data.it_interval.tv_sec  = 0;                         
40008310:	c0 22 20 54 	clr  [ %o0 + 0x54 ]                            
  ptimer->timer_data.it_interval.tv_nsec = 0;                         
40008314:	c0 22 20 58 	clr  [ %o0 + 0x58 ]                            
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
40008318:	c0 22 20 18 	clr  [ %o0 + 0x18 ]                            
  the_watchdog->routine   = routine;                                  
4000831c:	c0 22 20 2c 	clr  [ %o0 + 0x2c ]                            
  the_watchdog->id        = id;                                       
40008320:	c0 22 20 30 	clr  [ %o0 + 0x30 ]                            
  the_watchdog->user_data = user_data;                                
40008324:	c0 22 20 34 	clr  [ %o0 + 0x34 ]                            
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  uint32_t             name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
40008328:	c2 02 20 08 	ld  [ %o0 + 8 ], %g1                           
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
4000832c:	85 28 a0 02 	sll  %g2, 2, %g2                               
40008330:	d0 20 c0 02 	st  %o0, [ %g3 + %g2 ]                         
    _Objects_Get_index( the_object->id ),                             
    the_object                                                        
  );                                                                  
                                                                      
  /* ASSERT: information->is_string == false */                       
  the_object->name.name_u32 = name;                                   
40008334:	c0 22 20 0c 	clr  [ %o0 + 0xc ]                             
                                                                      
  _Watchdog_Initialize( &ptimer->Timer, NULL, 0, NULL );              
  _Objects_Open_u32(&_POSIX_Timer_Information, &ptimer->Object, 0);   
                                                                      
  *timerid  = ptimer->Object.id;                                      
40008338:	c2 26 80 00 	st  %g1, [ %i2 ]                               
  _Thread_Enable_dispatch();                                          
4000833c:	40 00 0e 09 	call  4000bb60 <_Thread_Enable_dispatch>       
40008340:	b0 10 20 00 	clr  %i0                                       
  return 0;                                                           
}                                                                     
40008344:	81 c7 e0 08 	ret                                            
40008348:	81 e8 00 00 	restore                                        
                                                                      
     if ( !evp->sigev_signo )                                         
       rtems_set_errno_and_return_minus_one( EINVAL );                
                                                                      
     if ( !is_valid_signo(evp->sigev_signo) )                         
       rtems_set_errno_and_return_minus_one( EINVAL );                
4000834c:	40 00 24 c4 	call  4001165c <__errno>                       
40008350:	b0 10 3f ff 	mov  -1, %i0                                   
40008354:	82 10 20 16 	mov  0x16, %g1                                 
40008358:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4000835c:	81 c7 e0 08 	ret                                            
40008360:	81 e8 00 00 	restore                                        
  /*                                                                  
   *  Allocate a timer                                                
   */                                                                 
  ptimer = _POSIX_Timer_Allocate();                                   
  if ( !ptimer ) {                                                    
    _Thread_Enable_dispatch();                                        
40008364:	40 00 0d ff 	call  4000bb60 <_Thread_Enable_dispatch>       
40008368:	b0 10 3f ff 	mov  -1, %i0                                   
    rtems_set_errno_and_return_minus_one( EAGAIN );                   
4000836c:	40 00 24 bc 	call  4001165c <__errno>                       
40008370:	01 00 00 00 	nop                                            
40008374:	82 10 20 0b 	mov  0xb, %g1	! b <PROM_START+0xb>             
40008378:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4000837c:	81 c7 e0 08 	ret                                            
40008380:	81 e8 00 00 	restore                                        
                                                                      

40006ea8 <timer_settime>: timer_t timerid, int flags, const struct itimerspec *value, struct itimerspec *ovalue ) {
40006ea8:	9d e3 bf 78 	save  %sp, -136, %sp                           
  Objects_Locations    location;                                      
  bool                 activated;                                     
  uint32_t             initial_period;                                
  struct itimerspec    normalize;                                     
                                                                      
  if ( !value )                                                       
40006eac:	80 a6 a0 00 	cmp  %i2, 0                                    
40006eb0:	02 80 00 86 	be  400070c8 <timer_settime+0x220>             <== NEVER TAKEN
40006eb4:	01 00 00 00 	nop                                            
                                                                      
  /*                                                                  
   * First, it verifies if the structure "value" is correct           
   * if the number of nanoseconds is not correct return EINVAL        
   */                                                                 
  if ( !_Timespec_Is_valid( &(value->it_value) ) ) {                  
40006eb8:	40 00 10 37 	call  4000af94 <_Timespec_Is_valid>            
40006ebc:	90 06 a0 08 	add  %i2, 8, %o0                               
40006ec0:	80 8a 20 ff 	btst  0xff, %o0                                
40006ec4:	02 80 00 81 	be  400070c8 <timer_settime+0x220>             
40006ec8:	01 00 00 00 	nop                                            
    rtems_set_errno_and_return_minus_one( EINVAL );                   
  }                                                                   
  if ( !_Timespec_Is_valid( &(value->it_interval) ) ) {               
40006ecc:	40 00 10 32 	call  4000af94 <_Timespec_Is_valid>            
40006ed0:	90 10 00 1a 	mov  %i2, %o0                                  
40006ed4:	80 8a 20 ff 	btst  0xff, %o0                                
40006ed8:	02 80 00 7c 	be  400070c8 <timer_settime+0x220>             <== NEVER TAKEN
40006edc:	80 8e 7f fb 	btst  -5, %i1                                  
    rtems_set_errno_and_return_minus_one( EINVAL );                   
  }                                                                   
                                                                      
  if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {    
40006ee0:	12 80 00 7a 	bne  400070c8 <timer_settime+0x220>            
40006ee4:	80 a6 60 04 	cmp  %i1, 4                                    
    rtems_set_errno_and_return_minus_one( EINVAL );                   
  }                                                                   
                                                                      
  normalize = *value;                                                 
40006ee8:	c8 06 80 00 	ld  [ %i2 ], %g4                               
40006eec:	c6 06 a0 04 	ld  [ %i2 + 4 ], %g3                           
40006ef0:	c4 06 a0 08 	ld  [ %i2 + 8 ], %g2                           
40006ef4:	c2 06 a0 0c 	ld  [ %i2 + 0xc ], %g1                         
40006ef8:	c8 27 bf f0 	st  %g4, [ %fp + -16 ]                         
40006efc:	c6 27 bf f4 	st  %g3, [ %fp + -12 ]                         
40006f00:	c4 27 bf f8 	st  %g2, [ %fp + -8 ]                          
                                                                      
  /* Convert absolute to relative time */                             
  if (flags == TIMER_ABSTIME) {                                       
40006f04:	02 80 00 4c 	be  40007034 <timer_settime+0x18c>             
40006f08:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Get (          
  timer_t            id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (POSIX_Timer_Control *)                                      
40006f0c:	92 10 00 18 	mov  %i0, %o1                                  
40006f10:	11 10 00 7f 	sethi  %hi(0x4001fc00), %o0                    
40006f14:	94 07 bf dc 	add  %fp, -36, %o2                             
40006f18:	40 00 09 ba 	call  40009600 <_Objects_Get>                  
40006f1c:	90 12 20 d4 	or  %o0, 0xd4, %o0                             
   * something with the structure of times of the timer: to stop, start
   * or start it again                                                
   */                                                                 
                                                                      
  ptimer = _POSIX_Timer_Get( timerid, &location );                    
  switch ( location ) {                                               
40006f20:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1                         
40006f24:	80 a0 60 00 	cmp  %g1, 0                                    
40006f28:	12 80 00 68 	bne  400070c8 <timer_settime+0x220>            <== NEVER TAKEN
40006f2c:	b2 10 00 08 	mov  %o0, %i1                                  
                                                                      
    case OBJECTS_LOCAL:                                               
      /* First, it verifies if the timer must be stopped */           
      if ( normalize.it_value.tv_sec == 0 && normalize.it_value.tv_nsec == 0 ) {
40006f30:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
40006f34:	80 a0 60 00 	cmp  %g1, 0                                    
40006f38:	12 80 00 05 	bne  40006f4c <timer_settime+0xa4>             
40006f3c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40006f40:	80 a0 60 00 	cmp  %g1, 0                                    
40006f44:	02 80 00 67 	be  400070e0 <timer_settime+0x238>             
40006f48:	01 00 00 00 	nop                                            
        _Thread_Enable_dispatch();                                    
        return 0;                                                     
       }                                                              
                                                                      
       /* Convert from seconds and nanoseconds to ticks */            
       ptimer->ticks  = _Timespec_To_ticks( &value->it_interval );    
40006f4c:	40 00 10 4b 	call  4000b078 <_Timespec_To_ticks>            
40006f50:	90 10 00 1a 	mov  %i2, %o0                                  
40006f54:	d0 26 60 64 	st  %o0, [ %i1 + 0x64 ]                        
       initial_period = _Timespec_To_ticks( &normalize.it_value );    
40006f58:	40 00 10 48 	call  4000b078 <_Timespec_To_ticks>            
40006f5c:	90 07 bf f8 	add  %fp, -8, %o0                              
                                                                      
                                                                      
       activated = _POSIX_Timer_Insert_helper(                        
40006f60:	d4 06 60 08 	ld  [ %i1 + 8 ], %o2                           
        return 0;                                                     
       }                                                              
                                                                      
       /* Convert from seconds and nanoseconds to ticks */            
       ptimer->ticks  = _Timespec_To_ticks( &value->it_interval );    
       initial_period = _Timespec_To_ticks( &normalize.it_value );    
40006f64:	92 10 00 08 	mov  %o0, %o1                                  
                                                                      
                                                                      
       activated = _POSIX_Timer_Insert_helper(                        
40006f68:	98 10 00 19 	mov  %i1, %o4                                  
40006f6c:	90 06 60 10 	add  %i1, 0x10, %o0                            
40006f70:	17 10 00 1c 	sethi  %hi(0x40007000), %o3                    
40006f74:	40 00 19 c7 	call  4000d690 <_POSIX_Timer_Insert_helper>    
40006f78:	96 12 e1 4c 	or  %o3, 0x14c, %o3	! 4000714c <_POSIX_Timer_TSR>
         initial_period,                                              
         ptimer->Object.id,                                           
         _POSIX_Timer_TSR,                                            
         ptimer                                                       
       );                                                             
       if ( !activated ) {                                            
40006f7c:	80 8a 20 ff 	btst  0xff, %o0                                
40006f80:	02 80 00 29 	be  40007024 <timer_settime+0x17c>             
40006f84:	80 a6 e0 00 	cmp  %i3, 0                                    
                                                                      
       /*                                                             
        * The timer has been started and is running.  So we return the
        * old ones in "ovalue"                                        
        */                                                            
       if ( ovalue )                                                  
40006f88:	02 80 00 0b 	be  40006fb4 <timer_settime+0x10c>             
40006f8c:	c2 07 bf f0 	ld  [ %fp + -16 ], %g1                         
         *ovalue = ptimer->timer_data;                                
40006f90:	c2 06 60 54 	ld  [ %i1 + 0x54 ], %g1                        
40006f94:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
40006f98:	c2 06 60 58 	ld  [ %i1 + 0x58 ], %g1                        
40006f9c:	c2 26 e0 04 	st  %g1, [ %i3 + 4 ]                           
40006fa0:	c2 06 60 5c 	ld  [ %i1 + 0x5c ], %g1                        
40006fa4:	c2 26 e0 08 	st  %g1, [ %i3 + 8 ]                           
40006fa8:	c2 06 60 60 	ld  [ %i1 + 0x60 ], %g1                        
40006fac:	c2 26 e0 0c 	st  %g1, [ %i3 + 0xc ]                         
       ptimer->timer_data = normalize;                                
40006fb0:	c2 07 bf f0 	ld  [ %fp + -16 ], %g1                         
)                                                                     
{                                                                     
  Timestamp_Control  tod_as_timestamp;                                
  Timestamp_Control *tod_as_timestamp_ptr;                            
                                                                      
  tod_as_timestamp_ptr =                                              
40006fb4:	90 07 bf e0 	add  %fp, -32, %o0                             
40006fb8:	c2 26 60 54 	st  %g1, [ %i1 + 0x54 ]                        
40006fbc:	c2 07 bf f4 	ld  [ %fp + -12 ], %g1                         
40006fc0:	13 10 00 7e 	sethi  %hi(0x4001f800), %o1                    
40006fc4:	c2 26 60 58 	st  %g1, [ %i1 + 0x58 ]                        
40006fc8:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
40006fcc:	92 12 61 58 	or  %o1, 0x158, %o1                            
40006fd0:	c2 26 60 5c 	st  %g1, [ %i1 + 0x5c ]                        
40006fd4:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40006fd8:	c2 26 60 60 	st  %g1, [ %i1 + 0x60 ]                        
                                                                      
       /* Indicate that the time is running */                        
       ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;                  
40006fdc:	82 10 20 03 	mov  3, %g1                                    
40006fe0:	40 00 06 b4 	call  40008ab0 <_TOD_Get_with_nanoseconds>     
40006fe4:	c2 2e 60 3c 	stb  %g1, [ %i1 + 0x3c ]                       
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  rtems_set_errno_and_return_minus_one( EINVAL );                     
}                                                                     
40006fe8:	f8 1a 00 00 	ldd  [ %o0 ], %i4                              
static inline void _Timestamp64_implementation_To_timespec(           
  const Timestamp64_Control *_timestamp,                              
  struct timespec           *_timespec                                
)                                                                     
{                                                                     
  _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);           
40006fec:	94 10 20 00 	clr  %o2                                       
40006ff0:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
40006ff4:	90 10 00 1c 	mov  %i4, %o0                                  
40006ff8:	96 12 e2 00 	or  %o3, 0x200, %o3                            
40006ffc:	40 00 4a ad 	call  40019ab0 <__divdi3>                      
40007000:	92 10 00 1d 	mov  %i5, %o1                                  
  _timespec->tv_nsec = (long) (*_timestamp % 1000000000L);            
40007004:	94 10 20 00 	clr  %o2                                       
static inline void _Timestamp64_implementation_To_timespec(           
  const Timestamp64_Control *_timestamp,                              
  struct timespec           *_timespec                                
)                                                                     
{                                                                     
  _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);           
40007008:	d2 26 60 6c 	st  %o1, [ %i1 + 0x6c ]                        
  _timespec->tv_nsec = (long) (*_timestamp % 1000000000L);            
4000700c:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
40007010:	90 10 00 1c 	mov  %i4, %o0                                  
40007014:	96 12 e2 00 	or  %o3, 0x200, %o3                            
40007018:	40 00 4b 91 	call  40019e5c <__moddi3>                      
4000701c:	92 10 00 1d 	mov  %i5, %o1                                  
40007020:	d2 26 60 70 	st  %o1, [ %i1 + 0x70 ]                        
       ptimer->timer_data = normalize;                                
                                                                      
       /* Indicate that the time is running */                        
       ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;                  
       _TOD_Get( &ptimer->time );                                     
       _Thread_Enable_dispatch();                                     
40007024:	40 00 0d 2e 	call  4000a4dc <_Thread_Enable_dispatch>       
40007028:	b0 10 20 00 	clr  %i0                                       
4000702c:	81 c7 e0 08 	ret                                            
40007030:	81 e8 00 00 	restore                                        
40007034:	90 07 bf e0 	add  %fp, -32, %o0                             
40007038:	13 10 00 7e 	sethi  %hi(0x4001f800), %o1                    
4000703c:	40 00 06 9d 	call  40008ab0 <_TOD_Get_with_nanoseconds>     
40007040:	92 12 61 58 	or  %o1, 0x158, %o1	! 4001f958 <_TOD>          
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  rtems_set_errno_and_return_minus_one( EINVAL );                     
}                                                                     
40007044:	f8 1a 00 00 	ldd  [ %o0 ], %i4                              
static inline void _Timestamp64_implementation_To_timespec(           
  const Timestamp64_Control *_timestamp,                              
  struct timespec           *_timespec                                
)                                                                     
{                                                                     
  _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);           
40007048:	94 10 20 00 	clr  %o2                                       
4000704c:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
40007050:	90 10 00 1c 	mov  %i4, %o0                                  
40007054:	96 12 e2 00 	or  %o3, 0x200, %o3                            
40007058:	40 00 4a 96 	call  40019ab0 <__divdi3>                      
4000705c:	92 10 00 1d 	mov  %i5, %o1                                  
  _timespec->tv_nsec = (long) (*_timestamp % 1000000000L);            
40007060:	94 10 20 00 	clr  %o2                                       
static inline void _Timestamp64_implementation_To_timespec(           
  const Timestamp64_Control *_timestamp,                              
  struct timespec           *_timespec                                
)                                                                     
{                                                                     
  _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);           
40007064:	d2 27 bf e8 	st  %o1, [ %fp + -24 ]                         
  _timespec->tv_nsec = (long) (*_timestamp % 1000000000L);            
40007068:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
4000706c:	90 10 00 1c 	mov  %i4, %o0                                  
40007070:	96 12 e2 00 	or  %o3, 0x200, %o3                            
40007074:	40 00 4b 7a 	call  40019e5c <__moddi3>                      
40007078:	92 10 00 1d 	mov  %i5, %o1                                  
  /* Convert absolute to relative time */                             
  if (flags == TIMER_ABSTIME) {                                       
    struct timespec now;                                              
    _TOD_Get( &now );                                                 
    /* Check for seconds in the past */                               
    if ( _Timespec_Greater_than( &now, &normalize.it_value ) )        
4000707c:	90 07 bf f8 	add  %fp, -8, %o0                              
40007080:	d2 27 bf ec 	st  %o1, [ %fp + -20 ]                         
40007084:	40 00 0f d7 	call  4000afe0 <_Timespec_Less_than>           
40007088:	92 07 bf e8 	add  %fp, -24, %o1                             
4000708c:	80 8a 20 ff 	btst  0xff, %o0                                
40007090:	12 80 00 0e 	bne  400070c8 <timer_settime+0x220>            
40007094:	92 07 bf f8 	add  %fp, -8, %o1                              
      rtems_set_errno_and_return_minus_one( EINVAL );                 
    _Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value );
40007098:	90 07 bf e8 	add  %fp, -24, %o0                             
4000709c:	40 00 0f e3 	call  4000b028 <_Timespec_Subtract>            
400070a0:	94 10 00 09 	mov  %o1, %o2                                  
400070a4:	92 10 00 18 	mov  %i0, %o1                                  
400070a8:	11 10 00 7f 	sethi  %hi(0x4001fc00), %o0                    
400070ac:	94 07 bf dc 	add  %fp, -36, %o2                             
400070b0:	40 00 09 54 	call  40009600 <_Objects_Get>                  
400070b4:	90 12 20 d4 	or  %o0, 0xd4, %o0                             
   * something with the structure of times of the timer: to stop, start
   * or start it again                                                
   */                                                                 
                                                                      
  ptimer = _POSIX_Timer_Get( timerid, &location );                    
  switch ( location ) {                                               
400070b8:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1                         
400070bc:	80 a0 60 00 	cmp  %g1, 0                                    
400070c0:	02 bf ff 9c 	be  40006f30 <timer_settime+0x88>              
400070c4:	b2 10 00 08 	mov  %o0, %i1                                  
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  rtems_set_errno_and_return_minus_one( EINVAL );                     
400070c8:	40 00 24 11 	call  4001010c <__errno>                       
400070cc:	b0 10 3f ff 	mov  -1, %i0                                   
400070d0:	82 10 20 16 	mov  0x16, %g1                                 
400070d4:	c2 22 00 00 	st  %g1, [ %o0 ]                               
}                                                                     
400070d8:	81 c7 e0 08 	ret                                            
400070dc:	81 e8 00 00 	restore                                        
                                                                      
    case OBJECTS_LOCAL:                                               
      /* First, it verifies if the timer must be stopped */           
      if ( normalize.it_value.tv_sec == 0 && normalize.it_value.tv_nsec == 0 ) {
         /* Stop the timer */                                         
         (void) _Watchdog_Remove( &ptimer->Timer );                   
400070e0:	40 00 10 ef 	call  4000b49c <_Watchdog_Remove>              
400070e4:	90 02 20 10 	add  %o0, 0x10, %o0                            
         /* The old data of the timer are returned */                 
         if ( ovalue )                                                
400070e8:	80 a6 e0 00 	cmp  %i3, 0                                    
400070ec:	02 80 00 0b 	be  40007118 <timer_settime+0x270>             
400070f0:	c2 07 bf f0 	ld  [ %fp + -16 ], %g1                         
           *ovalue = ptimer->timer_data;                              
400070f4:	c2 06 60 54 	ld  [ %i1 + 0x54 ], %g1                        
400070f8:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
400070fc:	c2 06 60 58 	ld  [ %i1 + 0x58 ], %g1                        
40007100:	c2 26 e0 04 	st  %g1, [ %i3 + 4 ]                           
40007104:	c2 06 60 5c 	ld  [ %i1 + 0x5c ], %g1                        
40007108:	c2 26 e0 08 	st  %g1, [ %i3 + 8 ]                           
4000710c:	c2 06 60 60 	ld  [ %i1 + 0x60 ], %g1                        
40007110:	c2 26 e0 0c 	st  %g1, [ %i3 + 0xc ]                         
         /* The new data are set */                                   
         ptimer->timer_data = normalize;                              
40007114:	c2 07 bf f0 	ld  [ %fp + -16 ], %g1                         
         /* Indicates that the timer is created and stopped */        
         ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;               
         /* Returns with success */                                   
        _Thread_Enable_dispatch();                                    
        return 0;                                                     
40007118:	b0 10 20 00 	clr  %i0                                       
         (void) _Watchdog_Remove( &ptimer->Timer );                   
         /* The old data of the timer are returned */                 
         if ( ovalue )                                                
           *ovalue = ptimer->timer_data;                              
         /* The new data are set */                                   
         ptimer->timer_data = normalize;                              
4000711c:	c2 26 60 54 	st  %g1, [ %i1 + 0x54 ]                        
40007120:	c2 07 bf f4 	ld  [ %fp + -12 ], %g1                         
40007124:	c2 26 60 58 	st  %g1, [ %i1 + 0x58 ]                        
40007128:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
4000712c:	c2 26 60 5c 	st  %g1, [ %i1 + 0x5c ]                        
40007130:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40007134:	c2 26 60 60 	st  %g1, [ %i1 + 0x60 ]                        
         /* Indicates that the timer is created and stopped */        
         ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;               
40007138:	82 10 20 04 	mov  4, %g1                                    
         /* Returns with success */                                   
        _Thread_Enable_dispatch();                                    
4000713c:	40 00 0c e8 	call  4000a4dc <_Thread_Enable_dispatch>       
40007140:	c2 2e 60 3c 	stb  %g1, [ %i1 + 0x3c ]                       
40007144:	81 c7 e0 08 	ret                                            
40007148:	81 e8 00 00 	restore                                        
                                                                      

40006df4 <ualarm>: useconds_t ualarm( useconds_t useconds, useconds_t interval ) {
40006df4:	9d e3 bf 98 	save  %sp, -104, %sp                           
                                                                      
  /*                                                                  
   *  Initialize the timer used to implement alarm().                 
   */                                                                 
                                                                      
  if ( !the_timer->routine ) {                                        
40006df8:	3b 10 00 65 	sethi  %hi(0x40019400), %i5                    
40006dfc:	ba 17 62 58 	or  %i5, 0x258, %i5	! 40019658 <_POSIX_signals_Ualarm_timer>
40006e00:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
40006e04:	80 a0 60 00 	cmp  %g1, 0                                    
40006e08:	02 80 00 24 	be  40006e98 <ualarm+0xa4>                     
40006e0c:	b8 10 00 18 	mov  %i0, %i4                                  
    _Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL );
  } else {                                                            
    Watchdog_States state;                                            
                                                                      
    state = _Watchdog_Remove( the_timer );                            
40006e10:	40 00 10 8e 	call  4000b048 <_Watchdog_Remove>              
40006e14:	90 10 00 1d 	mov  %i5, %o0                                  
    if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
40006e18:	90 02 3f fe 	add  %o0, -2, %o0                              
40006e1c:	80 a2 20 01 	cmp  %o0, 1                                    
40006e20:	08 80 00 26 	bleu  40006eb8 <ualarm+0xc4>                   <== ALWAYS TAKEN
40006e24:	b0 10 20 00 	clr  %i0                                       
  /*                                                                  
   *  If useconds is non-zero, then the caller wants to schedule      
   *  the alarm repeatedly at that interval.  If the interval is      
   *  less than a single clock tick, then fudge it to a clock tick.   
   */                                                                 
  if ( useconds ) {                                                   
40006e28:	80 a7 20 00 	cmp  %i4, 0                                    
40006e2c:	02 80 00 19 	be  40006e90 <ualarm+0x9c>                     
40006e30:	37 00 03 d0 	sethi  %hi(0xf4000), %i3                       
    Watchdog_Interval ticks;                                          
                                                                      
    tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;               
40006e34:	90 10 00 1c 	mov  %i4, %o0                                  
40006e38:	40 00 37 2b 	call  40014ae4 <.udiv>                         
40006e3c:	92 16 e2 40 	or  %i3, 0x240, %o1                            
    tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;     
40006e40:	92 16 e2 40 	or  %i3, 0x240, %o1                            
   *  less than a single clock tick, then fudge it to a clock tick.   
   */                                                                 
  if ( useconds ) {                                                   
    Watchdog_Interval ticks;                                          
                                                                      
    tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;               
40006e44:	d0 27 bf f8 	st  %o0, [ %fp + -8 ]                          
    tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;     
40006e48:	40 00 37 d3 	call  40014d94 <.urem>                         
40006e4c:	90 10 00 1c 	mov  %i4, %o0                                  
40006e50:	87 2a 20 07 	sll  %o0, 7, %g3                               
40006e54:	82 10 00 08 	mov  %o0, %g1                                  
40006e58:	85 2a 20 02 	sll  %o0, 2, %g2                               
40006e5c:	84 20 c0 02 	sub  %g3, %g2, %g2                             
40006e60:	82 00 80 01 	add  %g2, %g1, %g1                             
40006e64:	83 28 60 03 	sll  %g1, 3, %g1                               
    ticks = _Timespec_To_ticks( &tp );                                
40006e68:	90 07 bf f8 	add  %fp, -8, %o0                              
40006e6c:	40 00 0f 3e 	call  4000ab64 <_Timespec_To_ticks>            
40006e70:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
    if ( ticks == 0 )                                                 
      ticks = 1;                                                      
                                                                      
    _Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );   
40006e74:	40 00 0f 3c 	call  4000ab64 <_Timespec_To_ticks>            
40006e78:	90 07 bf f8 	add  %fp, -8, %o0                              
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
40006e7c:	92 10 00 1d 	mov  %i5, %o1                                  
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
40006e80:	d0 27 60 0c 	st  %o0, [ %i5 + 0xc ]                         
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
40006e84:	11 10 00 63 	sethi  %hi(0x40018c00), %o0                    
40006e88:	40 00 10 11 	call  4000aecc <_Watchdog_Insert>              
40006e8c:	90 12 22 08 	or  %o0, 0x208, %o0	! 40018e08 <_Watchdog_Ticks_chain>
  }                                                                   
                                                                      
  return remaining;                                                   
}                                                                     
40006e90:	81 c7 e0 08 	ret                                            
40006e94:	81 e8 00 00 	restore                                        
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
  the_watchdog->routine   = routine;                                  
40006e98:	03 10 00 1b 	sethi  %hi(0x40006c00), %g1                    
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
40006e9c:	c0 27 60 08 	clr  [ %i5 + 8 ]                               
  the_watchdog->routine   = routine;                                  
40006ea0:	82 10 61 c4 	or  %g1, 0x1c4, %g1                            
  the_watchdog->id        = id;                                       
40006ea4:	c0 27 60 20 	clr  [ %i5 + 0x20 ]                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
  the_watchdog->routine   = routine;                                  
40006ea8:	c2 27 60 1c 	st  %g1, [ %i5 + 0x1c ]                        
  the_watchdog->id        = id;                                       
  the_watchdog->user_data = user_data;                                
40006eac:	c0 27 60 24 	clr  [ %i5 + 0x24 ]                            
useconds_t ualarm(                                                    
  useconds_t useconds,                                                
  useconds_t interval                                                 
)                                                                     
{                                                                     
  useconds_t        remaining = 0;                                    
40006eb0:	10 bf ff de 	b  40006e28 <ualarm+0x34>                      
40006eb4:	b0 10 20 00 	clr  %i0                                       
       *  boot.  Since alarm() is dealing in seconds, we must account for
       *  this.                                                       
       */                                                             
                                                                      
      ticks = the_timer->initial;                                     
      ticks -= (the_timer->stop_time - the_timer->start_time);        
40006eb8:	c4 07 60 0c 	ld  [ %i5 + 0xc ], %g2                         
40006ebc:	c2 07 60 18 	ld  [ %i5 + 0x18 ], %g1                        
40006ec0:	d0 07 60 14 	ld  [ %i5 + 0x14 ], %o0                        
      /* remaining is now in ticks */                                 
                                                                      
      _Timespec_From_ticks( ticks, &tp );                             
40006ec4:	92 07 bf f8 	add  %fp, -8, %o1                              
       *  boot.  Since alarm() is dealing in seconds, we must account for
       *  this.                                                       
       */                                                             
                                                                      
      ticks = the_timer->initial;                                     
      ticks -= (the_timer->stop_time - the_timer->start_time);        
40006ec8:	90 02 00 02 	add  %o0, %g2, %o0                             
      /* remaining is now in ticks */                                 
                                                                      
      _Timespec_From_ticks( ticks, &tp );                             
40006ecc:	40 00 0f 11 	call  4000ab10 <_Timespec_From_ticks>          
40006ed0:	90 22 00 01 	sub  %o0, %g1, %o0                             
      remaining  = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;           
40006ed4:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
      remaining += tp.tv_nsec / 1000;                                 
40006ed8:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
      ticks = the_timer->initial;                                     
      ticks -= (the_timer->stop_time - the_timer->start_time);        
      /* remaining is now in ticks */                                 
                                                                      
      _Timespec_From_ticks( ticks, &tp );                             
      remaining  = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;           
40006edc:	85 28 60 03 	sll  %g1, 3, %g2                               
40006ee0:	87 28 60 08 	sll  %g1, 8, %g3                               
40006ee4:	84 20 c0 02 	sub  %g3, %g2, %g2                             
      remaining += tp.tv_nsec / 1000;                                 
40006ee8:	92 10 23 e8 	mov  0x3e8, %o1                                
      ticks = the_timer->initial;                                     
      ticks -= (the_timer->stop_time - the_timer->start_time);        
      /* remaining is now in ticks */                                 
                                                                      
      _Timespec_From_ticks( ticks, &tp );                             
      remaining  = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;           
40006eec:	b1 28 a0 06 	sll  %g2, 6, %i0                               
40006ef0:	b0 26 00 02 	sub  %i0, %g2, %i0                             
      remaining += tp.tv_nsec / 1000;                                 
40006ef4:	40 00 36 fe 	call  40014aec <.div>                          
40006ef8:	b0 06 00 01 	add  %i0, %g1, %i0                             
      ticks = the_timer->initial;                                     
      ticks -= (the_timer->stop_time - the_timer->start_time);        
      /* remaining is now in ticks */                                 
                                                                      
      _Timespec_From_ticks( ticks, &tp );                             
      remaining  = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;           
40006efc:	b1 2e 20 06 	sll  %i0, 6, %i0                               
      remaining += tp.tv_nsec / 1000;                                 
40006f00:	10 bf ff ca 	b  40006e28 <ualarm+0x34>                      
40006f04:	b0 02 00 18 	add  %o0, %i0, %i0                             
                                                                      

4000688c <unmount>: * in some form is supported on most UNIX and POSIX systems. This * routine is necessary to mount instantiations of a file system * into the file system name space. */ int unmount( const char *path ) {
4000688c:	9d e3 bf 60 	save  %sp, -160, %sp                           
  int rv = 0;                                                         
  rtems_filesystem_eval_path_context_t ctx;                           
  int eval_flags = RTEMS_FS_FOLLOW_LINK;                              
  const rtems_filesystem_location_info_t *currentloc =                
40006890:	94 10 20 18 	mov  0x18, %o2                                 
40006894:	92 10 00 18 	mov  %i0, %o1                                  
40006898:	7f ff f6 a6 	call  40004330 <rtems_filesystem_eval_path_start>
4000689c:	90 07 bf c8 	add  %fp, -56, %o0                             
    rtems_filesystem_eval_path_start( &ctx, path, eval_flags );       
  rtems_filesystem_mount_table_entry_t *mt_entry = currentloc->mt_entry;
400068a0:	fa 02 20 14 	ld  [ %o0 + 0x14 ], %i5                        
  const rtems_filesystem_location_info_t *loc                         
)                                                                     
{                                                                     
  const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
                                                                      
  return (*mt_entry->ops->are_nodes_equal_h)(                         
400068a4:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
400068a8:	c2 00 60 10 	ld  [ %g1 + 0x10 ], %g1                        
400068ac:	9f c0 40 00 	call  %g1                                      
400068b0:	d2 07 60 24 	ld  [ %i5 + 0x24 ], %o1                        
                                                                      
  if ( rtems_filesystem_location_is_instance_root( currentloc ) ) {   
400068b4:	80 8a 20 ff 	btst  0xff, %o0                                
400068b8:	02 80 00 33 	be  40006984 <unmount+0xf8>                    
400068bc:	03 10 00 59 	sethi  %hi(0x40016400), %g1                    
static bool contains_root_or_current_directory(                       
  const rtems_filesystem_mount_table_entry_t *mt_entry                
)                                                                     
{                                                                     
  const rtems_filesystem_location_info_t *root =                      
    &rtems_filesystem_root->location;                                 
400068c0:	c2 00 62 1c 	ld  [ %g1 + 0x21c ], %g1	! 4001661c <rtems_current_user_env>
  const rtems_filesystem_location_info_t *current =                   
    &rtems_filesystem_current->location;                              
                                                                      
  return mt_entry == root->mt_entry || mt_entry == current->mt_entry; 
400068c4:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
)                                                                     
{                                                                     
  const rtems_filesystem_location_info_t *root =                      
    &rtems_filesystem_root->location;                                 
  const rtems_filesystem_location_info_t *current =                   
    &rtems_filesystem_current->location;                              
400068c8:	c6 00 40 00 	ld  [ %g1 ], %g3                               
                                                                      
  return mt_entry == root->mt_entry || mt_entry == current->mt_entry; 
400068cc:	c2 00 a0 14 	ld  [ %g2 + 0x14 ], %g1                        
400068d0:	80 a7 40 01 	cmp  %i5, %g1                                  
400068d4:	02 80 00 27 	be  40006970 <unmount+0xe4>                    
400068d8:	01 00 00 00 	nop                                            
400068dc:	c2 00 e0 14 	ld  [ %g3 + 0x14 ], %g1                        
400068e0:	80 a7 40 01 	cmp  %i5, %g1                                  
400068e4:	02 80 00 23 	be  40006970 <unmount+0xe4>                    
400068e8:	01 00 00 00 	nop                                            
  rtems_filesystem_mount_table_entry_t *mt_entry = currentloc->mt_entry;
                                                                      
  if ( rtems_filesystem_location_is_instance_root( currentloc ) ) {   
    if ( !contains_root_or_current_directory( mt_entry ) ) {          
      const rtems_filesystem_operations_table *mt_point_ops =         
        mt_entry->mt_point_node->location.mt_entry->ops;              
400068ec:	c2 07 60 20 	ld  [ %i5 + 0x20 ], %g1                        
400068f0:	c2 00 60 14 	ld  [ %g1 + 0x14 ], %g1                        
                                                                      
      rv = (*mt_point_ops->unmount_h)( mt_entry );                    
400068f4:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
400068f8:	c2 00 60 38 	ld  [ %g1 + 0x38 ], %g1                        
400068fc:	9f c0 40 00 	call  %g1                                      
40006900:	90 10 00 1d 	mov  %i5, %o0                                  
      if ( rv == 0 ) {                                                
40006904:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40006908:	02 80 00 06 	be  40006920 <unmount+0x94>                    
4000690c:	01 00 00 00 	nop                                            
  } else {                                                            
    errno = EACCES;                                                   
    rv = -1;                                                          
  }                                                                   
                                                                      
  rtems_filesystem_eval_path_cleanup( &ctx );                         
40006910:	7f ff f6 c8 	call  40004430 <rtems_filesystem_eval_path_cleanup>
40006914:	90 07 bf c8 	add  %fp, -56, %o0                             
      rtems_fatal_error_occurred( 0xdeadbeef );                       
    }                                                                 
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
40006918:	81 c7 e0 08 	ret                                            
4000691c:	81 e8 00 00 	restore                                        
      const rtems_filesystem_operations_table *mt_point_ops =         
        mt_entry->mt_point_node->location.mt_entry->ops;              
                                                                      
      rv = (*mt_point_ops->unmount_h)( mt_entry );                    
      if ( rv == 0 ) {                                                
        rtems_id self_task_id = rtems_task_self();                    
40006920:	40 00 04 48 	call  40007a40 <rtems_task_self>               
40006924:	01 00 00 00 	nop                                            
        rtems_filesystem_mt_entry_declare_lock_context( lock_context );
                                                                      
        rtems_filesystem_mt_entry_lock( lock_context );               
40006928:	7f ff ed c9 	call  4000204c <sparc_disable_interrupts>      
4000692c:	b8 10 00 08 	mov  %o0, %i4                                  
        mt_entry->unmount_task = self_task_id;                        
40006930:	f8 27 60 3c 	st  %i4, [ %i5 + 0x3c ]                        
        mt_entry->mounted = false;                                    
40006934:	c0 2f 60 28 	clrb  [ %i5 + 0x28 ]                           
        rtems_filesystem_mt_entry_unlock( lock_context );             
40006938:	7f ff ed c9 	call  4000205c <sparc_enable_interrupts>       
4000693c:	01 00 00 00 	nop                                            
  } else {                                                            
    errno = EACCES;                                                   
    rv = -1;                                                          
  }                                                                   
                                                                      
  rtems_filesystem_eval_path_cleanup( &ctx );                         
40006940:	7f ff f6 bc 	call  40004430 <rtems_filesystem_eval_path_cleanup>
40006944:	90 07 bf c8 	add  %fp, -56, %o0                             
  rtems_interval ticks                                                
)                                                                     
{                                                                     
  rtems_event_set event_out;                                          
                                                                      
  return rtems_event_system_receive(                                  
40006948:	11 20 00 00 	sethi  %hi(0x80000000), %o0                    
4000694c:	92 10 20 00 	clr  %o1                                       
40006950:	94 10 20 00 	clr  %o2                                       
40006954:	40 00 03 78 	call  40007734 <rtems_event_system_receive>    
40006958:	96 07 bf c4 	add  %fp, -60, %o3                             
    rtems_status_code sc = rtems_event_transient_receive(             
      RTEMS_WAIT,                                                     
      RTEMS_NO_TIMEOUT                                                
    );                                                                
                                                                      
    if ( sc != RTEMS_SUCCESSFUL ) {                                   
4000695c:	80 a2 20 00 	cmp  %o0, 0                                    
40006960:	02 bf ff ee 	be  40006918 <unmount+0x8c>                    <== ALWAYS TAKEN
40006964:	11 37 ab 6f 	sethi  %hi(0xdeadbc00), %o0                    
      rtems_fatal_error_occurred( 0xdeadbeef );                       
40006968:	40 00 04 da 	call  40007cd0 <rtems_fatal_error_occurred>    <== NOT EXECUTED
4000696c:	90 12 22 ef 	or  %o0, 0x2ef, %o0	! deadbeef <LEON_REG+0x5eadbeef><== NOT EXECUTED
        mt_entry->unmount_task = self_task_id;                        
        mt_entry->mounted = false;                                    
        rtems_filesystem_mt_entry_unlock( lock_context );             
      }                                                               
    } else {                                                          
      errno = EBUSY;                                                  
40006970:	40 00 23 b0 	call  4000f830 <__errno>                       
40006974:	b0 10 3f ff 	mov  -1, %i0                                   
40006978:	82 10 20 10 	mov  0x10, %g1                                 
4000697c:	10 bf ff e5 	b  40006910 <unmount+0x84>                     
40006980:	c2 22 00 00 	st  %g1, [ %o0 ]                               
      rv = -1;                                                        
    }                                                                 
  } else {                                                            
    errno = EACCES;                                                   
40006984:	40 00 23 ab 	call  4000f830 <__errno>                       
40006988:	b0 10 3f ff 	mov  -1, %i0                                   
4000698c:	82 10 20 0d 	mov  0xd, %g1                                  
40006990:	10 bf ff e0 	b  40006910 <unmount+0x84>                     
40006994:	c2 22 00 00 	st  %g1, [ %o0 ]                               
                                                                      

40006868 <vprintk>: */ void vprintk( const char *fmt, va_list ap ) {
40006868:	9d e3 bf 88 	save  %sp, -120, %sp                           
  for (; *fmt != '\0'; fmt++) {                                       
4000686c:	d0 0e 00 00 	ldub  [ %i0 ], %o0                             
 *  console is not yet initialized or in ISR's.                       
 *                                                                    
 * Arguments:                                                         
 *    as in printf: fmt - format string, ... - unnamed arguments.     
 */                                                                   
void vprintk(                                                         
40006870:	a0 07 bf e8 	add  %fp, -24, %l0                             
  const char *fmt,                                                    
  va_list     ap                                                      
)                                                                     
{                                                                     
  for (; *fmt != '\0'; fmt++) {                                       
40006874:	91 2a 20 18 	sll  %o0, 0x18, %o0                            
 *  console is not yet initialized or in ISR's.                       
 *                                                                    
 * Arguments:                                                         
 *    as in printf: fmt - format string, ... - unnamed arguments.     
 */                                                                   
void vprintk(                                                         
40006878:	a2 07 bf e7 	add  %fp, -25, %l1                             
4000687c:	25 10 00 73 	sethi  %hi(0x4001cc00), %l2                    
  const char *fmt,                                                    
  va_list     ap                                                      
)                                                                     
{                                                                     
  for (; *fmt != '\0'; fmt++) {                                       
40006880:	80 a2 20 00 	cmp  %o0, 0                                    
40006884:	02 80 00 74 	be  40006a54 <vprintk+0x1ec>                   <== NEVER TAKEN
40006888:	27 10 00 71 	sethi  %hi(0x4001c400), %l3                    
    bool minus = false;                                               
    bool sign = false;                                                
    char lead = ' ';                                                  
    char c;                                                           
                                                                      
    if (*fmt != '%') {                                                
4000688c:	91 3a 20 18 	sra  %o0, 0x18, %o0                            
40006890:	80 a2 20 25 	cmp  %o0, 0x25                                 
40006894:	12 80 00 7a 	bne  40006a7c <vprintk+0x214>                  
40006898:	01 00 00 00 	nop                                            
      rtems_putc(*fmt);                                               
      continue;                                                       
    }                                                                 
    fmt++;                                                            
    if (*fmt == '0' ) {                                               
4000689c:	c2 0e 20 01 	ldub  [ %i0 + 1 ], %g1                         
400068a0:	85 28 60 18 	sll  %g1, 0x18, %g2                            
400068a4:	87 38 a0 18 	sra  %g2, 0x18, %g3                            
400068a8:	80 a0 e0 30 	cmp  %g3, 0x30                                 
400068ac:	22 80 00 a9 	be,a   40006b50 <vprintk+0x2e8>                
400068b0:	c2 0e 20 02 	ldub  [ %i0 + 2 ], %g1                         
                                                                      
    if (*fmt != '%') {                                                
      rtems_putc(*fmt);                                               
      continue;                                                       
    }                                                                 
    fmt++;                                                            
400068b4:	b0 06 20 01 	inc  %i0                                       
    unsigned base = 0;                                                
    unsigned width = 0;                                               
    bool lflag = false;                                               
    bool minus = false;                                               
    bool sign = false;                                                
    char lead = ' ';                                                  
400068b8:	a8 10 20 20 	mov  0x20, %l4                                 
    fmt++;                                                            
    if (*fmt == '0' ) {                                               
      lead = '0';                                                     
      fmt++;                                                          
    }                                                                 
    if (*fmt == '-' ) {                                               
400068bc:	87 38 a0 18 	sra  %g2, 0x18, %g3                            
400068c0:	80 a0 e0 2d 	cmp  %g3, 0x2d                                 
400068c4:	02 80 00 9e 	be  40006b3c <vprintk+0x2d4>                   
400068c8:	88 10 20 00 	clr  %g4                                       
      minus = true;                                                   
      fmt++;                                                          
    }                                                                 
    while (*fmt >= '0' && *fmt <= '9' ) {                             
400068cc:	86 00 7f d0 	add  %g1, -48, %g3                             
400068d0:	86 08 e0 ff 	and  %g3, 0xff, %g3                            
400068d4:	80 a0 e0 09 	cmp  %g3, 9                                    
400068d8:	18 80 00 0f 	bgu  40006914 <vprintk+0xac>                   
400068dc:	ba 10 20 00 	clr  %i5                                       
      width *= 10;                                                    
      width += ((unsigned) *fmt - '0');                               
      fmt++;                                                          
400068e0:	b0 06 20 01 	inc  %i0                                       
    }                                                                 
    if (*fmt == '-' ) {                                               
      minus = true;                                                   
      fmt++;                                                          
    }                                                                 
    while (*fmt >= '0' && *fmt <= '9' ) {                             
400068e4:	c2 0e 00 00 	ldub  [ %i0 ], %g1                             
      width *= 10;                                                    
400068e8:	87 2f 60 01 	sll  %i5, 1, %g3                               
      width += ((unsigned) *fmt - '0');                               
400068ec:	85 38 a0 18 	sra  %g2, 0x18, %g2                            
    if (*fmt == '-' ) {                                               
      minus = true;                                                   
      fmt++;                                                          
    }                                                                 
    while (*fmt >= '0' && *fmt <= '9' ) {                             
      width *= 10;                                                    
400068f0:	bb 2f 60 03 	sll  %i5, 3, %i5                               
400068f4:	ba 00 c0 1d 	add  %g3, %i5, %i5                             
    }                                                                 
    if (*fmt == '-' ) {                                               
      minus = true;                                                   
      fmt++;                                                          
    }                                                                 
    while (*fmt >= '0' && *fmt <= '9' ) {                             
400068f8:	86 00 7f d0 	add  %g1, -48, %g3                             
      width *= 10;                                                    
      width += ((unsigned) *fmt - '0');                               
400068fc:	ba 07 40 02 	add  %i5, %g2, %i5                             
    }                                                                 
    if (*fmt == '-' ) {                                               
      minus = true;                                                   
      fmt++;                                                          
    }                                                                 
    while (*fmt >= '0' && *fmt <= '9' ) {                             
40006900:	86 08 e0 ff 	and  %g3, 0xff, %g3                            
      width *= 10;                                                    
      width += ((unsigned) *fmt - '0');                               
40006904:	ba 07 7f d0 	add  %i5, -48, %i5                             
    }                                                                 
    if (*fmt == '-' ) {                                               
      minus = true;                                                   
      fmt++;                                                          
    }                                                                 
    while (*fmt >= '0' && *fmt <= '9' ) {                             
40006908:	80 a0 e0 09 	cmp  %g3, 9                                    
4000690c:	08 bf ff f5 	bleu  400068e0 <vprintk+0x78>                  
40006910:	85 28 60 18 	sll  %g1, 0x18, %g2                            
      width *= 10;                                                    
      width += ((unsigned) *fmt - '0');                               
      fmt++;                                                          
    }                                                                 
                                                                      
    if ((c = *fmt) == 'l') {                                          
40006914:	87 38 a0 18 	sra  %g2, 0x18, %g3                            
40006918:	80 a0 e0 6c 	cmp  %g3, 0x6c                                 
4000691c:	02 80 00 77 	be  40006af8 <vprintk+0x290>                   
40006920:	91 38 a0 18 	sra  %g2, 0x18, %o0                            
      lflag = true;                                                   
      c = *++fmt;                                                     
    }                                                                 
    if ( c == 'c' ) {                                                 
40006924:	80 a2 20 63 	cmp  %o0, 0x63                                 
40006928:	22 80 00 7b 	be,a   40006b14 <vprintk+0x2ac>                
4000692c:	d0 06 40 00 	ld  [ %i1 ], %o0                               
      /* need a cast here since va_arg() only takes fully promoted types */
      char chr = (char) va_arg(ap, int);                              
      rtems_putc(chr);                                                
      continue;                                                       
    }                                                                 
    if ( c == 's' ) {                                                 
40006930:	80 a2 20 73 	cmp  %o0, 0x73                                 
40006934:	02 80 00 8b 	be  40006b60 <vprintk+0x2f8>                   
40006938:	82 08 7f df 	and  %g1, -33, %g1                             
                                                                      
      continue;                                                       
    }                                                                 
                                                                      
    /* must be a numeric format or something unsupported */           
    if ( c == 'o' || c == 'O' ) {                                     
4000693c:	83 28 60 18 	sll  %g1, 0x18, %g1                            
40006940:	83 38 60 18 	sra  %g1, 0x18, %g1                            
40006944:	80 a0 60 4f 	cmp  %g1, 0x4f                                 
40006948:	22 80 00 55 	be,a   40006a9c <vprintk+0x234>                
4000694c:	f4 06 40 00 	ld  [ %i1 ], %i2                               
      base = 8; sign = false;                                         
    } else if ( c == 'i' || c == 'I' ||                               
40006950:	80 a0 60 49 	cmp  %g1, 0x49                                 
40006954:	22 80 00 06 	be,a   4000696c <vprintk+0x104>                
40006958:	82 10 20 01 	mov  1, %g1                                    
                c == 'd' || c == 'D' ) {                              
4000695c:	80 a0 60 44 	cmp  %g1, 0x44                                 
40006960:	12 80 00 3f 	bne  40006a5c <vprintk+0x1f4>                  
40006964:	80 a0 60 55 	cmp  %g1, 0x55                                 
      base = 10; sign = true;                                         
40006968:	82 10 20 01 	mov  1, %g1                                    
4000696c:	aa 10 20 0a 	mov  0xa, %l5                                  
    } else {                                                          
      rtems_putc(c);                                                  
      continue;                                                       
    }                                                                 
                                                                      
    printNum(                                                         
40006970:	f4 06 40 00 	ld  [ %i1 ], %i2                               
  unsigned long unsigned_num;                                         
  unsigned long n;                                                    
  unsigned count;                                                     
  char toPrint[20];                                                   
                                                                      
  if ( sign && (num <  0) ) {                                         
40006974:	80 a6 a0 00 	cmp  %i2, 0                                    
40006978:	06 80 00 4e 	bl  40006ab0 <vprintk+0x248>                   
4000697c:	b2 06 60 04 	add  %i1, 4, %i1                               
  } else {                                                            
    unsigned_num = (unsigned long) num;                               
  }                                                                   
                                                                      
  count = 0;                                                          
  while ((n = unsigned_num / base) > 0) {                             
40006980:	90 10 00 1a 	mov  %i2, %o0                                  
40006984:	40 00 47 bc 	call  40018874 <.udiv>                         
40006988:	92 10 00 15 	mov  %l5, %o1                                  
4000698c:	b8 92 20 00 	orcc  %o0, 0, %i4                              
40006990:	22 80 00 57 	be,a   40006aec <vprintk+0x284>                
40006994:	b8 10 00 1a 	mov  %i2, %i4                                  
40006998:	ac 10 00 15 	mov  %l5, %l6                                  
    if (maxwidth) maxwidth--;                                         
  } else {                                                            
    unsigned_num = (unsigned long) num;                               
  }                                                                   
                                                                      
  count = 0;                                                          
4000699c:	10 80 00 03 	b  400069a8 <vprintk+0x140>                    
400069a0:	b6 10 20 00 	clr  %i3                                       
  while ((n = unsigned_num / base) > 0) {                             
400069a4:	b8 10 00 08 	mov  %o0, %i4                                  
    toPrint[count++] = (char) (unsigned_num - (n * base));            
400069a8:	92 10 00 1c 	mov  %i4, %o1                                  
400069ac:	40 00 47 78 	call  4001878c <.umul>                         
400069b0:	90 10 00 16 	mov  %l6, %o0                                  
400069b4:	b4 26 80 08 	sub  %i2, %o0, %i2                             
  } else {                                                            
    unsigned_num = (unsigned long) num;                               
  }                                                                   
                                                                      
  count = 0;                                                          
  while ((n = unsigned_num / base) > 0) {                             
400069b8:	92 10 00 15 	mov  %l5, %o1                                  
    toPrint[count++] = (char) (unsigned_num - (n * base));            
400069bc:	f4 2c 00 1b 	stb  %i2, [ %l0 + %i3 ]                        
  } else {                                                            
    unsigned_num = (unsigned long) num;                               
  }                                                                   
                                                                      
  count = 0;                                                          
  while ((n = unsigned_num / base) > 0) {                             
400069c0:	90 10 00 1c 	mov  %i4, %o0                                  
400069c4:	40 00 47 ac 	call  40018874 <.udiv>                         
400069c8:	b4 10 00 1c 	mov  %i4, %i2                                  
400069cc:	80 a2 20 00 	cmp  %o0, 0                                    
400069d0:	12 bf ff f5 	bne  400069a4 <vprintk+0x13c>                  
400069d4:	b6 06 e0 01 	inc  %i3                                       
400069d8:	b4 06 e0 01 	add  %i3, 1, %i2                               
    toPrint[count++] = (char) (unsigned_num - (n * base));            
    unsigned_num = n;                                                 
  }                                                                   
  toPrint[count++] = (char) unsigned_num;                             
400069dc:	b6 07 80 1b 	add  %fp, %i3, %i3                             
400069e0:	f8 2e ff e8 	stb  %i4, [ %i3 + -24 ]                        
400069e4:	a9 2d 20 18 	sll  %l4, 0x18, %l4                            
                                                                      
  for (n=maxwidth ; n > count; n-- )                                  
400069e8:	80 a6 80 1d 	cmp  %i2, %i5                                  
400069ec:	1a 80 00 08 	bcc  40006a0c <vprintk+0x1a4>                  
400069f0:	a9 3d 20 18 	sra  %l4, 0x18, %l4                            
    rtems_putc(lead);                                                 
400069f4:	40 00 16 10 	call  4000c234 <rtems_putc>                    
400069f8:	90 10 00 14 	mov  %l4, %o0                                  
    toPrint[count++] = (char) (unsigned_num - (n * base));            
    unsigned_num = n;                                                 
  }                                                                   
  toPrint[count++] = (char) unsigned_num;                             
                                                                      
  for (n=maxwidth ; n > count; n-- )                                  
400069fc:	ba 07 7f ff 	add  %i5, -1, %i5                              
40006a00:	80 a6 80 1d 	cmp  %i2, %i5                                  
40006a04:	0a bf ff fc 	bcs  400069f4 <vprintk+0x18c>                  
40006a08:	01 00 00 00 	nop                                            
    rtems_putc(lead);                                                 
                                                                      
  for (n = 0; n < count; n++) {                                       
40006a0c:	80 a6 a0 00 	cmp  %i2, 0                                    
40006a10:	22 80 00 0d 	be,a   40006a44 <vprintk+0x1dc>                <== NEVER TAKEN
40006a14:	d0 0e 20 01 	ldub  [ %i0 + 1 ], %o0                         <== NOT EXECUTED
    rtems_putc("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]);      
40006a18:	ba 06 bf ff 	add  %i2, -1, %i5                              
40006a1c:	b8 14 a3 e8 	or  %l2, 0x3e8, %i4                            
 *  console is not yet initialized or in ISR's.                       
 *                                                                    
 * Arguments:                                                         
 *    as in printf: fmt - format string, ... - unnamed arguments.     
 */                                                                   
void vprintk(                                                         
40006a20:	ba 04 00 1d 	add  %l0, %i5, %i5                             
                                                                      
  for (n=maxwidth ; n > count; n-- )                                  
    rtems_putc(lead);                                                 
                                                                      
  for (n = 0; n < count; n++) {                                       
    rtems_putc("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]);      
40006a24:	c2 4f 40 00 	ldsb  [ %i5 ], %g1                             
40006a28:	ba 07 7f ff 	add  %i5, -1, %i5                              
40006a2c:	40 00 16 02 	call  4000c234 <rtems_putc>                    
40006a30:	d0 4f 00 01 	ldsb  [ %i4 + %g1 ], %o0                       
  toPrint[count++] = (char) unsigned_num;                             
                                                                      
  for (n=maxwidth ; n > count; n-- )                                  
    rtems_putc(lead);                                                 
                                                                      
  for (n = 0; n < count; n++) {                                       
40006a34:	80 a7 40 11 	cmp  %i5, %l1                                  
40006a38:	32 bf ff fc 	bne,a   40006a28 <vprintk+0x1c0>               
40006a3c:	c2 4f 40 00 	ldsb  [ %i5 ], %g1                             
void vprintk(                                                         
  const char *fmt,                                                    
  va_list     ap                                                      
)                                                                     
{                                                                     
  for (; *fmt != '\0'; fmt++) {                                       
40006a40:	d0 0e 20 01 	ldub  [ %i0 + 1 ], %o0                         
40006a44:	91 2a 20 18 	sll  %o0, 0x18, %o0                            
40006a48:	80 a2 20 00 	cmp  %o0, 0                                    
40006a4c:	12 bf ff 90 	bne  4000688c <vprintk+0x24>                   <== ALWAYS TAKEN
40006a50:	b0 06 20 01 	inc  %i0                                       
40006a54:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40006a58:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    if ( c == 'o' || c == 'O' ) {                                     
      base = 8; sign = false;                                         
    } else if ( c == 'i' || c == 'I' ||                               
                c == 'd' || c == 'D' ) {                              
      base = 10; sign = true;                                         
    } else if ( c == 'u' || c == 'U' ) {                              
40006a5c:	22 80 00 7e 	be,a   40006c54 <vprintk+0x3ec>                
40006a60:	82 10 20 00 	clr  %g1                                       
      base = 10; sign = false;                                        
    } else if ( c == 'x' || c == 'X' ) {                              
40006a64:	80 a0 60 58 	cmp  %g1, 0x58                                 
40006a68:	02 80 00 7d 	be  40006c5c <vprintk+0x3f4>                   
40006a6c:	82 10 20 00 	clr  %g1                                       
      base = 16; sign = false;                                        
    } else if ( c == 'p' ) {                                          
40006a70:	80 a2 20 70 	cmp  %o0, 0x70                                 
40006a74:	02 bf ff bf 	be  40006970 <vprintk+0x108>                   
40006a78:	aa 10 20 10 	mov  0x10, %l5                                 
      base = 16; sign = false; lflag = true;                          
    } else {                                                          
      rtems_putc(c);                                                  
40006a7c:	40 00 15 ee 	call  4000c234 <rtems_putc>                    
40006a80:	01 00 00 00 	nop                                            
void vprintk(                                                         
  const char *fmt,                                                    
  va_list     ap                                                      
)                                                                     
{                                                                     
  for (; *fmt != '\0'; fmt++) {                                       
40006a84:	d0 0e 20 01 	ldub  [ %i0 + 1 ], %o0                         
40006a88:	91 2a 20 18 	sll  %o0, 0x18, %o0                            
40006a8c:	80 a2 20 00 	cmp  %o0, 0                                    
40006a90:	12 bf ff 7f 	bne  4000688c <vprintk+0x24>                   
40006a94:	b0 06 20 01 	inc  %i0                                       
40006a98:	30 80 00 6d 	b,a   40006c4c <vprintk+0x3e4>                 
      continue;                                                       
    }                                                                 
                                                                      
    /* must be a numeric format or something unsupported */           
    if ( c == 'o' || c == 'O' ) {                                     
      base = 8; sign = false;                                         
40006a9c:	82 10 20 00 	clr  %g1                                       
40006aa0:	aa 10 20 08 	mov  8, %l5                                    
  unsigned long unsigned_num;                                         
  unsigned long n;                                                    
  unsigned count;                                                     
  char toPrint[20];                                                   
                                                                      
  if ( sign && (num <  0) ) {                                         
40006aa4:	80 a6 a0 00 	cmp  %i2, 0                                    
40006aa8:	16 bf ff b6 	bge  40006980 <vprintk+0x118>                  <== ALWAYS TAKEN
40006aac:	b2 06 60 04 	add  %i1, 4, %i1                               
40006ab0:	80 88 60 ff 	btst  0xff, %g1                                
40006ab4:	02 bf ff b4 	be  40006984 <vprintk+0x11c>                   
40006ab8:	90 10 00 1a 	mov  %i2, %o0                                  
    rtems_putc('-');                                                  
40006abc:	40 00 15 de 	call  4000c234 <rtems_putc>                    
40006ac0:	90 10 20 2d 	mov  0x2d, %o0                                 
    unsigned_num = (unsigned long) -num;                              
    if (maxwidth) maxwidth--;                                         
40006ac4:	80 a0 00 1d 	cmp  %g0, %i5                                  
  unsigned count;                                                     
  char toPrint[20];                                                   
                                                                      
  if ( sign && (num <  0) ) {                                         
    rtems_putc('-');                                                  
    unsigned_num = (unsigned long) -num;                              
40006ac8:	b4 20 00 1a 	neg  %i2                                       
    if (maxwidth) maxwidth--;                                         
40006acc:	ba 67 60 00 	subx  %i5, 0, %i5                              
  } else {                                                            
    unsigned_num = (unsigned long) num;                               
  }                                                                   
                                                                      
  count = 0;                                                          
  while ((n = unsigned_num / base) > 0) {                             
40006ad0:	90 10 00 1a 	mov  %i2, %o0                                  
40006ad4:	40 00 47 68 	call  40018874 <.udiv>                         
40006ad8:	92 10 00 15 	mov  %l5, %o1                                  
40006adc:	b8 92 20 00 	orcc  %o0, 0, %i4                              
40006ae0:	32 bf ff af 	bne,a   4000699c <vprintk+0x134>               <== ALWAYS TAKEN
40006ae4:	ac 10 00 15 	mov  %l5, %l6                                  
40006ae8:	b8 10 00 1a 	mov  %i2, %i4                                  <== NOT EXECUTED
    if (maxwidth) maxwidth--;                                         
  } else {                                                            
    unsigned_num = (unsigned long) num;                               
  }                                                                   
                                                                      
  count = 0;                                                          
40006aec:	b6 10 20 00 	clr  %i3                                       
  while ((n = unsigned_num / base) > 0) {                             
40006af0:	10 bf ff bb 	b  400069dc <vprintk+0x174>                    
40006af4:	b4 10 20 01 	mov  1, %i2                                    
      fmt++;                                                          
    }                                                                 
                                                                      
    if ((c = *fmt) == 'l') {                                          
      lflag = true;                                                   
      c = *++fmt;                                                     
40006af8:	c2 0e 20 01 	ldub  [ %i0 + 1 ], %g1                         
40006afc:	85 28 60 18 	sll  %g1, 0x18, %g2                            
    }                                                                 
    if ( c == 'c' ) {                                                 
40006b00:	91 38 a0 18 	sra  %g2, 0x18, %o0                            
40006b04:	80 a2 20 63 	cmp  %o0, 0x63                                 
40006b08:	12 bf ff 8a 	bne  40006930 <vprintk+0xc8>                   <== ALWAYS TAKEN
40006b0c:	b0 06 20 01 	inc  %i0                                       
      /* need a cast here since va_arg() only takes fully promoted types */
      char chr = (char) va_arg(ap, int);                              
40006b10:	d0 06 40 00 	ld  [ %i1 ], %o0                               <== NOT EXECUTED
40006b14:	b2 06 60 04 	add  %i1, 4, %i1                               
      rtems_putc(chr);                                                
40006b18:	91 2a 20 18 	sll  %o0, 0x18, %o0                            
40006b1c:	40 00 15 c6 	call  4000c234 <rtems_putc>                    
40006b20:	91 3a 20 18 	sra  %o0, 0x18, %o0                            
void vprintk(                                                         
  const char *fmt,                                                    
  va_list     ap                                                      
)                                                                     
{                                                                     
  for (; *fmt != '\0'; fmt++) {                                       
40006b24:	d0 0e 20 01 	ldub  [ %i0 + 1 ], %o0                         
40006b28:	91 2a 20 18 	sll  %o0, 0x18, %o0                            
40006b2c:	80 a2 20 00 	cmp  %o0, 0                                    
40006b30:	12 bf ff 57 	bne  4000688c <vprintk+0x24>                   
40006b34:	b0 06 20 01 	inc  %i0                                       
40006b38:	30 80 00 45 	b,a   40006c4c <vprintk+0x3e4>                 
40006b3c:	c2 0e 20 01 	ldub  [ %i0 + 1 ], %g1                         
    if (*fmt == '0' ) {                                               
      lead = '0';                                                     
      fmt++;                                                          
    }                                                                 
    if (*fmt == '-' ) {                                               
      minus = true;                                                   
40006b40:	88 10 20 01 	mov  1, %g4                                    
      fmt++;                                                          
40006b44:	b0 06 20 01 	inc  %i0                                       
40006b48:	10 bf ff 61 	b  400068cc <vprintk+0x64>                     
40006b4c:	85 28 60 18 	sll  %g1, 0x18, %g2                            
      rtems_putc(*fmt);                                               
      continue;                                                       
    }                                                                 
    fmt++;                                                            
    if (*fmt == '0' ) {                                               
      lead = '0';                                                     
40006b50:	a8 10 20 30 	mov  0x30, %l4                                 
      fmt++;                                                          
40006b54:	b0 06 20 02 	add  %i0, 2, %i0                               
40006b58:	10 bf ff 59 	b  400068bc <vprintk+0x54>                     
40006b5c:	85 28 60 18 	sll  %g1, 0x18, %g2                            
    }                                                                 
    if ( c == 's' ) {                                                 
      unsigned i, len;                                                
      char *s, *str;                                                  
                                                                      
      str = va_arg(ap, char *);                                       
40006b60:	f6 06 40 00 	ld  [ %i1 ], %i3                               
                                                                      
      if ( str == NULL ) {                                            
40006b64:	80 a6 e0 00 	cmp  %i3, 0                                    
40006b68:	02 80 00 3f 	be  40006c64 <vprintk+0x3fc>                   
40006b6c:	b2 06 60 04 	add  %i1, 4, %i1                               
        str = "";                                                     
      }                                                               
                                                                      
      /* calculate length of string */                                
      for ( len=0, s=str ; *s ; len++, s++ )                          
40006b70:	c2 4e c0 00 	ldsb  [ %i3 ], %g1                             
40006b74:	80 a0 60 00 	cmp  %g1, 0                                    
40006b78:	02 80 00 07 	be  40006b94 <vprintk+0x32c>                   
40006b7c:	b8 10 20 00 	clr  %i4                                       
40006b80:	b8 07 20 01 	inc  %i4                                       
40006b84:	c2 4e c0 1c 	ldsb  [ %i3 + %i4 ], %g1                       
40006b88:	80 a0 60 00 	cmp  %g1, 0                                    
40006b8c:	32 bf ff fe 	bne,a   40006b84 <vprintk+0x31c>               
40006b90:	b8 07 20 01 	inc  %i4                                       
        ;                                                             
                                                                      
      /* leading spaces */                                            
      if ( !minus )                                                   
40006b94:	a8 89 20 ff 	andcc  %g4, 0xff, %l4                          
40006b98:	12 80 00 0c 	bne  40006bc8 <vprintk+0x360>                  
40006b9c:	80 a7 60 00 	cmp  %i5, 0                                    
        for ( i=len ; i<width ; i++ )                                 
40006ba0:	80 a7 40 1c 	cmp  %i5, %i4                                  
40006ba4:	08 80 00 09 	bleu  40006bc8 <vprintk+0x360>                 
40006ba8:	80 a7 60 00 	cmp  %i5, 0                                    
40006bac:	b4 10 00 1c 	mov  %i4, %i2                                  
          rtems_putc(' ');                                            
40006bb0:	40 00 15 a1 	call  4000c234 <rtems_putc>                    
40006bb4:	90 10 20 20 	mov  0x20, %o0                                 
      for ( len=0, s=str ; *s ; len++, s++ )                          
        ;                                                             
                                                                      
      /* leading spaces */                                            
      if ( !minus )                                                   
        for ( i=len ; i<width ; i++ )                                 
40006bb8:	b4 06 a0 01 	inc  %i2                                       
40006bbc:	80 a6 80 1d 	cmp  %i2, %i5                                  
40006bc0:	0a bf ff fc 	bcs  40006bb0 <vprintk+0x348>                  
40006bc4:	80 a7 60 00 	cmp  %i5, 0                                    
          rtems_putc(' ');                                            
                                                                      
      /* no width option */                                           
      if (width == 0) {                                               
40006bc8:	32 80 00 07 	bne,a   40006be4 <vprintk+0x37c>               
40006bcc:	d0 4e c0 00 	ldsb  [ %i3 ], %o0                             
          width = len;                                                
      }                                                               
                                                                      
      /* output the string */                                         
      for ( i=0 ; i<width && *str ; str++ )                           
40006bd0:	80 a7 20 00 	cmp  %i4, 0                                    
40006bd4:	22 bf ff 9c 	be,a   40006a44 <vprintk+0x1dc>                
40006bd8:	d0 0e 20 01 	ldub  [ %i0 + 1 ], %o0                         
40006bdc:	ba 10 00 1c 	mov  %i4, %i5                                  
40006be0:	d0 4e c0 00 	ldsb  [ %i3 ], %o0                             
40006be4:	80 a2 20 00 	cmp  %o0, 0                                    
40006be8:	02 80 00 08 	be  40006c08 <vprintk+0x3a0>                   <== NEVER TAKEN
40006bec:	b6 06 e0 01 	inc  %i3                                       
        rtems_putc(*str);                                             
40006bf0:	40 00 15 91 	call  4000c234 <rtems_putc>                    
40006bf4:	01 00 00 00 	nop                                            
      if (width == 0) {                                               
          width = len;                                                
      }                                                               
                                                                      
      /* output the string */                                         
      for ( i=0 ; i<width && *str ; str++ )                           
40006bf8:	d0 4e c0 00 	ldsb  [ %i3 ], %o0                             
40006bfc:	80 a2 20 00 	cmp  %o0, 0                                    
40006c00:	12 bf ff fc 	bne  40006bf0 <vprintk+0x388>                  
40006c04:	b6 06 e0 01 	inc  %i3                                       
        rtems_putc(*str);                                             
                                                                      
      /* trailing spaces */                                           
      if ( minus )                                                    
40006c08:	80 a5 20 00 	cmp  %l4, 0                                    
40006c0c:	22 bf ff 8e 	be,a   40006a44 <vprintk+0x1dc>                
40006c10:	d0 0e 20 01 	ldub  [ %i0 + 1 ], %o0                         
        for ( i=len ; i<width ; i++ )                                 
40006c14:	80 a7 40 1c 	cmp  %i5, %i4                                  
40006c18:	28 bf ff 8b 	bleu,a   40006a44 <vprintk+0x1dc>              
40006c1c:	d0 0e 20 01 	ldub  [ %i0 + 1 ], %o0                         
          rtems_putc(' ');                                            
40006c20:	40 00 15 85 	call  4000c234 <rtems_putc>                    
40006c24:	90 10 20 20 	mov  0x20, %o0                                 
      for ( i=0 ; i<width && *str ; str++ )                           
        rtems_putc(*str);                                             
                                                                      
      /* trailing spaces */                                           
      if ( minus )                                                    
        for ( i=len ; i<width ; i++ )                                 
40006c28:	b8 07 20 01 	inc  %i4                                       
40006c2c:	80 a7 00 1d 	cmp  %i4, %i5                                  
40006c30:	0a bf ff fc 	bcs  40006c20 <vprintk+0x3b8>                  
40006c34:	01 00 00 00 	nop                                            
void vprintk(                                                         
  const char *fmt,                                                    
  va_list     ap                                                      
)                                                                     
{                                                                     
  for (; *fmt != '\0'; fmt++) {                                       
40006c38:	d0 0e 20 01 	ldub  [ %i0 + 1 ], %o0                         
40006c3c:	91 2a 20 18 	sll  %o0, 0x18, %o0                            
40006c40:	80 a2 20 00 	cmp  %o0, 0                                    
40006c44:	12 bf ff 12 	bne  4000688c <vprintk+0x24>                   <== ALWAYS TAKEN
40006c48:	b0 06 20 01 	inc  %i0                                       
40006c4c:	81 c7 e0 08 	ret                                            
40006c50:	81 e8 00 00 	restore                                        
      base = 8; sign = false;                                         
    } else if ( c == 'i' || c == 'I' ||                               
                c == 'd' || c == 'D' ) {                              
      base = 10; sign = true;                                         
    } else if ( c == 'u' || c == 'U' ) {                              
      base = 10; sign = false;                                        
40006c54:	10 bf ff 47 	b  40006970 <vprintk+0x108>                    
40006c58:	aa 10 20 0a 	mov  0xa, %l5                                  
    } else if ( c == 'x' || c == 'X' ) {                              
      base = 16; sign = false;                                        
    } else if ( c == 'p' ) {                                          
      base = 16; sign = false; lflag = true;                          
40006c5c:	10 bf ff 45 	b  40006970 <vprintk+0x108>                    
40006c60:	aa 10 20 10 	mov  0x10, %l5                                 
      char *s, *str;                                                  
                                                                      
      str = va_arg(ap, char *);                                       
                                                                      
      if ( str == NULL ) {                                            
        str = "";                                                     
40006c64:	10 bf ff c3 	b  40006b70 <vprintk+0x308>                    
40006c68:	b6 14 e3 f0 	or  %l3, 0x3f0, %i3                            
                                                                      

4001b918 <write>: ssize_t write( int fd, const void *buffer, size_t count ) {
4001b918:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_libio_t     *iop;                                             
                                                                      
  rtems_libio_check_fd( fd );                                         
4001b91c:	03 10 00 78 	sethi  %hi(0x4001e000), %g1                    
4001b920:	c2 00 63 a4 	ld  [ %g1 + 0x3a4 ], %g1	! 4001e3a4 <rtems_libio_number_iops>
4001b924:	80 a6 00 01 	cmp  %i0, %g1                                  
4001b928:	1a 80 00 18 	bcc  4001b988 <write+0x70>                     
4001b92c:	03 10 00 7b 	sethi  %hi(0x4001ec00), %g1                    
  iop = rtems_libio_iop( fd );                                        
4001b930:	d0 00 61 30 	ld  [ %g1 + 0x130 ], %o0	! 4001ed30 <rtems_libio_iops>
4001b934:	83 2e 20 03 	sll  %i0, 3, %g1                               
4001b938:	b1 2e 20 06 	sll  %i0, 6, %i0                               
4001b93c:	b0 26 00 01 	sub  %i0, %g1, %i0                             
4001b940:	90 02 00 18 	add  %o0, %i0, %o0                             
  rtems_libio_check_is_open( iop );                                   
4001b944:	c2 02 20 10 	ld  [ %o0 + 0x10 ], %g1                        
4001b948:	80 88 61 00 	btst  0x100, %g1                               
4001b94c:	02 80 00 0f 	be  4001b988 <write+0x70>                      
4001b950:	80 a6 60 00 	cmp  %i1, 0                                    
  rtems_libio_check_buffer( buffer );                                 
4001b954:	02 80 00 13 	be  4001b9a0 <write+0x88>                      <== NEVER TAKEN
4001b958:	80 a6 a0 00 	cmp  %i2, 0                                    
  rtems_libio_check_count( count );                                   
4001b95c:	02 80 00 0f 	be  4001b998 <write+0x80>                      
4001b960:	b0 10 20 00 	clr  %i0                                       
  rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
4001b964:	80 88 60 04 	btst  4, %g1                                   
4001b968:	02 80 00 08 	be  4001b988 <write+0x70>                      
4001b96c:	92 10 00 19 	mov  %i1, %o1                                  
                                                                      
  /*                                                                  
   *  Now process the write() request.                                
   */                                                                 
  return (*iop->pathinfo.handlers->write_h)( iop, buffer, count );    
4001b970:	c2 02 20 24 	ld  [ %o0 + 0x24 ], %g1                        
4001b974:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
4001b978:	9f c0 40 00 	call  %g1                                      
4001b97c:	94 10 00 1a 	mov  %i2, %o2                                  
}                                                                     
4001b980:	81 c7 e0 08 	ret                                            
4001b984:	91 e8 00 08 	restore  %g0, %o0, %o0                         
  rtems_libio_check_fd( fd );                                         
  iop = rtems_libio_iop( fd );                                        
  rtems_libio_check_is_open( iop );                                   
  rtems_libio_check_buffer( buffer );                                 
  rtems_libio_check_count( count );                                   
  rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
4001b988:	7f ff cf 6e 	call  4000f740 <__errno>                       
4001b98c:	b0 10 3f ff 	mov  -1, %i0                                   
4001b990:	82 10 20 09 	mov  9, %g1                                    
4001b994:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4001b998:	81 c7 e0 08 	ret                                            
4001b99c:	81 e8 00 00 	restore                                        
  rtems_libio_t     *iop;                                             
                                                                      
  rtems_libio_check_fd( fd );                                         
  iop = rtems_libio_iop( fd );                                        
  rtems_libio_check_is_open( iop );                                   
  rtems_libio_check_buffer( buffer );                                 
4001b9a0:	7f ff cf 68 	call  4000f740 <__errno>                       <== NOT EXECUTED
4001b9a4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4001b9a8:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
4001b9ac:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4001b9b0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001b9b4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40007854 <writev>: ssize_t writev( int fd, const struct iovec *iov, int iovcnt ) {
40007854:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int            bytes;                                               
  rtems_libio_t *iop;                                                 
  ssize_t        old;                                                 
  bool           all_zeros;                                           
                                                                      
  rtems_libio_check_fd( fd );                                         
40007858:	03 10 00 5d 	sethi  %hi(0x40017400), %g1                    
4000785c:	c2 00 63 d4 	ld  [ %g1 + 0x3d4 ], %g1	! 400177d4 <rtems_libio_number_iops>
40007860:	80 a6 00 01 	cmp  %i0, %g1                                  
40007864:	1a 80 00 4d 	bcc  40007998 <writev+0x144>                   
40007868:	03 10 00 60 	sethi  %hi(0x40018000), %g1                    
  iop = rtems_libio_iop( fd );                                        
4000786c:	f6 00 61 2c 	ld  [ %g1 + 0x12c ], %i3	! 4001812c <rtems_libio_iops>
40007870:	83 2e 20 03 	sll  %i0, 3, %g1                               
40007874:	b1 2e 20 06 	sll  %i0, 6, %i0                               
40007878:	b0 26 00 01 	sub  %i0, %g1, %i0                             
4000787c:	b6 06 c0 18 	add  %i3, %i0, %i3                             
  rtems_libio_check_is_open( iop );                                   
40007880:	c2 06 e0 10 	ld  [ %i3 + 0x10 ], %g1                        
40007884:	80 88 61 00 	btst  0x100, %g1                               
40007888:	02 80 00 44 	be  40007998 <writev+0x144>                    
4000788c:	80 88 60 04 	btst  4, %g1                                   
  rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
40007890:	02 80 00 42 	be  40007998 <writev+0x144>                    <== NEVER TAKEN
40007894:	80 a6 60 00 	cmp  %i1, 0                                    
                                                                      
  /*                                                                  
   *  Argument validation on IO vector                                
   */                                                                 
  if ( !iov )                                                         
40007898:	02 80 00 3a 	be  40007980 <writev+0x12c>                    
4000789c:	80 a6 a0 00 	cmp  %i2, 0                                    
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( iovcnt <= 0 )                                                  
400078a0:	04 80 00 38 	ble  40007980 <writev+0x12c>                   
400078a4:	80 a6 a4 00 	cmp  %i2, 0x400                                
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( iovcnt > IOV_MAX )                                             
400078a8:	14 80 00 36 	bg  40007980 <writev+0x12c>                    <== NEVER TAKEN
400078ac:	b5 2e a0 03 	sll  %i2, 3, %i2                               
#include <sys/uio.h>                                                  
                                                                      
#include <rtems/libio_.h>                                             
#include <rtems/seterr.h>                                             
                                                                      
ssize_t writev(                                                       
400078b0:	82 10 20 00 	clr  %g1                                       
400078b4:	ba 10 20 01 	mov  1, %i5                                    
400078b8:	84 10 20 00 	clr  %g2                                       
                                                                      
    /*                                                                
     *  iov[v].iov_len cannot be less than 0 because size_t is unsigned.
     *  So we only check for zero.                                    
     */                                                               
    if ( iov[v].iov_base == 0 )                                       
400078bc:	c6 06 40 01 	ld  [ %i1 + %g1 ], %g3                         
#include <sys/uio.h>                                                  
                                                                      
#include <rtems/libio_.h>                                             
#include <rtems/seterr.h>                                             
                                                                      
ssize_t writev(                                                       
400078c0:	b8 06 40 01 	add  %i1, %g1, %i4                             
                                                                      
    /*                                                                
     *  iov[v].iov_len cannot be less than 0 because size_t is unsigned.
     *  So we only check for zero.                                    
     */                                                               
    if ( iov[v].iov_base == 0 )                                       
400078c4:	80 a0 e0 00 	cmp  %g3, 0                                    
400078c8:	02 80 00 2e 	be  40007980 <writev+0x12c>                    
400078cc:	88 10 20 01 	mov  1, %g4                                    
      rtems_set_errno_and_return_minus_one( EINVAL );                 
                                                                      
    if ( iov[v].iov_len )                                             
400078d0:	c6 07 20 04 	ld  [ %i4 + 4 ], %g3                           
400078d4:	82 00 60 08 	add  %g1, 8, %g1                               
      all_zeros = false;                                              
400078d8:	80 a0 00 03 	cmp  %g0, %g3                                  
400078dc:	b8 40 3f ff 	addx  %g0, -1, %i4                             
                                                                      
    /* check for wrap */                                              
    old    = total;                                                   
    total += iov[v].iov_len;                                          
    if ( total < old || total > SSIZE_MAX )                           
400078e0:	86 80 c0 02 	addcc  %g3, %g2, %g3                           
400078e4:	0c 80 00 27 	bneg  40007980 <writev+0x12c>                  
400078e8:	ba 0f 40 1c 	and  %i5, %i4, %i5                             
400078ec:	80 a0 80 03 	cmp  %g2, %g3                                  
400078f0:	24 80 00 02 	ble,a   400078f8 <writev+0xa4>                 
400078f4:	88 10 20 00 	clr  %g4                                       
400078f8:	80 89 20 ff 	btst  0xff, %g4                                
400078fc:	12 80 00 21 	bne  40007980 <writev+0x12c>                   
40007900:	80 a0 40 1a 	cmp  %g1, %i2                                  
   *  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++ ) {                    
40007904:	12 bf ff ee 	bne  400078bc <writev+0x68>                    
40007908:	84 10 00 03 	mov  %g3, %g2                                  
  }                                                                   
                                                                      
  /*                                                                  
   * A writev with all zeros is supposed to have no effect per OpenGroup.
   */                                                                 
  if ( all_zeros == true ) {                                          
4000790c:	80 8f 60 ff 	btst  0xff, %i5                                
40007910:	12 80 00 1a 	bne  40007978 <writev+0x124>                   
40007914:	b0 10 20 00 	clr  %i0                                       
40007918:	10 80 00 05 	b  4000792c <writev+0xd8>                      
4000791c:	ba 10 20 00 	clr  %i5                                       
  }                                                                   
                                                                      
  /*                                                                  
   *  Now process the writev().                                       
   */                                                                 
  for ( total=0, v=0 ; v < iovcnt ; v++ ) {                           
40007920:	80 a7 40 1a 	cmp  %i5, %i2                                  
40007924:	02 80 00 21 	be  400079a8 <writev+0x154>                    
40007928:	01 00 00 00 	nop                                            
#include <sys/uio.h>                                                  
                                                                      
#include <rtems/libio_.h>                                             
#include <rtems/seterr.h>                                             
                                                                      
ssize_t writev(                                                       
4000792c:	b8 06 40 1d 	add  %i1, %i5, %i4                             
  /*                                                                  
   *  Now process the writev().                                       
   */                                                                 
  for ( total=0, v=0 ; v < iovcnt ; v++ ) {                           
    /* all zero lengths has no effect */                              
    if ( iov[v].iov_len == 0 )                                        
40007930:	d4 07 20 04 	ld  [ %i4 + 4 ], %o2                           
40007934:	80 a2 a0 00 	cmp  %o2, 0                                    
40007938:	22 bf ff fa 	be,a   40007920 <writev+0xcc>                  <== NEVER TAKEN
4000793c:	ba 07 60 08 	add  %i5, 8, %i5                               <== NOT EXECUTED
      continue;                                                       
                                                                      
    bytes = (*iop->pathinfo.handlers->write_h)(                       
40007940:	c2 06 e0 24 	ld  [ %i3 + 0x24 ], %g1                        
40007944:	d2 06 40 1d 	ld  [ %i1 + %i5 ], %o1                         
40007948:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
4000794c:	9f c0 40 00 	call  %g1                                      
40007950:	90 10 00 1b 	mov  %i3, %o0                                  
      iop,                                                            
      iov[v].iov_base,                                                
      iov[v].iov_len                                                  
    );                                                                
                                                                      
    if ( bytes < 0 )                                                  
40007954:	80 a2 20 00 	cmp  %o0, 0                                    
40007958:	06 80 00 16 	bl  400079b0 <writev+0x15c>                    <== NEVER TAKEN
4000795c:	01 00 00 00 	nop                                            
      return -1;                                                      
                                                                      
    if ( bytes > 0 ) {                                                
40007960:	32 80 00 02 	bne,a   40007968 <writev+0x114>                <== ALWAYS TAKEN
40007964:	b0 06 00 08 	add  %i0, %o0, %i0                             
      total       += bytes;                                           
    }                                                                 
                                                                      
    if (bytes != iov[ v ].iov_len)                                    
40007968:	c2 07 20 04 	ld  [ %i4 + 4 ], %g1                           
4000796c:	80 a2 00 01 	cmp  %o0, %g1                                  
40007970:	02 bf ff ec 	be  40007920 <writev+0xcc>                     <== ALWAYS TAKEN
40007974:	ba 07 60 08 	add  %i5, 8, %i5                               
      break;                                                          
  }                                                                   
                                                                      
  return total;                                                       
}                                                                     
40007978:	81 c7 e0 08 	ret                                            
4000797c:	81 e8 00 00 	restore                                        
                                                                      
    /* check for wrap */                                              
    old    = total;                                                   
    total += iov[v].iov_len;                                          
    if ( total < old || total > SSIZE_MAX )                           
      rtems_set_errno_and_return_minus_one( EINVAL );                 
40007980:	40 00 21 c1 	call  40010084 <__errno>                       
40007984:	b0 10 3f ff 	mov  -1, %i0                                   
40007988:	82 10 20 16 	mov  0x16, %g1                                 
4000798c:	c2 22 00 00 	st  %g1, [ %o0 ]                               
40007990:	81 c7 e0 08 	ret                                            
40007994:	81 e8 00 00 	restore                                        
  bool           all_zeros;                                           
                                                                      
  rtems_libio_check_fd( fd );                                         
  iop = rtems_libio_iop( fd );                                        
  rtems_libio_check_is_open( iop );                                   
  rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
40007998:	40 00 21 bb 	call  40010084 <__errno>                       
4000799c:	b0 10 3f ff 	mov  -1, %i0                                   
400079a0:	82 10 20 09 	mov  9, %g1                                    
400079a4:	c2 22 00 00 	st  %g1, [ %o0 ]                               
400079a8:	81 c7 e0 08 	ret                                            
400079ac:	81 e8 00 00 	restore                                        
    if (bytes != iov[ v ].iov_len)                                    
      break;                                                          
  }                                                                   
                                                                      
  return total;                                                       
}                                                                     
400079b0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400079b4:	91 e8 3f ff 	restore  %g0, -1, %o0                          <== NOT EXECUTED